From 9827764fca5baf47ab92e3a00b440bbcef3e0f69 Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Fri, 11 Sep 2026 12:45:16 +0530
Subject: [PATCH 01/42] extractor: Add staged source-aware extraction

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 README.md                 |   9 +-
 src/lib.rs                | 580 +++++++++++++++++++++++++++++++-------
 src/main.rs               |  13 +-
 src/python.rs             |   6 +
 tests/delta_extraction.rs | 520 ++++++++++++++++++++++++++++++++++
 tests/python_smoke.py     |   4 +-
 6 files changed, 1029 insertions(+), 103 deletions(-)
 create mode 100644 tests/delta_extraction.rs

diff --git a/README.md b/README.md
index 5da5dd6..3bdc4d2 100644
--- a/README.md
+++ b/README.md
@@ -80,6 +80,9 @@ otadump ota.zip
 
 # Run on payload.bin file.
 otadump payload.bin
+
+# Apply a SOURCE_COPY delta payload with matching base partition images.
+otadump delta.zip --output-dir output --source-dir source-images
 ```
 
 ### Python
@@ -97,11 +100,13 @@ otadump.extract(
     Path("output"),
     partitions=["boot", "system"],
     overwrite=True,
+    source_dir=Path("source-images"),
 )
 ```
 
-The optional keyword arguments are `num_threads`, `overwrite`, `partitions`,
-and `verify`. Extraction releases the Python GIL.
+The optional keyword arguments are `num_threads`, `overwrite`, `partitions`, `verify`, and `source_dir`.
+Set `source_dir` to a directory containing matching base partition images for supported delta operations.
+Extraction releases the Python GIL.
 
 ## Contributors
 
diff --git a/src/lib.rs b/src/lib.rs
index 5da31f5..87ea92a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,11 +9,11 @@ mod python;
 
 use std::cmp::Reverse;
 use std::collections::HashSet;
-use std::fs::{self, File, OpenOptions};
+use std::fs::{self, File};
 use std::io::Read;
 use std::num::NonZero;
-use std::ops::Mul;
-use std::path::Path;
+use std::ops::Range;
+use std::path::{Component, Path, PathBuf};
 use std::sync::OnceLock;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::{error, result, slice, thread};
@@ -28,6 +28,7 @@ use prost::Message as _;
 use rayon::{BroadcastContext, ThreadPoolBuilder};
 use ring::digest;
 use sync_unsafe_cell::SyncUnsafeCell;
+use tempfile::TempPath;
 use zip::ZipArchive;
 use zip::result::ZipError;
 use zstd::Decoder as ZstdDecoder;
@@ -44,6 +45,7 @@ pub struct ExtractOptions<'a> {
     partitions: Option<HashSet<String>>,
     progress_reporter: &'a dyn ProgressReporter,
     verify: bool,
+    source_dir: Option<PathBuf>,
 }
 
 impl<'a> ExtractOptions<'a> {
@@ -55,6 +57,7 @@ impl<'a> ExtractOptions<'a> {
             partitions: None,
             progress_reporter: &NoOpProgressReporter,
             verify: true,
+            source_dir: None,
         }
     }
 
@@ -97,24 +100,21 @@ impl<'a> ExtractOptions<'a> {
 
         let extract_ops =
             manifest.partitions.iter().map(|update| update.operations.len()).sum::<usize>();
-        let verify_ops = if self.verify {
-            manifest
-                .partitions
-                .iter()
-                .map(|update| {
-                    let partition_size =
-                        update.new_partition_info.as_ref().and_then(|info| info.size).unwrap_or(0)
-                            as usize;
-                    partition_size.div_ceil(VERIFY_CHUNK_SIZE)
-                })
-                .sum()
-        } else {
-            0
-        };
+        let verify_ops: usize = manifest
+            .partitions
+            .iter()
+            .map(|update| {
+                let partition_size =
+                    update.new_partition_info.as_ref().and_then(|info| info.size).unwrap_or(0)
+                        as usize;
+                partition_size.div_ceil(VERIFY_CHUNK_SIZE)
+            })
+            .sum();
         let total_ops = extract_ops + verify_ops;
         let total_ops_completed = AtomicUsize::new(0);
 
         let block_size = manifest.block_size.context("block_size not defined")? as usize;
+        ensure!(block_size > 0, "block_size must be greater than zero");
 
         // Ensure that all partitions to be extracted are present in the manifest.
         for partition_name in self.partitions.iter().flatten() {
@@ -127,6 +127,51 @@ impl<'a> ExtractOptions<'a> {
         fs::create_dir_all(output_dir)
             .with_context(|| format!("Could not create output directory: {output_dir:?}"))?;
 
+        let sources = manifest
+            .partitions
+            .iter()
+            .map(|update| self.validate_partition(update, &payload, block_size))
+            .collect::<Result<Vec<_>>>()?;
+
+        let mut partition_names = HashSet::with_capacity(manifest.partitions.len());
+        let mut destinations = Vec::with_capacity(manifest.partitions.len());
+        for update in &manifest.partitions {
+            ensure!(
+                partition_names.insert(&update.partition_name),
+                "Duplicate partition mapping: {:?}",
+                update.partition_name
+            );
+            destinations.push(output_dir.join(format!("{}.img", update.partition_name)));
+        }
+        for (update, destination) in manifest.partitions.iter().zip(&destinations) {
+            for source in sources.iter().flatten() {
+                ensure!(
+                    !paths_alias(&source.path, destination)?,
+                    "Source partition image {:?} and destination partition image {destination:?} refer to the same file",
+                    source.path,
+                );
+            }
+            if !self.overwrite {
+                ensure!(
+                    !path_entry_exists(destination)?,
+                    "Destination partition image already exists for {:?}: {destination:?}",
+                    update.partition_name
+                );
+            }
+        }
+
+        let staging_dir = tempfile::Builder::new()
+            .prefix(".otadump-")
+            .tempdir_in(output_dir)
+            .context("Unable to create staging directory")?;
+        let mut staging_paths = Vec::with_capacity(manifest.partitions.len());
+        let mut partitions = Vec::with_capacity(manifest.partitions.len());
+        for update in &manifest.partitions {
+            let (path, partition) = self.create_staged_partition(update, staging_dir.path())?;
+            staging_paths.push(path);
+            partitions.push(partition);
+        }
+
         let num_threads = self
             .num_threads
             .unwrap_or_else(|| thread::available_parallelism().map(NonZero::get).unwrap_or(1))
@@ -137,20 +182,22 @@ impl<'a> ExtractOptions<'a> {
             .context("Unable to start threadpool")?;
         let mut error = OnceLock::new();
 
-        threadpool.in_place_scope_fifo(|scope| -> Result<()> {
-            for update in &manifest.partitions {
+        threadpool.in_place_scope_fifo(|scope| {
+            for ((update, source), partition) in
+                manifest.partitions.iter().zip(sources).zip(partitions)
+            {
                 // Exit early if an error has occurred.
                 if error.get().is_some() {
                     break;
                 }
 
                 // Create and broadcast a task to the threadpool.
-                let partition = self.open_partition_file(update, output_dir)?;
                 let task = Task {
                     payload: &payload,
                     block_size,
                     verify: self.verify,
                     update,
+                    source,
                     op_idx: AtomicUsize::new(0),
                     partition: SyncUnsafeCell::new(partition),
                     total_ops,
@@ -164,13 +211,21 @@ impl<'a> ExtractOptions<'a> {
                     }
                 });
             }
-            Ok(())
-        })?;
+        });
 
         if let Some(e) = error.take() {
             return Err(e);
         }
 
+        for (staging_path, destination) in staging_paths.into_iter().zip(destinations) {
+            let result = if self.overwrite {
+                staging_path.persist(&destination)
+            } else {
+                staging_path.persist_noclobber(&destination)
+            };
+            result.map_err(|error| error.error)?;
+        }
+
         self.progress_reporter.report_progress(1.);
         Ok(())
     }
@@ -219,33 +274,162 @@ impl<'a> ExtractOptions<'a> {
         }
     }
 
-    fn open_partition_file(
+    fn validate_partition(
         &self,
         update: &PartitionUpdate,
-        partition_dir: impl AsRef<Path>,
-    ) -> Result<MmapMut> {
+        payload: &Payload<'_>,
+        block_size: usize,
+    ) -> Result<Option<SourcePartition>> {
+        validate_partition_name(&update.partition_name)?;
+
         let partition_len = update
             .new_partition_info
             .as_ref()
             .and_then(|info| info.size)
             .context("Unable to determine output file size")?;
+        let partition_len =
+            usize::try_from(partition_len).context("Output partition is too large")?;
+        ensure!(
+            update.new_partition_info.as_ref().and_then(|info| info.hash.as_ref()).is_some(),
+            "Unable to determine output partition hash"
+        );
+
+        let needs_source = update.operations.iter().try_fold(false, |needed, op| {
+            let op_type = Type::try_from(op.r#type).context("Invalid operation")?;
+            validate_operation_type(op_type)?;
+            Ok::<_, Error>(needed || operation_needs_source(op_type))
+        })?;
+        let source = if needs_source { Some(self.open_source_partition(update)?) } else { None };
+
+        let mut destination_ranges = Vec::new();
+        for (op_index, op) in update.operations.iter().enumerate() {
+            let op_type = Type::try_from(op.r#type).context("Invalid operation")?;
+            let dst_ranges = extent_ranges(&op.dst_extents, block_size, partition_len)
+                .with_context(|| format!("Invalid destination extents for operation {op_index}"))?;
+            ensure!(!dst_ranges.is_empty(), "Operation {op_index} has no destination extents");
+            let dst_len = ranges_len(&dst_ranges)?;
+            if let Some(declared_len) = op.dst_length {
+                ensure!(
+                    usize::try_from(declared_len).ok() == Some(dst_len),
+                    "Destination length mismatch for operation {op_index}"
+                );
+            }
+            destination_ranges.extend(
+                dst_ranges
+                    .iter()
+                    .filter(|range| !range.is_empty())
+                    .map(|range| (range.clone(), op_index)),
+            );
 
-        let filename = Path::new(&update.partition_name).with_extension("img");
-        let path = partition_dir.as_ref().join(filename);
-
-        let file = OpenOptions::new()
-            .create(true)
-            .create_new(!self.overwrite)
-            .read(true)
-            .write(true)
-            .truncate(true)
-            .open(&path)
-            .with_context(|| format!("Unable to open file for writing: {path:?}"))?;
-        file.set_len(partition_len)?;
-
-        let file = unsafe { MmapMut::map_mut(&file) }
-            .with_context(|| format!("Failed to mmap file: {path:?}"))?;
-        Ok(file)
+            if operation_needs_source(op_type) {
+                let source = source.as_ref().context("Source partition was not opened")?;
+                let src_ranges = extent_ranges(&op.src_extents, block_size, source.len)
+                    .with_context(|| format!("Invalid source extents for operation {op_index}"))?;
+                ensure!(!src_ranges.is_empty(), "Operation {op_index} has no source extents");
+                let src_len = ranges_len(&src_ranges)?;
+                if let Some(declared_len) = op.src_length {
+                    ensure!(
+                        usize::try_from(declared_len).ok() == Some(src_len),
+                        "Source length mismatch for operation {op_index}"
+                    );
+                }
+                if self.verify {
+                    verify_hash_over_ranges(
+                        source.bytes(),
+                        &src_ranges,
+                        op.src_sha256_hash.as_deref(),
+                        "Source extent",
+                    )
+                    .with_context(|| {
+                        format!("Source verification failed for operation {op_index}")
+                    })?;
+                }
+            }
+
+            if operation_has_data(op_type) {
+                let data = extract_operation_data(payload, op)
+                    .with_context(|| format!("Invalid data for operation {op_index}"))?;
+                if self.verify {
+                    verify_hash(data, op.data_sha256_hash.as_deref(), "Input").with_context(
+                        || format!("Data verification failed for operation {op_index}"),
+                    )?;
+                }
+            }
+        }
+
+        destination_ranges.sort_unstable_by_key(|(range, _)| (range.start, range.end));
+        for pair in destination_ranges.windows(2) {
+            let (left, left_op) = &pair[0];
+            let (right, right_op) = &pair[1];
+            ensure!(
+                left.end <= right.start,
+                "Destination extents overlap between operations {left_op} and {right_op}"
+            );
+        }
+
+        Ok(source)
+    }
+
+    fn open_source_partition(&self, update: &PartitionUpdate) -> Result<SourcePartition> {
+        let source_dir = self.source_dir.as_ref().with_context(|| {
+            format!(
+                "Delta operations for partition {:?} require a source directory",
+                update.partition_name
+            )
+        })?;
+        let path = source_dir.join(format!("{}.img", update.partition_name));
+        let file = File::open(&path)
+            .with_context(|| format!("Unable to open source partition image: {path:?}"))?;
+        let metadata = file
+            .metadata()
+            .with_context(|| format!("Unable to inspect source partition image: {path:?}"))?;
+        ensure!(metadata.is_file(), "Source partition image is not a file: {path:?}");
+        let len = usize::try_from(metadata.len()).context("Source partition is too large")?;
+        let mmap = if len == 0 {
+            None
+        } else {
+            Some(
+                unsafe { MmapOptions::new().map(&file) }
+                    .with_context(|| format!("Failed to mmap source partition image: {path:?}"))?,
+            )
+        };
+        let source = SourcePartition { path, len, mmap };
+
+        let info =
+            update.old_partition_info.as_ref().context("Source partition info is missing")?;
+        let expected_size = info.size.context("Source partition size is missing")?;
+        ensure!(
+            usize::try_from(expected_size).ok() == Some(source.len),
+            "Source partition size mismatch for {:?}: expected {expected_size}, got {}",
+            update.partition_name,
+            source.len
+        );
+        let expected_hash = info.hash.as_deref().context("Source partition hash is missing")?;
+        verify_hash(source.bytes(), Some(expected_hash), "Source partition")?;
+        Ok(source)
+    }
+
+    fn create_staged_partition(
+        &self,
+        update: &PartitionUpdate,
+        staging_dir: &Path,
+    ) -> Result<(TempPath, MmapMut)> {
+        let partition_len = update
+            .new_partition_info
+            .as_ref()
+            .and_then(|info| info.size)
+            .context("Unable to determine output file size")?;
+        ensure!(partition_len > 0, "Output partition size must be greater than zero");
+
+        let file = tempfile::Builder::new()
+            .prefix("partition-")
+            .tempfile_in(staging_dir)
+            .context("Unable to create staged partition image")?;
+        file.as_file().set_len(partition_len)?;
+
+        let partition = unsafe { MmapMut::map_mut(file.as_file()) }
+            .context("Failed to mmap staged partition image")?;
+        Ok((file.into_temp_path(), partition))
     }
 
     /// Number of threads to use for extraction. By default, this is set to the
@@ -280,11 +464,198 @@ impl<'a> ExtractOptions<'a> {
         self
     }
 
-    /// Verify the input and output partitions. This is enabled by default.
+    /// Verify operation data and source extent hashes. This is enabled by default.
+    /// Whole source images and staged output images are always verified.
     pub fn verify(&mut self, verify: bool) -> &mut Self {
         self.verify = verify;
         self
     }
+
+    /// Set the directory containing base partition images for delta OTA extraction.
+    pub fn source_dir<P: AsRef<Path>>(&mut self, source_dir: P) -> &mut Self {
+        self.source_dir = Some(source_dir.as_ref().to_path_buf());
+        self
+    }
+}
+
+struct SourcePartition {
+    path: PathBuf,
+    len: usize,
+    mmap: Option<Mmap>,
+}
+
+impl SourcePartition {
+    fn bytes(&self) -> &[u8] {
+        self.mmap.as_deref().unwrap_or_default()
+    }
+}
+
+fn validate_partition_name(name: &str) -> Result<()> {
+    let mut components = Path::new(name).components();
+    let valid = matches!(components.next(), Some(Component::Normal(component)) if component == name)
+        && components.next().is_none()
+        && !name.contains('/')
+        && !name.contains('\\');
+    ensure!(valid, "Unsafe partition name: {name:?}");
+    Ok(())
+}
+
+#[allow(deprecated)]
+fn validate_operation_type(op_type: Type) -> Result<()> {
+    match op_type {
+        Type::Move | Type::Bsdiff => bail!("Deprecated operation is not supported: {op_type:?}"),
+        Type::Replace
+        | Type::ReplaceBz
+        | Type::SourceCopy
+        | Type::SourceBsdiff
+        | Type::Zero
+        | Type::Discard
+        | Type::ReplaceXz
+        | Type::Puffdiff
+        | Type::BrotliBsdiff
+        | Type::Zucchini
+        | Type::Lz4diffBsdiff
+        | Type::Lz4diffPuffdiff
+        | Type::ReplaceZstd => Ok(()),
+    }
+}
+
+fn operation_needs_source(op_type: Type) -> bool {
+    matches!(
+        op_type,
+        Type::SourceCopy
+            | Type::SourceBsdiff
+            | Type::Puffdiff
+            | Type::BrotliBsdiff
+            | Type::Zucchini
+            | Type::Lz4diffBsdiff
+            | Type::Lz4diffPuffdiff
+    )
+}
+
+fn operation_has_data(op_type: Type) -> bool {
+    matches!(
+        op_type,
+        Type::Replace
+            | Type::ReplaceBz
+            | Type::SourceBsdiff
+            | Type::ReplaceXz
+            | Type::Puffdiff
+            | Type::BrotliBsdiff
+            | Type::Zucchini
+            | Type::Lz4diffBsdiff
+            | Type::Lz4diffPuffdiff
+            | Type::ReplaceZstd
+    )
+}
+
+fn extent_ranges(
+    extents: &[chromeos_update_engine::Extent],
+    block_size: usize,
+    partition_len: usize,
+) -> Result<Vec<Range<usize>>> {
+    extents
+        .iter()
+        .map(|extent| {
+            let start_block =
+                usize::try_from(extent.start_block.context("start_block not defined in extent")?)
+                    .context("Extent start block is too large")?;
+            let num_blocks =
+                usize::try_from(extent.num_blocks.context("num_blocks not defined in extent")?)
+                    .context("Extent block count is too large")?;
+            let start = start_block.checked_mul(block_size).context("Extent offset overflow")?;
+            let len = num_blocks.checked_mul(block_size).context("Extent length overflow")?;
+            let end = start.checked_add(len).context("Extent end overflow")?;
+            ensure!(end <= partition_len, "Extent exceeds partition size");
+            Ok(start..end)
+        })
+        .collect()
+}
+
+fn ranges_len(ranges: &[Range<usize>]) -> Result<usize> {
+    ranges.iter().try_fold(0usize, |len, range| {
+        len.checked_add(range.len()).context("Combined extent length overflow")
+    })
+}
+
+fn extract_operation_data<'a>(payload: &'a Payload<'a>, op: &InstallOperation) -> Result<&'a [u8]> {
+    let offset = usize::try_from(op.data_offset.context("data_offset not defined")?)
+        .context("Data offset is too large")?;
+    let len = usize::try_from(op.data_length.context("data_length not defined")?)
+        .context("Data length is too large")?;
+    let end = offset.checked_add(len).context("Data range overflow")?;
+    payload.data.get(offset..end).context("Data range exceeds payload size")
+}
+
+fn verify_hash(data: &[u8], expected: Option<&[u8]>, label: &str) -> Result<()> {
+    let Some(expected) = expected else {
+        return Ok(());
+    };
+    let actual = digest::digest(&digest::SHA256, data);
+    ensure!(
+        actual.as_ref() == expected,
+        "{label} hash mismatch: expected {}, got {}",
+        hex::encode(expected),
+        hex::encode(actual.as_ref())
+    );
+    Ok(())
+}
+
+fn verify_hash_over_ranges(
+    data: &[u8],
+    ranges: &[Range<usize>],
+    expected: Option<&[u8]>,
+    label: &str,
+) -> Result<()> {
+    let Some(expected) = expected else {
+        return Ok(());
+    };
+    let mut context = digest::Context::new(&digest::SHA256);
+    for range in ranges {
+        context.update(&data[range.clone()]);
+    }
+    let actual = context.finish();
+    ensure!(
+        actual.as_ref() == expected,
+        "{label} hash mismatch: expected {}, got {}",
+        hex::encode(expected),
+        hex::encode(actual.as_ref())
+    );
+    Ok(())
+}
+
+fn paths_alias(source: &Path, destination: &Path) -> Result<bool> {
+    let destination_metadata = match fs::metadata(destination) {
+        Ok(metadata) => metadata,
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(false),
+        Err(error) => {
+            return Err(error).with_context(|| {
+                format!("Unable to inspect destination partition image: {destination:?}")
+            });
+        }
+    };
+    let source_metadata = fs::metadata(source)
+        .with_context(|| format!("Unable to inspect source partition image: {source:?}"))?;
+
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::MetadataExt as _;
+        Ok(source_metadata.dev() == destination_metadata.dev()
+            && source_metadata.ino() == destination_metadata.ino())
+    }
+    #[cfg(not(unix))]
+    {
+        Ok(fs::canonicalize(source)? == fs::canonicalize(destination)?)
+    }
+}
+
+fn path_entry_exists(path: &Path) -> Result<bool> {
+    match fs::symlink_metadata(path) {
+        Ok(_) => Ok(true),
+        Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(false),
+        Err(error) => Err(error)
+            .with_context(|| format!("Unable to inspect destination partition image: {path:?}")),
+    }
 }
 
 impl Default for ExtractOptions<'_> {
@@ -299,6 +670,7 @@ struct Task<'a> {
     verify: bool,
 
     update: &'a PartitionUpdate,
+    source: Option<SourcePartition>,
     op_idx: AtomicUsize,
     partition: SyncUnsafeCell<MmapMut>,
 
@@ -335,6 +707,7 @@ impl Task<'_> {
         Ok(())
     }
 
+    #[allow(deprecated)]
     fn run_op(&self, op: &InstallOperation) -> Result<()> {
         let mut dst_extents =
             self.extract_dst_extents(op).context("Error extracting dst_extents")?;
@@ -363,11 +736,53 @@ impl Task<'_> {
                 self.run_op_replace(&mut decoder, &mut dst_extents)
                     .context("Error in REPLACE_ZSTD operation")
             }
-            Type::Zero => Ok(()), // This is a no-op since the partition is already zeroed
+            Type::SourceCopy => {
+                let source = self.extract_source_data(op)?;
+                self.write_exact(&source, &mut dst_extents)
+                    .context("Error in SOURCE_COPY operation")
+            }
+            Type::Zero | Type::Discard => {
+                for extent in dst_extents {
+                    extent.fill(0);
+                }
+                Ok(())
+            }
+            Type::Move | Type::Bsdiff => {
+                bail!("Deprecated operation is not supported: {:?}", Type::try_from(op.r#type)?)
+            }
             op => bail!("Unimplemented operation: {op:?}"),
         }
     }
 
+    fn extract_source_data(&self, op: &InstallOperation) -> Result<Vec<u8>> {
+        let source = self.source.as_ref().context("Source partition was not opened")?;
+        let ranges = extent_ranges(&op.src_extents, self.block_size, source.len)?;
+        let capacity = ranges_len(&ranges)?;
+        let mut data = Vec::with_capacity(capacity);
+        for range in ranges {
+            data.extend_from_slice(&source.bytes()[range]);
+        }
+        Ok(data)
+    }
+
+    fn write_exact(&self, data: &[u8], dst_extents: &mut [&mut [u8]]) -> Result<()> {
+        let dst_len = dst_extents.iter().try_fold(0usize, |len, extent| {
+            len.checked_add(extent.len()).context("Combined destination length overflow")
+        })?;
+        ensure!(
+            data.len() == dst_len,
+            "Patched output size mismatch: expected {dst_len}, got {}",
+            data.len()
+        );
+        let mut offset = 0usize;
+        for extent in dst_extents {
+            let end = offset.checked_add(extent.len()).context("Destination offset overflow")?;
+            extent.copy_from_slice(&data[offset..end]);
+            offset = end;
+        }
+        Ok(())
+    }
+
     fn run_op_replace(&self, reader: &mut impl Read, dst_extents: &mut [&mut [u8]]) -> Result<()> {
         let dst_len = dst_extents.iter().map(|extent| extent.len()).sum::<usize>();
         let mut bytes_written = 0usize;
@@ -384,53 +799,38 @@ impl Task<'_> {
                 }
             }
         }
-        ensure!(reader.read(&mut [0])? == 0, "Read fewer bytes than expected");
+        ensure!(reader.read(&mut [0])? == 0, "Decoded data exceeds destination extents");
 
         // Align number of bytes written to block size. The formula for alignment is:
         //   ((operand + alignment - 1) / alignment) * alignment.
-        let bytes_written_aligned = bytes_written.div_ceil(self.block_size).mul(self.block_size);
+        let bytes_written_aligned = bytes_written
+            .checked_add(self.block_size - 1)
+            .context("Decoded data length overflow")?
+            / self.block_size
+            * self.block_size;
         ensure!(bytes_written_aligned == dst_len, "More dst blocks than data, even with padding");
 
         Ok(())
     }
 
-    fn extract_dst_extents(&self, op: &InstallOperation) -> Result<Vec<&'static mut [u8]>> {
+    #[allow(clippy::mut_from_ref)]
+    fn extract_dst_extents(&self, op: &InstallOperation) -> Result<Vec<&mut [u8]>> {
         let partition = unsafe { (*self.partition.get()).as_mut_ptr() };
         let partition_len = unsafe { (&(*self.partition.get())).len() };
-
-        op.dst_extents
-            .iter()
-            .map(|extent| {
-                let start_block =
-                    extent.start_block.context("start_block not defined in extent")? as usize;
-                let num_blocks =
-                    extent.num_blocks.context("num_blocks not defined in extent")? as usize;
-
-                let partition_offset = start_block * self.block_size;
-                let extent_len = num_blocks * self.block_size;
-
-                ensure!(
-                    partition_offset + extent_len <= partition_len,
-                    "Extent exceeds partition size"
-                );
-                let extent = unsafe {
-                    slice::from_raw_parts_mut(partition.add(partition_offset), extent_len)
-                };
-
-                Ok(extent)
+        let ranges = extent_ranges(&op.dst_extents, self.block_size, partition_len)?;
+
+        // validate_partition rejects overlapping destination ranges before any task starts.
+        // This guarantees that parallel workers never create aliases into the mutable map.
+        Ok(ranges
+            .into_iter()
+            .map(|range| unsafe {
+                slice::from_raw_parts_mut(partition.add(range.start), range.len())
             })
-            .collect()
+            .collect())
     }
 
     fn extract_data<'a>(&'a self, op: &InstallOperation) -> Result<&'a [u8]> {
-        let data_len = op.data_length.context("data_length not defined")? as usize;
-        let data = {
-            let offset = op.data_offset.context("data_offset not defined")? as usize;
-            self.payload
-                .data
-                .get(offset..offset + data_len)
-                .context("Data offset exceeds payload size")?
-        };
+        let data = extract_operation_data(self.payload, op)?;
         self.verify_op(op, data)?;
         Ok(data)
     }
@@ -439,30 +839,16 @@ impl Task<'_> {
         if !self.verify {
             return Ok(());
         }
-        let Some(exp_hash) = &op.data_sha256_hash else {
-            return Ok(());
-        };
-
-        let got_hash = digest::digest(&digest::SHA256, data);
-        let got_hash = got_hash.as_ref();
-        ensure!(
-            got_hash == exp_hash,
-            "Input verification failed: hash mismatch: expected {}, got {got_hash:?}",
-            hex::encode(exp_hash)
-        );
-        Ok(())
+        verify_hash(data, op.data_sha256_hash.as_deref(), "Input")
     }
 
     fn verify_partition(&self) -> Result<()> {
-        if !self.verify {
-            return Ok(());
-        }
-
-        let Some(exp_hash) =
-            self.update.new_partition_info.as_ref().and_then(|info| info.hash.as_ref())
-        else {
-            return Ok(());
-        };
+        let exp_hash = self
+            .update
+            .new_partition_info
+            .as_ref()
+            .and_then(|info| info.hash.as_ref())
+            .context("Unable to determine output partition hash")?;
 
         let mut digest = digest::Context::new(&digest::SHA256);
         for chunk in unsafe { (*self.partition.get()).chunks(VERIFY_CHUNK_SIZE) } {
diff --git a/src/main.rs b/src/main.rs
index 5c2e977..422332c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -39,6 +39,10 @@ pub struct Args {
     /// Path to the output directory
     #[clap(long)]
     pub output_dir: String,
+
+    /// Directory containing source partition images for delta payloads
+    #[clap(long)]
+    pub source_dir: Option<String>,
 }
 
 pub fn extract() {
@@ -47,9 +51,12 @@ pub fn extract() {
     let reporter = Box::new(CliProgressReporter::new());
     let reporter = reporter.as_ref();
 
-    let result = ExtractOptions::new()
-        .progress_reporter(reporter)
-        .extract(&args.payload_file, &args.output_dir);
+    let mut options = ExtractOptions::new();
+    options.progress_reporter(reporter);
+    if let Some(source_dir) = &args.source_dir {
+        options.source_dir(source_dir);
+    }
+    let result = options.extract(&args.payload_file, &args.output_dir);
     reporter.progress_bar.finish_and_clear();
     match result {
         Ok(()) => {
diff --git a/src/python.rs b/src/python.rs
index 3173fb8..a0e81be 100644
--- a/src/python.rs
+++ b/src/python.rs
@@ -10,6 +10,7 @@ create_exception!(otadump, OtaDumpError, PyException);
 
 /// Extract partitions from an Android OTA payload or OTA ZIP.
 #[pyfunction]
+#[allow(clippy::too_many_arguments)]
 #[pyo3(signature = (
     payload_file,
     output_dir,
@@ -18,6 +19,7 @@ create_exception!(otadump, OtaDumpError, PyException);
     overwrite = false,
     partitions = None,
     verify = true,
+    source_dir = None,
 ))]
 fn extract(
     py: Python<'_>,
@@ -27,6 +29,7 @@ fn extract(
     overwrite: bool,
     partitions: Option<Vec<String>>,
     verify: bool,
+    source_dir: Option<PathBuf>,
 ) -> PyResult<()> {
     let mut options = ExtractOptions::new();
     options.overwrite(overwrite).verify(verify);
@@ -37,6 +40,9 @@ fn extract(
     if let Some(partitions) = partitions {
         options.partitions(partitions);
     }
+    if let Some(source_dir) = source_dir {
+        options.source_dir(source_dir);
+    }
 
     py.detach(move || {
         options
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
new file mode 100644
index 0000000..878d5a1
--- /dev/null
+++ b/tests/delta_extraction.rs
@@ -0,0 +1,520 @@
+use std::fs;
+use std::path::Path;
+
+use otadump::ExtractOptions;
+use prost::Message;
+use ring::digest;
+use tempfile::TempDir;
+
+#[derive(Clone, PartialEq, Message)]
+struct Extent {
+    #[prost(uint64, optional, tag = "1")]
+    start_block: Option<u64>,
+    #[prost(uint64, optional, tag = "2")]
+    num_blocks: Option<u64>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+struct PartitionInfo {
+    #[prost(uint64, optional, tag = "1")]
+    size: Option<u64>,
+    #[prost(bytes = "vec", optional, tag = "2")]
+    hash: Option<Vec<u8>>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+struct InstallOperation {
+    #[prost(int32, tag = "1")]
+    operation_type: i32,
+    #[prost(uint64, optional, tag = "2")]
+    data_offset: Option<u64>,
+    #[prost(uint64, optional, tag = "3")]
+    data_length: Option<u64>,
+    #[prost(message, repeated, tag = "4")]
+    src_extents: Vec<Extent>,
+    #[prost(uint64, optional, tag = "5")]
+    src_length: Option<u64>,
+    #[prost(message, repeated, tag = "6")]
+    dst_extents: Vec<Extent>,
+    #[prost(uint64, optional, tag = "7")]
+    dst_length: Option<u64>,
+    #[prost(bytes = "vec", optional, tag = "8")]
+    data_sha256_hash: Option<Vec<u8>>,
+    #[prost(bytes = "vec", optional, tag = "9")]
+    src_sha256_hash: Option<Vec<u8>>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+struct PartitionUpdate {
+    #[prost(string, tag = "1")]
+    partition_name: String,
+    #[prost(message, optional, tag = "6")]
+    old_partition_info: Option<PartitionInfo>,
+    #[prost(message, optional, tag = "7")]
+    new_partition_info: Option<PartitionInfo>,
+    #[prost(message, repeated, tag = "8")]
+    operations: Vec<InstallOperation>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+struct DeltaArchiveManifest {
+    #[prost(uint32, optional, tag = "3")]
+    block_size: Option<u32>,
+    #[prost(uint32, optional, tag = "12")]
+    minor_version: Option<u32>,
+    #[prost(message, repeated, tag = "13")]
+    partitions: Vec<PartitionUpdate>,
+}
+
+fn sha256(bytes: &[u8]) -> Vec<u8> {
+    digest::digest(&digest::SHA256, bytes).as_ref().to_vec()
+}
+
+fn extent(start_block: u64, num_blocks: u64) -> Extent {
+    Extent { start_block: Some(start_block), num_blocks: Some(num_blocks) }
+}
+
+fn write_payload(path: &Path, manifest: DeltaArchiveManifest, data: &[u8]) {
+    let manifest = manifest.encode_to_vec();
+    let mut payload = Vec::with_capacity(24 + manifest.len() + data.len());
+    payload.extend_from_slice(b"CrAU");
+    payload.extend_from_slice(&2u64.to_be_bytes());
+    payload.extend_from_slice(&(manifest.len() as u64).to_be_bytes());
+    payload.extend_from_slice(&0u32.to_be_bytes());
+    payload.extend_from_slice(&manifest);
+    payload.extend_from_slice(data);
+    fs::write(path, payload).unwrap();
+}
+
+fn partition_info(bytes: &[u8]) -> PartitionInfo {
+    PartitionInfo { size: Some(bytes.len() as u64), hash: Some(sha256(bytes)) }
+}
+
+#[test]
+fn source_copy_reconstructs_noncontiguous_extents_without_modifying_source() {
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+    let source = b"AAAABBBBCCCCDDDD";
+    fs::write(source_dir.join("system.img"), source).unwrap();
+    let expected = b"AAAACCCC";
+    let operation = InstallOperation {
+        operation_type: 4,
+        src_extents: vec![extent(2, 1), extent(0, 1)],
+        src_length: Some(8),
+        dst_extents: vec![extent(1, 1), extent(0, 1)],
+        dst_length: Some(8),
+        src_sha256_hash: Some(sha256(b"CCCCAAAA")),
+        ..Default::default()
+    };
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(4),
+        minor_version: Some(2),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(source)),
+            new_partition_info: Some(partition_info(expected)),
+            operations: vec![operation],
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &[]);
+
+    ExtractOptions::new()
+        .source_dir(&source_dir)
+        .num_threads(2)
+        .extract(&payload, &output_dir)
+        .unwrap();
+
+    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), expected);
+    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+}
+
+#[test]
+fn source_validation_rejects_wrong_base_before_creating_output() {
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+    fs::write(source_dir.join("boot.img"), b"bad!").unwrap();
+    let operation = InstallOperation {
+        operation_type: 4,
+        src_extents: vec![extent(0, 1)],
+        dst_extents: vec![extent(0, 1)],
+        ..Default::default()
+    };
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(4),
+        minor_version: Some(2),
+        partitions: vec![PartitionUpdate {
+            partition_name: "boot".into(),
+            old_partition_info: Some(partition_info(b"good")),
+            new_partition_info: Some(partition_info(b"good")),
+            operations: vec![operation],
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &[]);
+
+    let error = ExtractOptions::new()
+        .source_dir(&source_dir)
+        .extract(&payload, &output_dir)
+        .unwrap_err()
+        .to_string();
+
+    assert!(error.contains("Source partition hash mismatch"));
+    assert!(!output_dir.join("boot.img").exists());
+}
+
+#[test]
+fn delta_operation_without_source_directory_fails_clearly() {
+    let temporary = TempDir::new().unwrap();
+    let output_dir = temporary.path().join("output");
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(4),
+        minor_version: Some(2),
+        partitions: vec![PartitionUpdate {
+            partition_name: "boot".into(),
+            old_partition_info: Some(partition_info(b"base")),
+            new_partition_info: Some(partition_info(b"base")),
+            operations: vec![InstallOperation {
+                operation_type: 4,
+                src_extents: vec![extent(0, 1)],
+                dst_extents: vec![extent(0, 1)],
+                ..Default::default()
+            }],
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &[]);
+
+    let error = ExtractOptions::new().extract(&payload, &output_dir).unwrap_err().to_string();
+
+    assert!(error.contains("require a source directory"));
+    assert!(!output_dir.join("boot.img").exists());
+}
+
+#[test]
+fn malformed_partition_layouts_fail_without_escaping_or_leaving_partial_images() {
+    for (name, operations, expected_error) in [
+        (
+            "../escape",
+            vec![InstallOperation {
+                operation_type: 0,
+                data_offset: Some(0),
+                data_length: Some(4),
+                dst_extents: vec![extent(0, 1)],
+                ..Default::default()
+            }],
+            "Unsafe partition name",
+        ),
+        (
+            "system",
+            vec![
+                InstallOperation {
+                    operation_type: 0,
+                    data_offset: Some(0),
+                    data_length: Some(4),
+                    dst_extents: vec![extent(0, 1)],
+                    ..Default::default()
+                },
+                InstallOperation {
+                    operation_type: 0,
+                    data_offset: Some(4),
+                    data_length: Some(4),
+                    dst_extents: vec![extent(0, 1)],
+                    ..Default::default()
+                },
+            ],
+            "Destination extents overlap",
+        ),
+    ] {
+        let temporary = TempDir::new().unwrap();
+        let output_dir = temporary.path().join("output");
+        let target = b"data";
+        let manifest = DeltaArchiveManifest {
+            block_size: Some(4),
+            minor_version: Some(0),
+            partitions: vec![PartitionUpdate {
+                partition_name: name.into(),
+                old_partition_info: None,
+                new_partition_info: Some(partition_info(target)),
+                operations,
+            }],
+        };
+        let payload = temporary.path().join("payload.bin");
+        write_payload(&payload, manifest, b"datadata");
+
+        let error = ExtractOptions::new().extract(&payload, &output_dir).unwrap_err().to_string();
+
+        assert!(error.contains(expected_error), "unexpected error: {error}");
+        assert!(!temporary.path().join("escape.img").exists());
+        assert!(!output_dir.join("system.img").exists());
+    }
+}
+
+#[test]
+fn full_replace_payload_remains_compatible() {
+    let temporary = TempDir::new().unwrap();
+    let output_dir = temporary.path().join("output");
+    let expected = b"full payload data";
+    let operation = InstallOperation {
+        operation_type: 0,
+        data_offset: Some(0),
+        data_length: Some(expected.len() as u64),
+        dst_extents: vec![extent(0, 2)],
+        data_sha256_hash: Some(sha256(expected)),
+        ..Default::default()
+    };
+    let mut padded = expected.to_vec();
+    padded.resize(32, 0);
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(16),
+        minor_version: Some(0),
+        partitions: vec![PartitionUpdate {
+            partition_name: "vendor".into(),
+            old_partition_info: None,
+            new_partition_info: Some(partition_info(&padded)),
+            operations: vec![operation],
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, expected);
+
+    ExtractOptions::new().extract(&payload, &output_dir).unwrap();
+
+    assert_eq!(fs::read(output_dir.join("vendor.img")).unwrap(), padded);
+}
+
+#[test]
+fn verified_partitions_are_promoted_after_all_succeed() {
+    let temporary = TempDir::new().unwrap();
+    let output_dir = temporary.path().join("output");
+    let boot = b"boot";
+    let vendor = b"vend";
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(4),
+        minor_version: Some(0),
+        partitions: vec![
+            PartitionUpdate {
+                partition_name: "boot".into(),
+                old_partition_info: None,
+                new_partition_info: Some(partition_info(boot)),
+                operations: vec![InstallOperation {
+                    operation_type: 0,
+                    data_offset: Some(0),
+                    data_length: Some(4),
+                    dst_extents: vec![extent(0, 1)],
+                    ..Default::default()
+                }],
+            },
+            PartitionUpdate {
+                partition_name: "vendor".into(),
+                old_partition_info: None,
+                new_partition_info: Some(partition_info(vendor)),
+                operations: vec![InstallOperation {
+                    operation_type: 0,
+                    data_offset: Some(4),
+                    data_length: Some(4),
+                    dst_extents: vec![extent(0, 1)],
+                    ..Default::default()
+                }],
+            },
+        ],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, b"bootvend");
+
+    ExtractOptions::new().extract(&payload, &output_dir).unwrap();
+
+    assert_eq!(fs::read(output_dir.join("boot.img")).unwrap(), boot);
+    assert_eq!(fs::read(output_dir.join("vendor.img")).unwrap(), vendor);
+}
+
+#[test]
+fn no_clobber_rejects_existing_destination_without_modifying_source() {
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+    fs::create_dir(&output_dir).unwrap();
+    let source = b"base";
+    let existing = b"keep";
+    fs::write(source_dir.join("system.img"), source).unwrap();
+    fs::write(output_dir.join("system.img"), existing).unwrap();
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(4),
+        minor_version: Some(2),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(source)),
+            new_partition_info: Some(partition_info(source)),
+            operations: vec![InstallOperation {
+                operation_type: 4,
+                src_extents: vec![extent(0, 1)],
+                dst_extents: vec![extent(0, 1)],
+                ..Default::default()
+            }],
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &[]);
+
+    let error = ExtractOptions::new()
+        .source_dir(&source_dir)
+        .extract(&payload, &output_dir)
+        .unwrap_err()
+        .to_string();
+
+    assert!(error.contains("already exists"));
+    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), existing);
+    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+    assert_eq!(fs::read_dir(&output_dir).unwrap().count(), 1);
+}
+
+#[test]
+fn verification_failure_preserves_existing_destinations_with_overwrite() {
+    let temporary = TempDir::new().unwrap();
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&output_dir).unwrap();
+    fs::write(output_dir.join("boot.img"), b"oldb").unwrap();
+    fs::write(output_dir.join("vendor.img"), b"oldv").unwrap();
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(4),
+        minor_version: Some(0),
+        partitions: vec![
+            PartitionUpdate {
+                partition_name: "boot".into(),
+                old_partition_info: None,
+                new_partition_info: Some(partition_info(b"boot")),
+                operations: vec![InstallOperation {
+                    operation_type: 0,
+                    data_offset: Some(0),
+                    data_length: Some(4),
+                    dst_extents: vec![extent(0, 1)],
+                    ..Default::default()
+                }],
+            },
+            PartitionUpdate {
+                partition_name: "vendor".into(),
+                old_partition_info: None,
+                new_partition_info: Some(partition_info(b"bad!")),
+                operations: vec![InstallOperation {
+                    operation_type: 0,
+                    data_offset: Some(4),
+                    data_length: Some(4),
+                    dst_extents: vec![extent(0, 1)],
+                    ..Default::default()
+                }],
+            },
+        ],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, b"bootvend");
+
+    let error = ExtractOptions::new()
+        .overwrite(true)
+        .extract(&payload, &output_dir)
+        .unwrap_err()
+        .to_string();
+
+    assert!(error.contains("Output verification failed"));
+    assert_eq!(fs::read(output_dir.join("boot.img")).unwrap(), b"oldb");
+    assert_eq!(fs::read(output_dir.join("vendor.img")).unwrap(), b"oldv");
+    assert_eq!(fs::read_dir(&output_dir).unwrap().count(), 2);
+}
+
+#[test]
+fn partition_selection_does_not_require_unselected_delta_sources() {
+    let temporary = TempDir::new().unwrap();
+    let output_dir = temporary.path().join("output");
+    let expected = b"boot";
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(4),
+        minor_version: Some(2),
+        partitions: vec![
+            PartitionUpdate {
+                partition_name: "boot".into(),
+                old_partition_info: None,
+                new_partition_info: Some(partition_info(expected)),
+                operations: vec![InstallOperation {
+                    operation_type: 0,
+                    data_offset: Some(0),
+                    data_length: Some(4),
+                    dst_extents: vec![extent(0, 1)],
+                    ..Default::default()
+                }],
+            },
+            PartitionUpdate {
+                partition_name: "system".into(),
+                old_partition_info: Some(partition_info(b"base")),
+                new_partition_info: Some(partition_info(b"base")),
+                operations: vec![InstallOperation {
+                    operation_type: 4,
+                    src_extents: vec![extent(0, 1)],
+                    dst_extents: vec![extent(0, 1)],
+                    ..Default::default()
+                }],
+            },
+        ],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, expected);
+
+    ExtractOptions::new().partitions(["boot"]).extract(&payload, &output_dir).unwrap();
+
+    assert_eq!(fs::read(output_dir.join("boot.img")).unwrap(), expected);
+    assert!(!output_dir.join("system.img").exists());
+}
+
+#[cfg(unix)]
+#[test]
+fn source_and_destination_aliases_are_rejected_without_modifying_the_source() {
+    use std::os::unix::fs::symlink;
+
+    for link in ["hard", "symbolic"] {
+        let temporary = TempDir::new().unwrap();
+        let source_dir = temporary.path().join("source");
+        let output_dir = temporary.path().join("output");
+        fs::create_dir(&source_dir).unwrap();
+        fs::create_dir(&output_dir).unwrap();
+        let source_path = source_dir.join("system.img");
+        let source = b"base";
+        fs::write(&source_path, source).unwrap();
+        let destination_path = output_dir.join("system.img");
+        if link == "hard" {
+            fs::hard_link(&source_path, &destination_path).unwrap();
+        } else {
+            symlink(&source_path, &destination_path).unwrap();
+        }
+
+        let manifest = DeltaArchiveManifest {
+            block_size: Some(4),
+            minor_version: Some(2),
+            partitions: vec![PartitionUpdate {
+                partition_name: "system".into(),
+                old_partition_info: Some(partition_info(source)),
+                new_partition_info: Some(partition_info(source)),
+                operations: vec![InstallOperation {
+                    operation_type: 4,
+                    src_extents: vec![extent(0, 1)],
+                    dst_extents: vec![extent(0, 1)],
+                    ..Default::default()
+                }],
+            }],
+        };
+        let payload = temporary.path().join("payload.bin");
+        write_payload(&payload, manifest, &[]);
+
+        let error = ExtractOptions::new()
+            .source_dir(&source_dir)
+            .overwrite(true)
+            .extract(&payload, &output_dir)
+            .unwrap_err()
+            .to_string();
+
+        assert!(error.contains("refer to the same file"));
+        assert_eq!(fs::read(&source_path).unwrap(), source);
+    }
+}
diff --git a/tests/python_smoke.py b/tests/python_smoke.py
index 8c9d270..d32ba71 100644
--- a/tests/python_smoke.py
+++ b/tests/python_smoke.py
@@ -7,7 +7,9 @@
 
 def main() -> None:
     assert issubclass(otadump.OtaDumpError, Exception)
-    assert "partitions" in str(signature(otadump.extract))
+    extract_signature = str(signature(otadump.extract))
+    assert "partitions" in extract_signature
+    assert "source_dir=None" in extract_signature
 
     with TemporaryDirectory() as temporary_directory:
         temporary_path = Path(temporary_directory)

From 9e9f912f3b22218892f9fc0d0eeb6ee3ec3d7661 Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Fri, 11 Sep 2026 13:21:36 +0530
Subject: [PATCH 02/42] extractor: Add graceful cancellation

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 Cargo.lock                |  85 +++++++++++++++++-
 Cargo.toml                |   1 +
 src/lib.rs                | 175 ++++++++++++++++++++++++++++++++------
 src/main.rs               |  21 +++--
 src/python.rs             |  64 ++++++++++++--
 tests/delta_extraction.rs | 159 +++++++++++++++++++++++++++++++++-
 tests/python_smoke.py     |  16 ++++
 7 files changed, 480 insertions(+), 41 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 370ea0e..6ed9355 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -82,6 +82,15 @@ version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
 
+[[package]]
+name = "block2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
+dependencies = [
+ "objc2",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.18.1"
@@ -120,6 +129,12 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
 
+[[package]]
+name = "cfg_aliases"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527"
+
 [[package]]
 name = "clap"
 version = "4.5.40"
@@ -234,6 +249,17 @@ version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
+[[package]]
+name = "ctrlc"
+version = "3.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0b1fab2ae45819af2d0731d60f2afe17227ebb1a1538a236da84c93e9a60162"
+dependencies = [
+ "dispatch2",
+ "nix",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "derive_arbitrary"
 version = "1.4.1"
@@ -245,6 +271,18 @@ dependencies = [
  "syn 2.0.104",
 ]
 
+[[package]]
+name = "dispatch2"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
+dependencies = [
+ "bitflags",
+ "block2",
+ "libc",
+ "objc2",
+]
+
 [[package]]
 name = "either"
 version = "1.15.0"
@@ -392,9 +430,9 @@ checksum = "775bf80d5878ab7c2b1080b5351a48b2f737d9f6f8b383574eebcc22be0dfccb"
 
 [[package]]
 name = "libc"
-version = "0.2.174"
+version = "0.2.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
 [[package]]
 name = "liblzma"
@@ -455,6 +493,18 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1d87ecb2933e8aeadb3e3a02b828fed80a7528047e68b4f424523a0981a3a084"
 
+[[package]]
+name = "nix"
+version = "0.31.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
 [[package]]
 name = "nom"
 version = "7.1.3"
@@ -493,6 +543,21 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
 
+[[package]]
+name = "objc2"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
+dependencies = [
+ "objc2-encode",
+]
+
+[[package]]
+name = "objc2-encode"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
+
 [[package]]
 name = "once_cell"
 version = "1.21.3"
@@ -513,6 +578,7 @@ dependencies = [
  "bzip2",
  "clap",
  "color-print",
+ "ctrlc",
  "hex",
  "indicatif",
  "liblzma",
@@ -1007,6 +1073,12 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
@@ -1034,6 +1106,15 @@ dependencies = [
  "windows-targets 0.53.2",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
diff --git a/Cargo.toml b/Cargo.toml
index 542c789..e5e946f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,6 +29,7 @@ anyhow = "1.0.69"
 bzip2 = { version = "0.6.0" }
 clap = { version = "4.2.1", features = ["derive"] }
 color-print = "0.3.4"
+ctrlc = "3.5.0"
 hex = "0.4.3"
 indicatif = "0.17.3"
 liblzma = { version = "0.4.2", features = ["static"] }
diff --git a/src/lib.rs b/src/lib.rs
index 87ea92a..a8b8c75 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -14,8 +14,8 @@ use std::io::Read;
 use std::num::NonZero;
 use std::ops::Range;
 use std::path::{Component, Path, PathBuf};
-use std::sync::OnceLock;
-use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::{Arc, OnceLock};
 use std::{error, result, slice, thread};
 
 use anyhow::{Context as _, Error, Result, bail, ensure};
@@ -39,6 +39,54 @@ pub use crate::payload::Payload;
 // the progress tracker.
 const VERIFY_CHUNK_SIZE: usize = 2 * 1024 * 1024; // 2 MiB
 
+#[derive(Clone, Debug, Default)]
+pub struct CancellationToken {
+    cancelled: Arc<AtomicBool>,
+}
+
+impl CancellationToken {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn cancel(&self) {
+        self.cancelled.store(true, Ordering::Release);
+    }
+
+    pub fn is_cancelled(&self) -> bool {
+        self.cancelled.load(Ordering::Acquire)
+    }
+
+    fn check(&self) -> Result<()> {
+        if self.is_cancelled() {
+            return Err(ExtractionCancelled.into());
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub struct ExtractionCancelled;
+
+impl std::fmt::Display for ExtractionCancelled {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str("Extraction cancelled")
+    }
+}
+
+impl error::Error for ExtractionCancelled {}
+
+pub fn is_cancellation(error: &(dyn error::Error + 'static)) -> bool {
+    let mut error = Some(error);
+    while let Some(current) = error {
+        if current.downcast_ref::<ExtractionCancelled>().is_some() {
+            return true;
+        }
+        error = current.source();
+    }
+    false
+}
+
 pub struct ExtractOptions<'a> {
     num_threads: Option<usize>,
     overwrite: bool,
@@ -46,6 +94,7 @@ pub struct ExtractOptions<'a> {
     progress_reporter: &'a dyn ProgressReporter,
     verify: bool,
     source_dir: Option<PathBuf>,
+    cancellation_token: CancellationToken,
 }
 
 impl<'a> ExtractOptions<'a> {
@@ -58,6 +107,7 @@ impl<'a> ExtractOptions<'a> {
             progress_reporter: &NoOpProgressReporter,
             verify: true,
             source_dir: None,
+            cancellation_token: CancellationToken::new(),
         }
     }
 
@@ -73,14 +123,18 @@ impl<'a> ExtractOptions<'a> {
     {
         let payload_file = payload_file.as_ref();
         let output_dir = output_dir.as_ref();
-        self.extract_impl(payload_file, output_dir)?;
-        Ok(())
+        match self.extract_impl(payload_file, output_dir) {
+            Ok(()) => Ok(()),
+            Err(error) if error.is::<ExtractionCancelled>() => Err(Box::new(ExtractionCancelled)),
+            Err(error) => Err(error.into()),
+        }
     }
 
     fn extract_impl(&self, payload_file: &Path, output_dir: &Path) -> Result<()> {
+        self.cancellation_token.check()?;
         self.progress_reporter.report_progress(0.);
 
-        let payload_file = Self::open_payload_file(payload_file)?;
+        let payload_file = self.open_payload_file(payload_file)?;
         let payload = Payload::parse(&payload_file)?;
 
         let mut manifest =
@@ -118,6 +172,7 @@ impl<'a> ExtractOptions<'a> {
 
         // Ensure that all partitions to be extracted are present in the manifest.
         for partition_name in self.partitions.iter().flatten() {
+            self.cancellation_token.check()?;
             ensure!(
                 manifest.partitions.iter().any(|update| &update.partition_name == partition_name),
                 "Partition not found: {partition_name}",
@@ -136,6 +191,7 @@ impl<'a> ExtractOptions<'a> {
         let mut partition_names = HashSet::with_capacity(manifest.partitions.len());
         let mut destinations = Vec::with_capacity(manifest.partitions.len());
         for update in &manifest.partitions {
+            self.cancellation_token.check()?;
             ensure!(
                 partition_names.insert(&update.partition_name),
                 "Duplicate partition mapping: {:?}",
@@ -144,6 +200,7 @@ impl<'a> ExtractOptions<'a> {
             destinations.push(output_dir.join(format!("{}.img", update.partition_name)));
         }
         for (update, destination) in manifest.partitions.iter().zip(&destinations) {
+            self.cancellation_token.check()?;
             for source in sources.iter().flatten() {
                 ensure!(
                     !paths_alias(&source.path, destination)?,
@@ -167,6 +224,7 @@ impl<'a> ExtractOptions<'a> {
         let mut staging_paths = Vec::with_capacity(manifest.partitions.len());
         let mut partitions = Vec::with_capacity(manifest.partitions.len());
         for update in &manifest.partitions {
+            self.cancellation_token.check()?;
             let (path, partition) = self.create_staged_partition(update, staging_dir.path())?;
             staging_paths.push(path);
             partitions.push(partition);
@@ -190,6 +248,10 @@ impl<'a> ExtractOptions<'a> {
                 if error.get().is_some() {
                     break;
                 }
+                if let Err(cancelled) = self.cancellation_token.check() {
+                    _ = error.set(cancelled);
+                    break;
+                }
 
                 // Create and broadcast a task to the threadpool.
                 let task = Task {
@@ -203,6 +265,7 @@ impl<'a> ExtractOptions<'a> {
                     total_ops,
                     total_ops_completed: &total_ops_completed,
                     progress_reporter: self.progress_reporter,
+                    cancellation_token: &self.cancellation_token,
                     error: &error,
                 };
                 scope.spawn_broadcast(move |_, ctx| {
@@ -213,11 +276,13 @@ impl<'a> ExtractOptions<'a> {
             }
         });
 
+        self.cancellation_token.check()?;
         if let Some(e) = error.take() {
             return Err(e);
         }
 
         for (staging_path, destination) in staging_paths.into_iter().zip(destinations) {
+            self.cancellation_token.check()?;
             let result = if self.overwrite {
                 staging_path.persist(&destination)
             } else {
@@ -227,10 +292,11 @@ impl<'a> ExtractOptions<'a> {
         }
 
         self.progress_reporter.report_progress(1.);
+        self.cancellation_token.check()?;
         Ok(())
     }
 
-    fn open_payload_file(path: &Path) -> Result<Mmap> {
+    fn open_payload_file(&self, path: &Path) -> Result<Mmap> {
         let in_file = File::open(path)
             .with_context(|| format!("Failed to open file for reading: {path:?}"))?;
 
@@ -261,9 +327,12 @@ impl<'a> ExtractOptions<'a> {
                         let mut out_file = unsafe { MmapMut::map_mut(&out_file) }
                             .context("Failed to mmap temporary file")?;
 
-                        zip_file
-                            .read_exact(&mut out_file)
-                            .context("Failed to write to temporary file")?;
+                        for chunk in out_file.chunks_mut(VERIFY_CHUNK_SIZE) {
+                            self.cancellation_token.check()?;
+                            zip_file
+                                .read_exact(chunk)
+                                .context("Failed to write to temporary file")?;
+                        }
                         out_file.make_read_only().context("Failed to make temporary file read-only")
                     }
                 }
@@ -281,6 +350,7 @@ impl<'a> ExtractOptions<'a> {
         block_size: usize,
     ) -> Result<Option<SourcePartition>> {
         validate_partition_name(&update.partition_name)?;
+        self.cancellation_token.check()?;
 
         let partition_len = update
             .new_partition_info
@@ -295,6 +365,7 @@ impl<'a> ExtractOptions<'a> {
         );
 
         let needs_source = update.operations.iter().try_fold(false, |needed, op| {
+            self.cancellation_token.check()?;
             let op_type = Type::try_from(op.r#type).context("Invalid operation")?;
             validate_operation_type(op_type)?;
             Ok::<_, Error>(needed || operation_needs_source(op_type))
@@ -303,6 +374,7 @@ impl<'a> ExtractOptions<'a> {
 
         let mut destination_ranges = Vec::new();
         for (op_index, op) in update.operations.iter().enumerate() {
+            self.cancellation_token.check()?;
             let op_type = Type::try_from(op.r#type).context("Invalid operation")?;
             let dst_ranges = extent_ranges(&op.dst_extents, block_size, partition_len)
                 .with_context(|| format!("Invalid destination extents for operation {op_index}"))?;
@@ -339,6 +411,7 @@ impl<'a> ExtractOptions<'a> {
                         &src_ranges,
                         op.src_sha256_hash.as_deref(),
                         "Source extent",
+                        &self.cancellation_token,
                     )
                     .with_context(|| {
                         format!("Source verification failed for operation {op_index}")
@@ -350,9 +423,15 @@ impl<'a> ExtractOptions<'a> {
                 let data = extract_operation_data(payload, op)
                     .with_context(|| format!("Invalid data for operation {op_index}"))?;
                 if self.verify {
-                    verify_hash(data, op.data_sha256_hash.as_deref(), "Input").with_context(
-                        || format!("Data verification failed for operation {op_index}"),
-                    )?;
+                    verify_hash(
+                        data,
+                        op.data_sha256_hash.as_deref(),
+                        "Input",
+                        &self.cancellation_token,
+                    )
+                    .with_context(|| {
+                        format!("Data verification failed for operation {op_index}")
+                    })?;
                 }
             }
         }
@@ -405,7 +484,12 @@ impl<'a> ExtractOptions<'a> {
             source.len
         );
         let expected_hash = info.hash.as_deref().context("Source partition hash is missing")?;
-        verify_hash(source.bytes(), Some(expected_hash), "Source partition")?;
+        verify_hash(
+            source.bytes(),
+            Some(expected_hash),
+            "Source partition",
+            &self.cancellation_token,
+        )?;
         Ok(source)
     }
 
@@ -476,6 +560,12 @@ impl<'a> ExtractOptions<'a> {
         self.source_dir = Some(source_dir.as_ref().to_path_buf());
         self
     }
+
+    /// Stop extraction cooperatively when the caller cancels the token.
+    pub fn cancellation_token(&mut self, cancellation_token: &CancellationToken) -> &mut Self {
+        self.cancellation_token = cancellation_token.clone();
+        self
+    }
 }
 
 struct SourcePartition {
@@ -587,11 +677,22 @@ fn extract_operation_data<'a>(payload: &'a Payload<'a>, op: &InstallOperation) -
     payload.data.get(offset..end).context("Data range exceeds payload size")
 }
 
-fn verify_hash(data: &[u8], expected: Option<&[u8]>, label: &str) -> Result<()> {
+fn verify_hash(
+    data: &[u8],
+    expected: Option<&[u8]>,
+    label: &str,
+    cancellation_token: &CancellationToken,
+) -> Result<()> {
+    cancellation_token.check()?;
     let Some(expected) = expected else {
         return Ok(());
     };
-    let actual = digest::digest(&digest::SHA256, data);
+    let mut context = digest::Context::new(&digest::SHA256);
+    for chunk in data.chunks(VERIFY_CHUNK_SIZE) {
+        cancellation_token.check()?;
+        context.update(chunk);
+    }
+    let actual = context.finish();
     ensure!(
         actual.as_ref() == expected,
         "{label} hash mismatch: expected {}, got {}",
@@ -606,13 +707,18 @@ fn verify_hash_over_ranges(
     ranges: &[Range<usize>],
     expected: Option<&[u8]>,
     label: &str,
+    cancellation_token: &CancellationToken,
 ) -> Result<()> {
+    cancellation_token.check()?;
     let Some(expected) = expected else {
         return Ok(());
     };
     let mut context = digest::Context::new(&digest::SHA256);
     for range in ranges {
-        context.update(&data[range.clone()]);
+        for chunk in data[range.clone()].chunks(VERIFY_CHUNK_SIZE) {
+            cancellation_token.check()?;
+            context.update(chunk);
+        }
     }
     let actual = context.finish();
     ensure!(
@@ -677,6 +783,7 @@ struct Task<'a> {
     total_ops: usize,
     total_ops_completed: &'a AtomicUsize,
     progress_reporter: &'a dyn ProgressReporter,
+    cancellation_token: &'a CancellationToken,
 
     error: &'a OnceLock<Error>,
 }
@@ -685,10 +792,12 @@ impl Task<'_> {
     fn run(&self, ctx: BroadcastContext<'_>) -> Result<()> {
         // If an error has already occurred, stop processing the partition.
         while self.error.get().is_none() {
+            self.cancellation_token.check()?;
             let op_idx = self.op_idx.fetch_add(1, Ordering::AcqRel);
             match self.update.operations.get(op_idx) {
                 Some(op) => {
                     self.run_op(op)?;
+                    self.cancellation_token.check()?;
                     self.increment_progress();
                 }
                 None => {
@@ -696,7 +805,9 @@ impl Task<'_> {
                     // partition, the partition is fully extracted and can now be
                     // verified.
                     if op_idx + 1 == self.update.operations.len() + ctx.num_threads() {
+                        self.cancellation_token.check()?;
                         self.verify_partition()?;
+                        self.cancellation_token.check()?;
                         unsafe { (*self.partition.get()).flush() }
                             .context("Error while flushing file to disk")?;
                     };
@@ -709,6 +820,7 @@ impl Task<'_> {
 
     #[allow(deprecated)]
     fn run_op(&self, op: &InstallOperation) -> Result<()> {
+        self.cancellation_token.check()?;
         let mut dst_extents =
             self.extract_dst_extents(op).context("Error extracting dst_extents")?;
         match Type::try_from(op.r#type).context("Invalid operation")? {
@@ -743,7 +855,10 @@ impl Task<'_> {
             }
             Type::Zero | Type::Discard => {
                 for extent in dst_extents {
-                    extent.fill(0);
+                    for chunk in extent.chunks_mut(VERIFY_CHUNK_SIZE) {
+                        self.cancellation_token.check()?;
+                        chunk.fill(0);
+                    }
                 }
                 Ok(())
             }
@@ -751,7 +866,8 @@ impl Task<'_> {
                 bail!("Deprecated operation is not supported: {:?}", Type::try_from(op.r#type)?)
             }
             op => bail!("Unimplemented operation: {op:?}"),
-        }
+        }?;
+        self.cancellation_token.check()
     }
 
     fn extract_source_data(&self, op: &InstallOperation) -> Result<Vec<u8>> {
@@ -760,7 +876,10 @@ impl Task<'_> {
         let capacity = ranges_len(&ranges)?;
         let mut data = Vec::with_capacity(capacity);
         for range in ranges {
-            data.extend_from_slice(&source.bytes()[range]);
+            for chunk in source.bytes()[range].chunks(VERIFY_CHUNK_SIZE) {
+                self.cancellation_token.check()?;
+                data.extend_from_slice(chunk);
+            }
         }
         Ok(data)
     }
@@ -776,9 +895,12 @@ impl Task<'_> {
         );
         let mut offset = 0usize;
         for extent in dst_extents {
-            let end = offset.checked_add(extent.len()).context("Destination offset overflow")?;
-            extent.copy_from_slice(&data[offset..end]);
-            offset = end;
+            for chunk in extent.chunks_mut(VERIFY_CHUNK_SIZE) {
+                self.cancellation_token.check()?;
+                let end = offset.checked_add(chunk.len()).context("Destination offset overflow")?;
+                chunk.copy_from_slice(&data[offset..end]);
+                offset = end;
+            }
         }
         Ok(())
     }
@@ -790,7 +912,9 @@ impl Task<'_> {
         for extent in dst_extents {
             let mut extent = &mut **extent;
             loop {
-                match reader.read(extent).context("Failed to write to buffer")? {
+                self.cancellation_token.check()?;
+                let chunk_len = extent.len().min(VERIFY_CHUNK_SIZE);
+                match reader.read(&mut extent[..chunk_len]).context("Failed to write to buffer")? {
                     0 => break,
                     n => {
                         bytes_written += n;
@@ -799,6 +923,7 @@ impl Task<'_> {
                 }
             }
         }
+        self.cancellation_token.check()?;
         ensure!(reader.read(&mut [0])? == 0, "Decoded data exceeds destination extents");
 
         // Align number of bytes written to block size. The formula for alignment is:
@@ -839,7 +964,7 @@ impl Task<'_> {
         if !self.verify {
             return Ok(());
         }
-        verify_hash(data, op.data_sha256_hash.as_deref(), "Input")
+        verify_hash(data, op.data_sha256_hash.as_deref(), "Input", self.cancellation_token)
     }
 
     fn verify_partition(&self) -> Result<()> {
@@ -852,10 +977,12 @@ impl Task<'_> {
 
         let mut digest = digest::Context::new(&digest::SHA256);
         for chunk in unsafe { (*self.partition.get()).chunks(VERIFY_CHUNK_SIZE) } {
+            self.cancellation_token.check()?;
             digest.update(chunk);
             self.increment_progress();
         }
 
+        self.cancellation_token.check()?;
         let got_hash = digest.finish();
         let got_hash = got_hash.as_ref();
         ensure!(
diff --git a/src/main.rs b/src/main.rs
index 422332c..6a72c93 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,10 +1,14 @@
-use anyhow::Result;
 use clap::Parser;
 use indicatif::{ProgressBar, ProgressStyle};
-use otadump::{ExtractOptions, ProgressReporter};
+use otadump::{CancellationToken, ExtractOptions, ProgressReporter, is_cancellation};
 
-fn main() -> Result<()> {
-    extract();
+fn main() -> Result<(), ctrlc::Error> {
+    let cancellation_token = CancellationToken::new();
+    let signal_token = cancellation_token.clone();
+    ctrlc::set_handler(move || signal_token.cancel())?;
+    if extract(&cancellation_token) || cancellation_token.is_cancelled() {
+        std::process::exit(130);
+    }
     Ok(())
 }
 
@@ -45,14 +49,14 @@ pub struct Args {
     pub source_dir: Option<String>,
 }
 
-pub fn extract() {
+pub fn extract(cancellation_token: &CancellationToken) -> bool {
     let args = Args::parse();
 
     let reporter = Box::new(CliProgressReporter::new());
     let reporter = reporter.as_ref();
 
     let mut options = ExtractOptions::new();
-    options.progress_reporter(reporter);
+    options.progress_reporter(reporter).cancellation_token(cancellation_token);
     if let Some(source_dir) = &args.source_dir {
         options.source_dir(source_dir);
     }
@@ -62,10 +66,15 @@ pub fn extract() {
         Ok(()) => {
             let message = format!("Extraction complete: {}", args.output_dir);
             reporter.progress_bar.println(message);
+            false
         }
         Err(e) => {
+            if is_cancellation(e.as_ref()) {
+                return true;
+            }
             let message = format!("Error: {e:?}");
             reporter.progress_bar.println(message);
+            false
         }
     }
 }
diff --git a/src/python.rs b/src/python.rs
index a0e81be..5ee7f16 100644
--- a/src/python.rs
+++ b/src/python.rs
@@ -1,13 +1,35 @@
 use std::path::PathBuf;
+use std::time::Duration;
 
 use pyo3::create_exception;
-use pyo3::exceptions::PyException;
+use pyo3::exceptions::{PyException, PyKeyboardInterrupt};
 use pyo3::prelude::*;
 
-use crate::ExtractOptions;
+use crate::{CancellationToken, ExtractOptions, is_cancellation};
 
 create_exception!(otadump, OtaDumpError, PyException);
 
+#[pyclass(name = "CancellationToken")]
+struct PyCancellationToken {
+    token: CancellationToken,
+}
+
+#[pymethods]
+impl PyCancellationToken {
+    #[new]
+    fn new() -> Self {
+        Self { token: CancellationToken::new() }
+    }
+
+    fn cancel(&self) {
+        self.token.cancel();
+    }
+
+    fn is_cancelled(&self) -> bool {
+        self.token.is_cancelled()
+    }
+}
+
 /// Extract partitions from an Android OTA payload or OTA ZIP.
 #[pyfunction]
 #[allow(clippy::too_many_arguments)]
@@ -20,6 +42,7 @@ create_exception!(otadump, OtaDumpError, PyException);
     partitions = None,
     verify = true,
     source_dir = None,
+    cancellation_token = None,
 ))]
 fn extract(
     py: Python<'_>,
@@ -30,9 +53,12 @@ fn extract(
     partitions: Option<Vec<String>>,
     verify: bool,
     source_dir: Option<PathBuf>,
+    cancellation_token: Option<PyRef<'_, PyCancellationToken>>,
 ) -> PyResult<()> {
+    let cancellation_token =
+        cancellation_token.map(|token| token.token.clone()).unwrap_or_default();
     let mut options = ExtractOptions::new();
-    options.overwrite(overwrite).verify(verify);
+    options.overwrite(overwrite).verify(verify).cancellation_token(&cancellation_token);
 
     if let Some(num_threads) = num_threads {
         options.num_threads(num_threads);
@@ -44,16 +70,38 @@ fn extract(
         options.source_dir(source_dir);
     }
 
-    py.detach(move || {
-        options
-            .extract(payload_file, output_dir)
-            .map_err(|error| OtaDumpError::new_err(error.to_string()))
-    })
+    let extraction = std::thread::spawn(move || match options.extract(payload_file, output_dir) {
+        Ok(()) => Ok(()),
+        Err(error) if is_cancellation(error.as_ref()) => Err(None),
+        Err(error) => Err(Some(error.to_string())),
+    });
+
+    let mut signal_error = None;
+    while !extraction.is_finished() {
+        if signal_error.is_none() {
+            if let Err(error) = py.check_signals() {
+                cancellation_token.cancel();
+                signal_error = Some(error);
+            }
+        }
+        py.detach(|| std::thread::sleep(Duration::from_millis(20)));
+    }
+    let result =
+        extraction.join().map_err(|_| OtaDumpError::new_err("Extraction worker panicked"))?;
+    if let Some(error) = signal_error {
+        return Err(error);
+    }
+    match result {
+        Ok(()) => Ok(()),
+        Err(None) => Err(PyKeyboardInterrupt::new_err("Extraction cancelled")),
+        Err(Some(error)) => Err(OtaDumpError::new_err(error)),
+    }
 }
 
 #[pymodule]
 fn otadump(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add("OtaDumpError", module.py().get_type::<OtaDumpError>())?;
+    module.add_class::<PyCancellationToken>()?;
     module.add_function(wrap_pyfunction!(extract, module)?)?;
     Ok(())
 }
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index 878d5a1..1ce68d1 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -1,7 +1,8 @@
 use std::fs;
 use std::path::Path;
+use std::sync::atomic::{AtomicBool, Ordering};
 
-use otadump::ExtractOptions;
+use otadump::{CancellationToken, ExtractOptions, ProgressReporter, is_cancellation};
 use prost::Message;
 use ring::digest;
 use tempfile::TempDir;
@@ -468,6 +469,162 @@ fn partition_selection_does_not_require_unselected_delta_sources() {
     assert!(!output_dir.join("system.img").exists());
 }
 
+struct CancellingReporter {
+    cancellation_token: CancellationToken,
+    cancelled: AtomicBool,
+}
+
+impl ProgressReporter for CancellingReporter {
+    fn report_progress(&self, progress: f64) {
+        if progress > 0.0 && !self.cancelled.swap(true, Ordering::AcqRel) {
+            self.cancellation_token.cancel();
+        }
+    }
+}
+
+#[test]
+fn cancellation_cleans_staging_without_promoting_or_modifying_source() {
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+    fs::create_dir(&output_dir).unwrap();
+    let source = (0..128).map(|byte| byte as u8).collect::<Vec<_>>();
+    fs::write(source_dir.join("system.img"), &source).unwrap();
+    let existing = b"existing destination";
+    fs::write(output_dir.join("system.img"), existing).unwrap();
+    let operations = (0..32)
+        .map(|block| InstallOperation {
+            operation_type: 4,
+            src_extents: vec![extent(block, 1)],
+            src_length: Some(4),
+            dst_extents: vec![extent(block, 1)],
+            dst_length: Some(4),
+            ..Default::default()
+        })
+        .collect();
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(4),
+        minor_version: Some(2),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(&source)),
+            new_partition_info: Some(partition_info(&source)),
+            operations,
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &[]);
+    let cancellation_token = CancellationToken::new();
+    let reporter = CancellingReporter {
+        cancellation_token: cancellation_token.clone(),
+        cancelled: AtomicBool::new(false),
+    };
+
+    let error = ExtractOptions::new()
+        .source_dir(&source_dir)
+        .overwrite(true)
+        .num_threads(4)
+        .progress_reporter(&reporter)
+        .cancellation_token(&cancellation_token)
+        .extract(&payload, &output_dir)
+        .unwrap_err();
+
+    assert!(is_cancellation(error.as_ref()));
+    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), existing);
+    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+    assert!(
+        fs::read_dir(&output_dir).unwrap().all(|entry| !entry
+            .unwrap()
+            .file_name()
+            .to_string_lossy()
+            .starts_with(".otadump-"))
+    );
+}
+
+#[cfg(unix)]
+#[test]
+fn cli_sigint_exits_130_after_cleaning_staging() {
+    use std::process::{Command, Stdio};
+    use std::time::{Duration, Instant};
+
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+    let block_size = 256usize;
+    let block_count = 65_536usize;
+    let source = vec![0x5a; block_size * block_count];
+    let source_path = source_dir.join("system.img");
+    fs::write(&source_path, &source).unwrap();
+    let operations = (0..block_count)
+        .map(|block| InstallOperation {
+            operation_type: 4,
+            src_extents: vec![extent(block as u64, 1)],
+            src_length: Some(block_size as u64),
+            dst_extents: vec![extent(block as u64, 1)],
+            dst_length: Some(block_size as u64),
+            ..Default::default()
+        })
+        .collect();
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(block_size as u32),
+        minor_version: Some(2),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(&source)),
+            new_partition_info: Some(partition_info(&source)),
+            operations,
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &[]);
+
+    let mut child = Command::new(env!("CARGO_BIN_EXE_otadump"))
+        .arg(&payload)
+        .arg("--output-dir")
+        .arg(&output_dir)
+        .arg("--source-dir")
+        .arg(&source_dir)
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+        .unwrap();
+    let deadline = Instant::now() + Duration::from_secs(10);
+    loop {
+        let staging_exists = output_dir.exists()
+            && fs::read_dir(&output_dir)
+                .unwrap()
+                .any(|entry| entry.unwrap().file_name().to_string_lossy().starts_with(".otadump-"));
+        if staging_exists {
+            break;
+        }
+        assert!(child.try_wait().unwrap().is_none(), "CLI finished before SIGINT");
+        assert!(Instant::now() < deadline, "staging directory was not created");
+        std::thread::yield_now();
+    }
+    let signal_status =
+        Command::new("kill").arg("-INT").arg(child.id().to_string()).status().unwrap();
+    assert!(signal_status.success());
+    let exit_deadline = Instant::now() + Duration::from_secs(10);
+    let status = loop {
+        if let Some(status) = child.try_wait().unwrap() {
+            break status;
+        }
+        if Instant::now() >= exit_deadline {
+            child.kill().unwrap();
+            child.wait().unwrap();
+            panic!("CLI did not finish cleanup after SIGINT");
+        }
+        std::thread::sleep(Duration::from_millis(1));
+    };
+
+    assert_eq!(status.code(), Some(130));
+    assert!(!output_dir.join("system.img").exists());
+    assert_eq!(sha256(&fs::read(source_path).unwrap()), sha256(&source));
+    assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
+}
+
 #[cfg(unix)]
 #[test]
 fn source_and_destination_aliases_are_rejected_without_modifying_the_source() {
diff --git a/tests/python_smoke.py b/tests/python_smoke.py
index d32ba71..4997436 100644
--- a/tests/python_smoke.py
+++ b/tests/python_smoke.py
@@ -23,6 +23,22 @@ def main() -> None:
         else:
             raise AssertionError("invalid payload unexpectedly succeeded")
 
+        cancellation_token = otadump.CancellationToken()
+        cancellation_token.cancel()
+        cancellation_token.cancel()
+        cancelled_output = temporary_path / "cancelled-output"
+        try:
+            otadump.extract(
+                payload_file,
+                cancelled_output,
+                cancellation_token=cancellation_token,
+            )
+        except KeyboardInterrupt:
+            pass
+        else:
+            raise AssertionError("cancelled extraction unexpectedly succeeded")
+        assert not cancelled_output.exists()
+
 
 if __name__ == "__main__":
     main()

From da3d1043a5fc57c0f0967354db1241cef6103753 Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Fri, 11 Sep 2026 14:57:28 +0530
Subject: [PATCH 03/42] extractor: Apply BSDIFF delta operations

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 Cargo.lock                |  63 +++++++++++++++-
 Cargo.toml                |   2 +
 README.md                 |   3 +-
 src/lib.rs                |  46 ++++++++++++
 tests/delta_extraction.rs | 153 ++++++++++++++++++++++++++++++++++++++
 5 files changed, 264 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6ed9355..a550f90 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11,6 +11,21 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e76a019e91224d279006ff972f1e984179a6e9feb050adba6ce8274aef23195"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
 [[package]]
 name = "anstream"
 version = "0.6.19"
@@ -91,6 +106,37 @@ dependencies = [
  "objc2",
 ]
 
+[[package]]
+name = "brotli"
+version = "8.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cc91aac060a7a1e25823bdccbfb6af1875b88f17c6daac97894eed8207166b3"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "5.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a32acac15fe1967bc3986b2a6347dffc965602354ea6f450ad07e8bfd253583"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
+[[package]]
+name = "bsdiff-android"
+version = "0.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd6e86c63a796e87fc125590d0dd6e6933a873642e6f8bbfea8eb31bb527ce56"
+dependencies = [
+ "brotli",
+ "bzip2",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.18.1"
@@ -105,13 +151,24 @@ checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
 
 [[package]]
 name = "bzip2"
-version = "0.6.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bea8dcd42434048e4f7a304411d9273a411f647446c1234a65ce0554923f4cff"
+checksum = "f3a53fac24f34a81bc9954b5d6cfce0c21e18ec6959f44f56e8e90e4bb7c346c"
 dependencies = [
+ "bzip2-sys",
  "libbz2-rs-sys",
 ]
 
+[[package]]
+name = "bzip2-sys"
+version = "0.1.13+1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "225bff33b2141874fe80d71e07d6eec4f85c5c216453dd96388240f96e1acc14"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
+
 [[package]]
 name = "cc"
 version = "1.2.27"
@@ -575,6 +632,8 @@ name = "otadump"
 version = "0.1.3"
 dependencies = [
  "anyhow",
+ "brotli",
+ "bsdiff-android",
  "bzip2",
  "clap",
  "color-print",
diff --git a/Cargo.toml b/Cargo.toml
index e5e946f..1920a7b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,6 +26,8 @@ protoc-bin-vendored = "3.2.0"
 
 [dependencies]
 anyhow = "1.0.69"
+brotli = "8.0.2"
+bsdiff-android = "0.0.2"
 bzip2 = { version = "0.6.0" }
 clap = { version = "4.2.1", features = ["derive"] }
 color-print = "0.3.4"
diff --git a/README.md b/README.md
index 3bdc4d2..f4bf7b6 100644
--- a/README.md
+++ b/README.md
@@ -81,7 +81,8 @@ otadump ota.zip
 # Run on payload.bin file.
 otadump payload.bin
 
-# Apply a SOURCE_COPY delta payload with matching base partition images.
+# Apply a SOURCE_COPY, SOURCE_BSDIFF, or BROTLI_BSDIFF delta payload with
+# matching base partition images.
 otadump delta.zip --output-dir output --source-dir source-images
 ```
 
diff --git a/src/lib.rs b/src/lib.rs
index a8b8c75..7c1446c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -19,6 +19,7 @@ use std::sync::{Arc, OnceLock};
 use std::{error, result, slice, thread};
 
 use anyhow::{Context as _, Error, Result, bail, ensure};
+use bsdiff_android::patch_bsdf2;
 use bzip2::read::BzDecoder;
 use chromeos_update_engine::install_operation::Type;
 use chromeos_update_engine::{DeltaArchiveManifest, InstallOperation, PartitionUpdate};
@@ -853,6 +854,14 @@ impl Task<'_> {
                 self.write_exact(&source, &mut dst_extents)
                     .context("Error in SOURCE_COPY operation")
             }
+            Type::SourceBsdiff => {
+                let patch = self.extract_data(op).context("Error extracting SOURCE_BSDIFF data")?;
+                self.run_op_bsdiff(op, patch, "SOURCE_BSDIFF", &mut dst_extents)
+            }
+            Type::BrotliBsdiff => {
+                let patch = self.extract_data(op).context("Error extracting BROTLI_BSDIFF data")?;
+                self.run_op_bsdiff(op, patch, "BROTLI_BSDIFF", &mut dst_extents)
+            }
             Type::Zero | Type::Discard => {
                 for extent in dst_extents {
                     for chunk in extent.chunks_mut(VERIFY_CHUNK_SIZE) {
@@ -884,6 +893,30 @@ impl Task<'_> {
         Ok(data)
     }
 
+    fn run_op_bsdiff(
+        &self,
+        op: &InstallOperation,
+        patch: &[u8],
+        operation: &str,
+        dst_extents: &mut [&mut [u8]],
+    ) -> Result<()> {
+        let source = self.extract_source_data(op)?;
+        let expected_output_len = dst_extents.iter().try_fold(0usize, |len, extent| {
+            len.checked_add(extent.len()).context("Combined destination length overflow")
+        })?;
+        validate_bsdiff_output_len(patch, expected_output_len)
+            .map_err(|error| anyhow::anyhow!("{operation} patch is invalid: {error}"))?;
+        self.cancellation_token.check()?;
+        let mut output = Vec::new();
+        output
+            .try_reserve_exact(expected_output_len)
+            .context("Unable to allocate patched output buffer")?;
+        patch_bsdf2(&source, patch, &mut output)
+            .map_err(|error| anyhow::anyhow!("{operation} patch is invalid: {error}"))?;
+        self.cancellation_token.check()?;
+        self.write_exact(&output, dst_extents)
+    }
+
     fn write_exact(&self, data: &[u8], dst_extents: &mut [&mut [u8]]) -> Result<()> {
         let dst_len = dst_extents.iter().try_fold(0usize, |len, extent| {
             len.checked_add(extent.len()).context("Combined destination length overflow")
@@ -1002,6 +1035,19 @@ impl Task<'_> {
     }
 }
 
+fn validate_bsdiff_output_len(patch: &[u8], expected: usize) -> Result<()> {
+    ensure!(patch.len() >= 32, "Patch data too short");
+    ensure!(
+        &patch[..8] == b"BSDIFF40" || &patch[..5] == b"BSDF2",
+        "Invalid BSDIFF/BSDF2 magic header"
+    );
+    let encoded = u64::from_le_bytes(patch[24..32].try_into().unwrap());
+    ensure!(encoded & (1 << 63) == 0, "Negative output length in patch header");
+    let actual = usize::try_from(encoded).context("Patch output length is too large")?;
+    ensure!(actual == expected, "Patch output length mismatch: expected {expected}, got {actual}");
+    Ok(())
+}
+
 pub trait ProgressReporter: Sync {
     /// Reports the progress of the extraction process. The progress is provided
     /// as a value between 0 and 1.
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index 1ce68d1..a0ef81b 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -71,6 +71,26 @@ fn sha256(bytes: &[u8]) -> Vec<u8> {
     digest::digest(&digest::SHA256, bytes).as_ref().to_vec()
 }
 
+// Hand-authored BSDIFF40 and BSDF2 fixtures. The test data is covered by this
+// project's MIT license and was not generated by the patch implementation.
+const BSDIFF40_PATCH: &[u8] = &[
+    66, 83, 68, 73, 70, 70, 52, 48, 41, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0,
+    0, 0, 0, 0, 66, 90, 104, 57, 49, 65, 89, 38, 83, 89, 184, 173, 85, 59, 0, 0, 2, 96, 0, 64, 64,
+    8, 0, 32, 0, 48, 204, 12, 245, 5, 206, 46, 228, 138, 112, 161, 33, 113, 90, 170, 118, 66, 90,
+    104, 57, 49, 65, 89, 38, 83, 89, 168, 46, 248, 254, 0, 0, 2, 192, 0, 192, 0, 2, 0, 32, 0, 48,
+    128, 103, 161, 185, 11, 185, 34, 156, 40, 72, 84, 23, 124, 127, 0, 66, 90, 104, 57, 23, 114,
+    69, 56, 80, 144, 0, 0, 0, 0,
+];
+const BROTLI_BSDF2_PATCH: &[u8] = &[
+    66, 83, 68, 70, 50, 2, 2, 2, 12, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0,
+    0, 0, 0, 31, 23, 0, 248, 167, 0, 16, 98, 141, 0, 160, 0, 143, 3, 128, 0, 0, 245, 245, 0, 0, 0,
+    0, 3, 63,
+];
+const BROTLI_INVALID_HEADER_PATCH: &[u8] = &[
+    66, 83, 68, 70, 50, 2, 2, 2, 12, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0,
+    0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+];
+
 fn extent(start_block: u64, num_blocks: u64) -> Extent {
     Extent { start_block: Some(start_block), num_blocks: Some(num_blocks) }
 }
@@ -132,6 +152,139 @@ fn source_copy_reconstructs_noncontiguous_extents_without_modifying_source() {
     assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
 }
 
+#[test]
+fn source_bsdiff_reconstructs_bsdiff40_without_modifying_source() {
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+    let source = b"abcdefgh";
+    let expected = b"abXYefgh";
+    fs::write(source_dir.join("system.img"), source).unwrap();
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(1),
+        minor_version: Some(2),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(source)),
+            new_partition_info: Some(partition_info(expected)),
+            operations: vec![InstallOperation {
+                operation_type: 5,
+                data_offset: Some(0),
+                data_length: Some(BSDIFF40_PATCH.len() as u64),
+                src_extents: vec![extent(0, source.len() as u64)],
+                src_length: Some(source.len() as u64),
+                dst_extents: vec![extent(0, expected.len() as u64)],
+                dst_length: Some(expected.len() as u64),
+                data_sha256_hash: Some(sha256(BSDIFF40_PATCH)),
+                src_sha256_hash: Some(sha256(source)),
+            }],
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, BSDIFF40_PATCH);
+
+    ExtractOptions::new()
+        .source_dir(&source_dir)
+        .num_threads(2)
+        .extract(&payload, &output_dir)
+        .unwrap();
+
+    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), expected);
+    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+}
+
+#[test]
+fn brotli_bsdiff_reconstructs_bsdf2_without_modifying_source() {
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+    let source = b"abcdefgh";
+    let expected = b"abXYefgh";
+    fs::write(source_dir.join("system.img"), source).unwrap();
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(1),
+        minor_version: Some(4),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(source)),
+            new_partition_info: Some(partition_info(expected)),
+            operations: vec![InstallOperation {
+                operation_type: 10,
+                data_offset: Some(0),
+                data_length: Some(BROTLI_BSDF2_PATCH.len() as u64),
+                src_extents: vec![extent(0, source.len() as u64)],
+                src_length: Some(source.len() as u64),
+                dst_extents: vec![extent(0, expected.len() as u64)],
+                dst_length: Some(expected.len() as u64),
+                data_sha256_hash: Some(sha256(BROTLI_BSDF2_PATCH)),
+                src_sha256_hash: Some(sha256(source)),
+            }],
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, BROTLI_BSDF2_PATCH);
+
+    ExtractOptions::new()
+        .source_dir(&source_dir)
+        .num_threads(2)
+        .extract(&payload, &output_dir)
+        .unwrap();
+
+    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), expected);
+    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+}
+
+#[test]
+fn malformed_bsdiff_headers_fail_cleanly_and_remove_staging() {
+    for (operation_type, patch, expected_error) in [
+        (5, &[0; 32][..], "SOURCE_BSDIFF patch is invalid"),
+        (10, BROTLI_INVALID_HEADER_PATCH, "BROTLI_BSDIFF patch is invalid"),
+    ] {
+        let temporary = TempDir::new().unwrap();
+        let source_dir = temporary.path().join("source");
+        let output_dir = temporary.path().join("output");
+        fs::create_dir(&source_dir).unwrap();
+        let source = b"abcdefgh";
+        fs::write(source_dir.join("system.img"), source).unwrap();
+        let manifest = DeltaArchiveManifest {
+            block_size: Some(1),
+            minor_version: Some(4),
+            partitions: vec![PartitionUpdate {
+                partition_name: "system".into(),
+                old_partition_info: Some(partition_info(source)),
+                new_partition_info: Some(partition_info(b"abXYefgh")),
+                operations: vec![InstallOperation {
+                    operation_type,
+                    data_offset: Some(0),
+                    data_length: Some(patch.len() as u64),
+                    src_extents: vec![extent(0, source.len() as u64)],
+                    src_length: Some(source.len() as u64),
+                    dst_extents: vec![extent(0, source.len() as u64)],
+                    dst_length: Some(source.len() as u64),
+                    data_sha256_hash: Some(sha256(patch)),
+                    src_sha256_hash: Some(sha256(source)),
+                }],
+            }],
+        };
+        let payload = temporary.path().join("payload.bin");
+        write_payload(&payload, manifest, patch);
+
+        let error = ExtractOptions::new()
+            .source_dir(&source_dir)
+            .num_threads(2)
+            .extract(&payload, &output_dir)
+            .unwrap_err()
+            .to_string();
+
+        assert!(error.contains(expected_error), "unexpected error: {error}");
+        assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+        assert!(!output_dir.join("system.img").exists());
+        assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
+    }
+}
+
 #[test]
 fn source_validation_rejects_wrong_base_before_creating_output() {
     let temporary = TempDir::new().unwrap();

From a7d635835917c5b9d102a5b500e66e3816fb1671 Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Fri, 11 Sep 2026 15:11:39 +0530
Subject: [PATCH 04/42] cli: Return failure for extraction errors

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 src/main.rs               | 22 ++++++++++++----------
 tests/delta_extraction.rs | 39 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 10 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 6a72c93..70e3e6d 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,15 +1,18 @@
+use std::process::ExitCode;
+
 use clap::Parser;
 use indicatif::{ProgressBar, ProgressStyle};
 use otadump::{CancellationToken, ExtractOptions, ProgressReporter, is_cancellation};
 
-fn main() -> Result<(), ctrlc::Error> {
+fn main() -> Result<ExitCode, ctrlc::Error> {
     let cancellation_token = CancellationToken::new();
     let signal_token = cancellation_token.clone();
     ctrlc::set_handler(move || signal_token.cancel())?;
-    if extract(&cancellation_token) || cancellation_token.is_cancelled() {
-        std::process::exit(130);
+    let exit_code = extract(&cancellation_token);
+    if cancellation_token.is_cancelled() {
+        return Ok(ExitCode::from(130));
     }
-    Ok(())
+    Ok(exit_code)
 }
 
 const HELP_TEMPLATE: &str = color_print::cstr!(
@@ -49,7 +52,7 @@ pub struct Args {
     pub source_dir: Option<String>,
 }
 
-pub fn extract(cancellation_token: &CancellationToken) -> bool {
+pub fn extract(cancellation_token: &CancellationToken) -> ExitCode {
     let args = Args::parse();
 
     let reporter = Box::new(CliProgressReporter::new());
@@ -66,15 +69,14 @@ pub fn extract(cancellation_token: &CancellationToken) -> bool {
         Ok(()) => {
             let message = format!("Extraction complete: {}", args.output_dir);
             reporter.progress_bar.println(message);
-            false
+            ExitCode::SUCCESS
         }
         Err(e) => {
             if is_cancellation(e.as_ref()) {
-                return true;
+                return ExitCode::from(130);
             }
-            let message = format!("Error: {e:?}");
-            reporter.progress_bar.println(message);
-            false
+            eprintln!("Error: {e:?}");
+            ExitCode::FAILURE
         }
     }
 }
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index a0ef81b..13541aa 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -695,6 +695,45 @@ fn cancellation_cleans_staging_without_promoting_or_modifying_source() {
     );
 }
 
+#[test]
+fn cli_extraction_error_exits_nonzero_and_reports_diagnostic() {
+    use std::process::Command;
+
+    let temporary = TempDir::new().unwrap();
+    let payload = temporary.path().join("payload.bin");
+    let output_dir = temporary.path().join("output");
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(4),
+        minor_version: Some(2),
+        partitions: vec![PartitionUpdate {
+            partition_name: "boot".into(),
+            old_partition_info: Some(partition_info(b"base")),
+            new_partition_info: Some(partition_info(b"base")),
+            operations: vec![InstallOperation {
+                operation_type: 4,
+                src_extents: vec![extent(0, 1)],
+                dst_extents: vec![extent(0, 1)],
+                ..Default::default()
+            }],
+        }],
+    };
+    write_payload(&payload, manifest, &[]);
+
+    let output = Command::new(env!("CARGO_BIN_EXE_otadump"))
+        .arg(&payload)
+        .arg("--output-dir")
+        .arg(&output_dir)
+        .output()
+        .unwrap();
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    assert_eq!(output.status.code(), Some(1), "CLI did not exit with code 1; stderr: {stderr}");
+    assert!(
+        stderr.contains("require a source directory"),
+        "missing extraction diagnostic: {stderr}"
+    );
+}
+
 #[cfg(unix)]
 #[test]
 fn cli_sigint_exits_130_after_cleaning_staging() {

From 2c901600b7c94a8e55e43eb5000dc26343d4923c Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Fri, 11 Sep 2026 15:35:26 +0530
Subject: [PATCH 05/42] extractor: Accept padded source images

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 src/lib.rs                |  25 +++++----
 tests/delta_extraction.rs | 115 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 128 insertions(+), 12 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 7c1446c..fdb40b0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -464,8 +464,18 @@ impl<'a> ExtractOptions<'a> {
             .metadata()
             .with_context(|| format!("Unable to inspect source partition image: {path:?}"))?;
         ensure!(metadata.is_file(), "Source partition image is not a file: {path:?}");
-        let len = usize::try_from(metadata.len()).context("Source partition is too large")?;
-        let mmap = if len == 0 {
+        let backing_len =
+            usize::try_from(metadata.len()).context("Source partition is too large")?;
+        let info =
+            update.old_partition_info.as_ref().context("Source partition info is missing")?;
+        let expected_size = info.size.context("Source partition size is missing")?;
+        let len = usize::try_from(expected_size).context("Source partition is too large")?;
+        ensure!(
+            backing_len >= len,
+            "Source partition size mismatch for {:?}: expected at least {expected_size}, got {backing_len}",
+            update.partition_name,
+        );
+        let mmap = if backing_len == 0 {
             None
         } else {
             Some(
@@ -475,15 +485,6 @@ impl<'a> ExtractOptions<'a> {
         };
         let source = SourcePartition { path, len, mmap };
 
-        let info =
-            update.old_partition_info.as_ref().context("Source partition info is missing")?;
-        let expected_size = info.size.context("Source partition size is missing")?;
-        ensure!(
-            usize::try_from(expected_size).ok() == Some(source.len),
-            "Source partition size mismatch for {:?}: expected {expected_size}, got {}",
-            update.partition_name,
-            source.len
-        );
         let expected_hash = info.hash.as_deref().context("Source partition hash is missing")?;
         verify_hash(
             source.bytes(),
@@ -577,7 +578,7 @@ struct SourcePartition {
 
 impl SourcePartition {
     fn bytes(&self) -> &[u8] {
-        self.mmap.as_deref().unwrap_or_default()
+        &self.mmap.as_deref().unwrap_or_default()[..self.len]
     }
 }
 
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index 13541aa..12dea42 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -321,6 +321,121 @@ fn source_validation_rejects_wrong_base_before_creating_output() {
     assert!(!output_dir.join("boot.img").exists());
 }
 
+#[test]
+fn padded_source_uses_declared_prefix_without_modifying_tail() {
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+    let declared_source = b"base";
+    let source = b"basefooter";
+    fs::write(source_dir.join("system.img"), source).unwrap();
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(4),
+        minor_version: Some(2),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(declared_source)),
+            new_partition_info: Some(partition_info(declared_source)),
+            operations: vec![InstallOperation {
+                operation_type: 4,
+                src_extents: vec![extent(0, 1)],
+                src_length: Some(4),
+                dst_extents: vec![extent(0, 1)],
+                dst_length: Some(4),
+                src_sha256_hash: Some(sha256(declared_source)),
+                ..Default::default()
+            }],
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &[]);
+
+    ExtractOptions::new().source_dir(&source_dir).extract(&payload, &output_dir).unwrap();
+
+    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), declared_source);
+    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+}
+
+#[test]
+fn source_shorter_than_declared_size_fails_cleanly() {
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+    let source = b"bas";
+    fs::write(source_dir.join("system.img"), source).unwrap();
+    let declared_source = b"base";
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(4),
+        minor_version: Some(2),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(declared_source)),
+            new_partition_info: Some(partition_info(declared_source)),
+            operations: vec![InstallOperation {
+                operation_type: 4,
+                src_extents: vec![extent(0, 1)],
+                dst_extents: vec![extent(0, 1)],
+                ..Default::default()
+            }],
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &[]);
+
+    let error = ExtractOptions::new()
+        .source_dir(&source_dir)
+        .extract(&payload, &output_dir)
+        .unwrap_err()
+        .to_string();
+
+    assert!(error.contains("Source partition size mismatch"), "unexpected error: {error}");
+    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+    assert!(!output_dir.join("system.img").exists());
+}
+
+#[test]
+fn source_extent_cannot_enter_padding_beyond_declared_size() {
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+    let declared_source = b"base";
+    let source = b"basefoot";
+    fs::write(source_dir.join("system.img"), source).unwrap();
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(4),
+        minor_version: Some(2),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(declared_source)),
+            new_partition_info: Some(partition_info(declared_source)),
+            operations: vec![InstallOperation {
+                operation_type: 4,
+                src_extents: vec![extent(1, 1)],
+                src_length: Some(4),
+                dst_extents: vec![extent(0, 1)],
+                dst_length: Some(4),
+                src_sha256_hash: Some(sha256(b"foot")),
+                ..Default::default()
+            }],
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &[]);
+
+    let error = ExtractOptions::new()
+        .source_dir(&source_dir)
+        .extract(&payload, &output_dir)
+        .unwrap_err()
+        .to_string();
+
+    assert!(error.contains("Invalid source extents"), "unexpected error: {error}");
+    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+    assert!(!output_dir.join("system.img").exists());
+}
+
 #[test]
 fn delta_operation_without_source_directory_fails_clearly() {
     let temporary = TempDir::new().unwrap();

From 4fe2369cfd4363284bbbc96029c11af917e03790 Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Fri, 11 Sep 2026 16:23:41 +0530
Subject: [PATCH 06/42] verity: Generate partition hash trees

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 src/lib.rs                | 141 ++++++++++++++++--------
 src/verity.rs             | 187 ++++++++++++++++++++++++++++++++
 tests/delta_extraction.rs | 221 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 502 insertions(+), 47 deletions(-)
 create mode 100644 src/verity.rs

diff --git a/src/lib.rs b/src/lib.rs
index fdb40b0..481528e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,10 +6,11 @@ mod chromeos_update_engine {
 mod payload;
 #[cfg(feature = "python")]
 mod python;
+mod verity;
 
 use std::cmp::Reverse;
 use std::collections::HashSet;
-use std::fs::{self, File};
+use std::fs::{self, File, OpenOptions};
 use std::io::Read;
 use std::num::NonZero;
 use std::ops::Range;
@@ -26,7 +27,7 @@ use chromeos_update_engine::{DeltaArchiveManifest, InstallOperation, PartitionUp
 use liblzma::read::XzDecoder;
 use memmap2::{Mmap, MmapMut, MmapOptions};
 use prost::Message as _;
-use rayon::{BroadcastContext, ThreadPoolBuilder};
+use rayon::ThreadPoolBuilder;
 use ring::digest;
 use sync_unsafe_cell::SyncUnsafeCell;
 use tempfile::TempPath;
@@ -126,7 +127,7 @@ impl<'a> ExtractOptions<'a> {
         let output_dir = output_dir.as_ref();
         match self.extract_impl(payload_file, output_dir) {
             Ok(()) => Ok(()),
-            Err(error) if error.is::<ExtractionCancelled>() => Err(Box::new(ExtractionCancelled)),
+            Err(error) if is_cancellation(error.as_ref()) => Err(Box::new(ExtractionCancelled)),
             Err(error) => Err(error.into()),
         }
     }
@@ -183,11 +184,12 @@ impl<'a> ExtractOptions<'a> {
         fs::create_dir_all(output_dir)
             .with_context(|| format!("Could not create output directory: {output_dir:?}"))?;
 
-        let sources = manifest
+        let validated = manifest
             .partitions
             .iter()
             .map(|update| self.validate_partition(update, &payload, block_size))
             .collect::<Result<Vec<_>>>()?;
+        let (sources, verity_configs): (Vec<_>, Vec<_>) = validated.into_iter().unzip();
 
         let mut partition_names = HashSet::with_capacity(manifest.partitions.len());
         let mut destinations = Vec::with_capacity(manifest.partitions.len());
@@ -269,8 +271,8 @@ impl<'a> ExtractOptions<'a> {
                     cancellation_token: &self.cancellation_token,
                     error: &error,
                 };
-                scope.spawn_broadcast(move |_, ctx| {
-                    if let Err(e) = task.run(ctx) {
+                scope.spawn_broadcast(move |_, _| {
+                    if let Err(e) = task.run() {
                         _ = task.error.set(e);
                     }
                 });
@@ -282,6 +284,42 @@ impl<'a> ExtractOptions<'a> {
             return Err(e);
         }
 
+        for ((update, verity_config), staging_path) in
+            manifest.partitions.iter().zip(verity_configs).zip(&staging_paths)
+        {
+            self.cancellation_token.check()?;
+            let file = OpenOptions::new()
+                .read(true)
+                .write(true)
+                .open(staging_path)
+                .context("Unable to reopen staged partition image")?;
+            let mut partition = unsafe { MmapMut::map_mut(&file) }
+                .context("Failed to mmap staged partition image")?;
+            if let Some(config) = verity_config.as_ref() {
+                verity::generate(&mut partition, config, block_size, &self.cancellation_token)
+                    .map_err(|error| {
+                        if is_cancellation(error.as_ref()) {
+                            error
+                        } else {
+                            error.context(format!(
+                                "Failed to generate hash tree for {:?}",
+                                update.partition_name
+                            ))
+                        }
+                    })?;
+            }
+            verify_partition(
+                update,
+                &partition,
+                total_ops,
+                &total_ops_completed,
+                self.progress_reporter,
+                &self.cancellation_token,
+            )?;
+            self.cancellation_token.check()?;
+            partition.flush().context("Error while flushing file to disk")?;
+        }
+
         for (staging_path, destination) in staging_paths.into_iter().zip(destinations) {
             self.cancellation_token.check()?;
             let result = if self.overwrite {
@@ -349,7 +387,7 @@ impl<'a> ExtractOptions<'a> {
         update: &PartitionUpdate,
         payload: &Payload<'_>,
         block_size: usize,
-    ) -> Result<Option<SourcePartition>> {
+    ) -> Result<(Option<SourcePartition>, Option<verity::VerityConfig>)> {
         validate_partition_name(&update.partition_name)?;
         self.cancellation_token.check()?;
 
@@ -447,7 +485,12 @@ impl<'a> ExtractOptions<'a> {
             );
         }
 
-        Ok(source)
+        let verity = verity::validate(update, block_size, partition_len, &destination_ranges)
+            .map_err(|error| {
+                anyhow::anyhow!("Invalid verity metadata for {:?}: {error}", update.partition_name)
+            })?;
+
+        Ok((source, verity))
     }
 
     fn open_source_partition(&self, update: &PartitionUpdate) -> Result<SourcePartition> {
@@ -791,7 +834,7 @@ struct Task<'a> {
 }
 
 impl Task<'_> {
-    fn run(&self, ctx: BroadcastContext<'_>) -> Result<()> {
+    fn run(&self) -> Result<()> {
         // If an error has already occurred, stop processing the partition.
         while self.error.get().is_none() {
             self.cancellation_token.check()?;
@@ -803,16 +846,6 @@ impl Task<'_> {
                     self.increment_progress();
                 }
                 None => {
-                    // If this is the last thread to fetch an operation for this
-                    // partition, the partition is fully extracted and can now be
-                    // verified.
-                    if op_idx + 1 == self.update.operations.len() + ctx.num_threads() {
-                        self.cancellation_token.check()?;
-                        self.verify_partition()?;
-                        self.cancellation_token.check()?;
-                        unsafe { (*self.partition.get()).flush() }
-                            .context("Error while flushing file to disk")?;
-                    };
                     break;
                 }
             }
@@ -1001,38 +1034,52 @@ impl Task<'_> {
         verify_hash(data, op.data_sha256_hash.as_deref(), "Input", self.cancellation_token)
     }
 
-    fn verify_partition(&self) -> Result<()> {
-        let exp_hash = self
-            .update
-            .new_partition_info
-            .as_ref()
-            .and_then(|info| info.hash.as_ref())
-            .context("Unable to determine output partition hash")?;
+    fn increment_progress(&self) {
+        increment_progress(self.total_ops, self.total_ops_completed, self.progress_reporter);
+    }
+}
 
-        let mut digest = digest::Context::new(&digest::SHA256);
-        for chunk in unsafe { (*self.partition.get()).chunks(VERIFY_CHUNK_SIZE) } {
-            self.cancellation_token.check()?;
-            digest.update(chunk);
-            self.increment_progress();
-        }
+fn verify_partition(
+    update: &PartitionUpdate,
+    partition: &[u8],
+    total_ops: usize,
+    total_ops_completed: &AtomicUsize,
+    progress_reporter: &dyn ProgressReporter,
+    cancellation_token: &CancellationToken,
+) -> Result<()> {
+    let exp_hash = update
+        .new_partition_info
+        .as_ref()
+        .and_then(|info| info.hash.as_ref())
+        .context("Unable to determine output partition hash")?;
 
-        self.cancellation_token.check()?;
-        let got_hash = digest.finish();
-        let got_hash = got_hash.as_ref();
-        ensure!(
-            got_hash == exp_hash,
-            "Output verification failed: hash mismatch: expected {}, got {got_hash:?}",
-            hex::encode(exp_hash)
-        );
-        Ok(())
+    let mut context = digest::Context::new(&digest::SHA256);
+    for chunk in partition.chunks(VERIFY_CHUNK_SIZE) {
+        cancellation_token.check()?;
+        context.update(chunk);
+        increment_progress(total_ops, total_ops_completed, progress_reporter);
     }
 
-    fn increment_progress(&self) {
-        let total_ops_completed = self.total_ops_completed.fetch_add(1, Ordering::Relaxed) + 1;
-        if total_ops_completed % 16 == 0 {
-            let progress = total_ops_completed as f64 / self.total_ops as f64;
-            self.progress_reporter.report_progress(progress);
-        }
+    cancellation_token.check()?;
+    let got_hash = context.finish();
+    ensure!(
+        got_hash.as_ref() == exp_hash,
+        "Output verification failed: hash mismatch: expected {}, got {}",
+        hex::encode(exp_hash),
+        hex::encode(got_hash.as_ref())
+    );
+    Ok(())
+}
+
+fn increment_progress(
+    total_ops: usize,
+    total_ops_completed: &AtomicUsize,
+    progress_reporter: &dyn ProgressReporter,
+) {
+    let total_ops_completed = total_ops_completed.fetch_add(1, Ordering::Relaxed) + 1;
+    if total_ops_completed % 16 == 0 {
+        let progress = total_ops_completed as f64 / total_ops as f64;
+        progress_reporter.report_progress(progress);
     }
 }
 
diff --git a/src/verity.rs b/src/verity.rs
new file mode 100644
index 0000000..e917adf
--- /dev/null
+++ b/src/verity.rs
@@ -0,0 +1,187 @@
+use std::ops::Range;
+
+use anyhow::{Context as _, Result, bail, ensure};
+use ring::digest;
+
+use crate::CancellationToken;
+use crate::chromeos_update_engine::{Extent, PartitionUpdate};
+
+const SHA256_SIZE: usize = 32;
+
+pub(crate) struct VerityConfig {
+    data: Range<usize>,
+    tree: Range<usize>,
+    salt: Vec<u8>,
+}
+
+pub(crate) fn validate(
+    update: &PartitionUpdate,
+    block_size: usize,
+    partition_len: usize,
+    operation_destinations: &[(Range<usize>, usize)],
+) -> Result<Option<VerityConfig>> {
+    if extent_num_blocks(update.fec_extent.as_ref(), "FEC")?.unwrap_or(0) > 0 {
+        bail!("FEC generation is not supported for partition {:?}", update.partition_name);
+    }
+
+    let data_blocks =
+        extent_num_blocks(update.hash_tree_data_extent.as_ref(), "Hash tree data")?.unwrap_or(0);
+    let tree_blocks =
+        extent_num_blocks(update.hash_tree_extent.as_ref(), "Hash tree")?.unwrap_or(0);
+    ensure!(
+        (data_blocks == 0) == (tree_blocks == 0),
+        "Hash tree data and storage extents must both be nonempty"
+    );
+    if tree_blocks == 0 {
+        return Ok(None);
+    }
+
+    let algorithm = update.hash_tree_algorithm.as_deref().unwrap_or_default();
+    let is_sha256 =
+        algorithm.eq_ignore_ascii_case("sha256") || algorithm.eq_ignore_ascii_case("sha-256");
+    ensure!(is_sha256, "Unsupported verity hash algorithm: {algorithm:?}");
+    ensure!(
+        block_size > SHA256_SIZE * 2 && block_size % SHA256_SIZE == 0,
+        "Block size {block_size} is not supported for SHA-256 verity trees"
+    );
+
+    let data_extent =
+        update.hash_tree_data_extent.as_ref().context("Hash tree data extent is missing")?;
+    let tree_extent =
+        update.hash_tree_extent.as_ref().context("Hash tree storage extent is missing")?;
+    let data = extent_range(data_extent, block_size, partition_len, "Hash tree data")?;
+    let tree = extent_range(tree_extent, block_size, partition_len, "Hash tree")?;
+    ensure!(!ranges_overlap(&data, &tree), "Hash tree data and storage extents overlap");
+    ensure!(
+        operation_destinations.iter().all(|(destination, _)| !ranges_overlap(&tree, destination)),
+        "Hash tree extent overlaps destination extents"
+    );
+
+    let hashes_per_block = block_size / SHA256_SIZE;
+    let mut level_blocks = div_ceil(data_blocks, hashes_per_block)?;
+    let mut required_blocks = 0usize;
+    loop {
+        required_blocks =
+            required_blocks.checked_add(level_blocks).context("Hash tree size overflow")?;
+        if level_blocks == 1 {
+            break;
+        }
+        level_blocks = div_ceil(level_blocks, hashes_per_block)?;
+    }
+    let required_size =
+        required_blocks.checked_mul(block_size).context("Hash tree size overflow")?;
+    ensure!(
+        tree.len() == required_size,
+        "Hash tree size mismatch: expected {required_size} bytes, got {}",
+        tree.len()
+    );
+
+    Ok(Some(VerityConfig { data, tree, salt: update.hash_tree_salt.clone().unwrap_or_default() }))
+}
+
+pub(crate) fn generate(
+    partition: &mut [u8],
+    config: &VerityConfig,
+    block_size: usize,
+    cancellation_token: &CancellationToken,
+) -> Result<()> {
+    cancellation_token.check()?;
+    let hashes_per_block = block_size / SHA256_SIZE;
+    let data_blocks = config.data.len() / block_size;
+    let base_blocks = div_ceil(data_blocks, hashes_per_block)?;
+    let mut level = zeroed_level(base_blocks, block_size)?;
+    for (block, hash_slot) in partition[config.data.clone()]
+        .chunks_exact(block_size)
+        .zip(level.chunks_exact_mut(SHA256_SIZE))
+    {
+        cancellation_token.check()?;
+        hash_slot.copy_from_slice(salted_hash(&config.salt, block).as_ref());
+    }
+
+    let mut levels = vec![level];
+    while levels.last().expect("base level exists").len() > block_size {
+        let current = levels.last().expect("base level exists");
+        let next_blocks = div_ceil(current.len() / block_size, hashes_per_block)?;
+        let mut next = zeroed_level(next_blocks, block_size)?;
+        for (block, hash_slot) in
+            current.chunks_exact(block_size).zip(next.chunks_exact_mut(SHA256_SIZE))
+        {
+            cancellation_token.check()?;
+            hash_slot.copy_from_slice(salted_hash(&config.salt, block).as_ref());
+        }
+        levels.push(next);
+    }
+
+    let tree = &mut partition[config.tree.clone()];
+    let mut offset = 0usize;
+    for level in levels.iter().rev() {
+        for block in level.chunks_exact(block_size) {
+            cancellation_token.check()?;
+            let end = offset.checked_add(block_size).context("Hash tree write overflow")?;
+            tree[offset..end].copy_from_slice(block);
+            offset = end;
+        }
+    }
+    ensure!(offset == tree.len(), "Generated hash tree size mismatch");
+    cancellation_token.check()
+}
+
+fn extent_num_blocks(extent: Option<&Extent>, label: &str) -> Result<Option<usize>> {
+    extent
+        .map(|extent| {
+            usize::try_from(
+                extent
+                    .num_blocks
+                    .with_context(|| format!("{label} extent block count is missing"))?,
+            )
+            .with_context(|| format!("{label} extent block count is too large"))
+        })
+        .transpose()
+}
+
+fn extent_range(
+    extent: &Extent,
+    block_size: usize,
+    partition_len: usize,
+    label: &str,
+) -> Result<Range<usize>> {
+    let start_block = usize::try_from(
+        extent.start_block.with_context(|| format!("{label} extent start block is missing"))?,
+    )
+    .with_context(|| format!("{label} extent start block is too large"))?;
+    let num_blocks = usize::try_from(
+        extent.num_blocks.with_context(|| format!("{label} extent block count is missing"))?,
+    )
+    .with_context(|| format!("{label} extent block count is too large"))?;
+    let start = start_block.checked_mul(block_size).context("Verity extent offset overflow")?;
+    let len = num_blocks.checked_mul(block_size).context("Verity extent length overflow")?;
+    let end = start.checked_add(len).context("Verity extent end overflow")?;
+    ensure!(end <= partition_len, "{label} extent exceeds partition size");
+    Ok(start..end)
+}
+
+fn div_ceil(value: usize, divisor: usize) -> Result<usize> {
+    value
+        .checked_add(divisor - 1)
+        .context("Hash tree block count overflow")
+        .map(|rounded| rounded / divisor)
+}
+
+fn zeroed_level(blocks: usize, block_size: usize) -> Result<Vec<u8>> {
+    let len = blocks.checked_mul(block_size).context("Hash tree level size overflow")?;
+    let mut level = Vec::new();
+    level.try_reserve_exact(len).context("Unable to allocate hash tree")?;
+    level.resize(len, 0);
+    Ok(level)
+}
+
+fn salted_hash(salt: &[u8], block: &[u8]) -> digest::Digest {
+    let mut context = digest::Context::new(&digest::SHA256);
+    context.update(salt);
+    context.update(block);
+    context.finish()
+}
+
+fn ranges_overlap(left: &Range<usize>, right: &Range<usize>) -> bool {
+    left.start < right.end && right.start < left.end
+}
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index 12dea42..5eebaac 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -55,6 +55,20 @@ struct PartitionUpdate {
     new_partition_info: Option<PartitionInfo>,
     #[prost(message, repeated, tag = "8")]
     operations: Vec<InstallOperation>,
+    #[prost(message, optional, tag = "10")]
+    hash_tree_data_extent: Option<Extent>,
+    #[prost(message, optional, tag = "11")]
+    hash_tree_extent: Option<Extent>,
+    #[prost(string, optional, tag = "12")]
+    hash_tree_algorithm: Option<String>,
+    #[prost(bytes = "vec", optional, tag = "13")]
+    hash_tree_salt: Option<Vec<u8>>,
+    #[prost(message, optional, tag = "14")]
+    fec_data_extent: Option<Extent>,
+    #[prost(message, optional, tag = "15")]
+    fec_extent: Option<Extent>,
+    #[prost(uint32, optional, tag = "16")]
+    fec_roots: Option<u32>,
 }
 
 #[derive(Clone, PartialEq, Message)]
@@ -137,6 +151,7 @@ fn source_copy_reconstructs_noncontiguous_extents_without_modifying_source() {
             old_partition_info: Some(partition_info(source)),
             new_partition_info: Some(partition_info(expected)),
             operations: vec![operation],
+            ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
@@ -179,6 +194,7 @@ fn source_bsdiff_reconstructs_bsdiff40_without_modifying_source() {
                 data_sha256_hash: Some(sha256(BSDIFF40_PATCH)),
                 src_sha256_hash: Some(sha256(source)),
             }],
+            ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
@@ -221,6 +237,7 @@ fn brotli_bsdiff_reconstructs_bsdf2_without_modifying_source() {
                 data_sha256_hash: Some(sha256(BROTLI_BSDF2_PATCH)),
                 src_sha256_hash: Some(sha256(source)),
             }],
+            ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
@@ -266,6 +283,7 @@ fn malformed_bsdiff_headers_fail_cleanly_and_remove_staging() {
                     data_sha256_hash: Some(sha256(patch)),
                     src_sha256_hash: Some(sha256(source)),
                 }],
+                ..Default::default()
             }],
         };
         let payload = temporary.path().join("payload.bin");
@@ -306,6 +324,7 @@ fn source_validation_rejects_wrong_base_before_creating_output() {
             old_partition_info: Some(partition_info(b"good")),
             new_partition_info: Some(partition_info(b"good")),
             operations: vec![operation],
+            ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
@@ -346,6 +365,7 @@ fn padded_source_uses_declared_prefix_without_modifying_tail() {
                 src_sha256_hash: Some(sha256(declared_source)),
                 ..Default::default()
             }],
+            ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
@@ -379,6 +399,7 @@ fn source_shorter_than_declared_size_fails_cleanly() {
                 dst_extents: vec![extent(0, 1)],
                 ..Default::default()
             }],
+            ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
@@ -420,6 +441,7 @@ fn source_extent_cannot_enter_padding_beyond_declared_size() {
                 src_sha256_hash: Some(sha256(b"foot")),
                 ..Default::default()
             }],
+            ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
@@ -453,6 +475,7 @@ fn delta_operation_without_source_directory_fails_clearly() {
                 dst_extents: vec![extent(0, 1)],
                 ..Default::default()
             }],
+            ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
@@ -510,6 +533,7 @@ fn malformed_partition_layouts_fail_without_escaping_or_leaving_partial_images()
                 old_partition_info: None,
                 new_partition_info: Some(partition_info(target)),
                 operations,
+                ..Default::default()
             }],
         };
         let payload = temporary.path().join("payload.bin");
@@ -546,6 +570,7 @@ fn full_replace_payload_remains_compatible() {
             old_partition_info: None,
             new_partition_info: Some(partition_info(&padded)),
             operations: vec![operation],
+            ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
@@ -556,6 +581,191 @@ fn full_replace_payload_remains_compatible() {
     assert_eq!(fs::read(output_dir.join("vendor.img")).unwrap(), padded);
 }
 
+#[test]
+fn omitted_verity_tree_is_generated_in_aosp_top_down_order() {
+    const LEAF_HASHES: [[u8; 32]; 5] = [
+        [
+            0x2b, 0xbf, 0x03, 0x32, 0xe3, 0x58, 0xa6, 0xa5, 0xdd, 0xc7, 0x3e, 0xa7, 0x1e, 0x75,
+            0xdc, 0x83, 0xf5, 0x8f, 0xec, 0xfc, 0x25, 0x4a, 0x4e, 0x7d, 0x41, 0x33, 0x86, 0x95,
+            0x8b, 0xd9, 0xe0, 0x00,
+        ],
+        [
+            0x24, 0x59, 0x0e, 0xd6, 0xcb, 0x84, 0x1e, 0xa2, 0xe5, 0xd8, 0x39, 0xe7, 0xc6, 0x3d,
+            0xb6, 0x9b, 0x75, 0x50, 0xb4, 0x88, 0x60, 0x7a, 0xf2, 0x52, 0x75, 0x53, 0x0a, 0x5e,
+            0x62, 0xce, 0x21, 0x7c,
+        ],
+        [
+            0xf1, 0x06, 0x4b, 0x13, 0x33, 0x00, 0xf3, 0x86, 0x53, 0x23, 0x3e, 0x15, 0x04, 0x99,
+            0x74, 0x81, 0xa0, 0x0b, 0xa8, 0xa1, 0x17, 0xd2, 0x0e, 0xd6, 0xae, 0x58, 0xc6, 0x75,
+            0x8e, 0x69, 0x39, 0xcc,
+        ],
+        [
+            0xda, 0x97, 0xb2, 0x05, 0xf9, 0xe7, 0xa3, 0xad, 0x12, 0x0d, 0xf3, 0xb2, 0x03, 0x14,
+            0xe2, 0x07, 0x1b, 0xb0, 0xfb, 0x0f, 0x87, 0x0f, 0x95, 0x21, 0xe0, 0xb2, 0xf9, 0x89,
+            0x1e, 0xe6, 0x9b, 0xe8,
+        ],
+        [
+            0xa7, 0xd9, 0xa0, 0xf7, 0xbf, 0xe5, 0xfa, 0x24, 0x7c, 0x32, 0x31, 0x87, 0x01, 0x9d,
+            0x01, 0x25, 0xf6, 0x93, 0xf0, 0xcd, 0xf4, 0x70, 0x93, 0xa2, 0xf1, 0x39, 0x2b, 0x3f,
+            0x57, 0xb9, 0xfb, 0x0b,
+        ],
+    ];
+    const UPPER_HASHES: [[u8; 32]; 2] = [
+        [
+            0x73, 0x55, 0xdf, 0xc2, 0xeb, 0x76, 0xd2, 0xb4, 0x0d, 0x27, 0xe3, 0x8c, 0x41, 0x40,
+            0x35, 0xa2, 0x7c, 0x5a, 0x8c, 0x95, 0x90, 0x2d, 0xdf, 0x77, 0xbb, 0x87, 0x69, 0x46,
+            0x96, 0xd6, 0x1b, 0x91,
+        ],
+        [
+            0xfe, 0xb1, 0x40, 0xb5, 0x15, 0x40, 0xbf, 0x36, 0x30, 0x8d, 0xce, 0x5c, 0x31, 0x08,
+            0x45, 0xe4, 0x12, 0x51, 0x2e, 0xc6, 0x53, 0xf9, 0x2b, 0x4e, 0x31, 0x09, 0x30, 0x7f,
+            0xab, 0x5e, 0x16, 0xe1,
+        ],
+    ];
+
+    let temporary = TempDir::new().unwrap();
+    let output_dir = temporary.path().join("output");
+    let block_size = 128usize;
+    let mut data = Vec::with_capacity(5 * block_size);
+    for byte in [0x11, 0x22, 0x33, 0x44, 0x55] {
+        data.extend(std::iter::repeat_n(byte, block_size));
+    }
+    let mut expected_tree = Vec::with_capacity(3 * block_size);
+    expected_tree.extend(UPPER_HASHES.into_iter().flatten());
+    expected_tree.resize(block_size, 0);
+    expected_tree.extend(LEAF_HASHES[..4].iter().flatten());
+    expected_tree.extend(LEAF_HASHES[4]);
+    expected_tree.resize(3 * block_size, 0);
+    let mut expected = data.clone();
+    expected.extend_from_slice(&expected_tree);
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(block_size as u32),
+        minor_version: Some(6),
+        partitions: vec![PartitionUpdate {
+            partition_name: "vendor".into(),
+            old_partition_info: None,
+            new_partition_info: Some(partition_info(&expected)),
+            operations: vec![InstallOperation {
+                operation_type: 0,
+                data_offset: Some(0),
+                data_length: Some(data.len() as u64),
+                dst_extents: vec![extent(0, 5)],
+                dst_length: Some(data.len() as u64),
+                data_sha256_hash: Some(sha256(&data)),
+                ..Default::default()
+            }],
+            hash_tree_data_extent: Some(extent(0, 5)),
+            hash_tree_extent: Some(extent(5, 3)),
+            hash_tree_algorithm: Some("sha256".into()),
+            hash_tree_salt: Some(b"verity-test-salt".to_vec()),
+            ..Default::default()
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &data);
+
+    ExtractOptions::new().num_threads(4).extract(&payload, &output_dir).unwrap();
+
+    let actual = fs::read(output_dir.join("vendor.img")).unwrap();
+    assert_eq!(&actual[5 * block_size..], expected_tree);
+    assert_eq!(actual, expected);
+}
+
+#[test]
+fn malformed_verity_layouts_fail_without_leaving_staging_files() {
+    for (tree_extent, operations, expected_error) in [
+        (
+            extent(5, 2),
+            vec![InstallOperation {
+                operation_type: 0,
+                data_offset: Some(0),
+                data_length: Some(5 * 128),
+                dst_extents: vec![extent(0, 5)],
+                ..Default::default()
+            }],
+            "Hash tree size mismatch",
+        ),
+        (
+            extent(5, 3),
+            vec![
+                InstallOperation {
+                    operation_type: 0,
+                    data_offset: Some(0),
+                    data_length: Some(5 * 128),
+                    dst_extents: vec![extent(0, 5)],
+                    ..Default::default()
+                },
+                InstallOperation {
+                    operation_type: 6,
+                    dst_extents: vec![extent(5, 1)],
+                    ..Default::default()
+                },
+            ],
+            "Hash tree extent overlaps destination extents",
+        ),
+    ] {
+        let temporary = TempDir::new().unwrap();
+        let output_dir = temporary.path().join("output");
+        let data = vec![0x5a; 5 * 128];
+        let manifest = DeltaArchiveManifest {
+            block_size: Some(128),
+            minor_version: Some(6),
+            partitions: vec![PartitionUpdate {
+                partition_name: "vendor".into(),
+                new_partition_info: Some(partition_info(&vec![0; 8 * 128])),
+                operations,
+                hash_tree_data_extent: Some(extent(0, 5)),
+                hash_tree_extent: Some(tree_extent),
+                hash_tree_algorithm: Some("sha256".into()),
+                hash_tree_salt: Some(vec![0x23; 32]),
+                ..Default::default()
+            }],
+        };
+        let payload = temporary.path().join("payload.bin");
+        write_payload(&payload, manifest, &data);
+
+        let error = ExtractOptions::new().extract(&payload, &output_dir).unwrap_err().to_string();
+
+        assert!(error.contains(expected_error), "unexpected error: {error}");
+        assert!(!output_dir.join("vendor.img").exists());
+        assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
+    }
+}
+
+#[test]
+fn fec_metadata_fails_explicitly_without_publishing_an_image() {
+    let temporary = TempDir::new().unwrap();
+    let output_dir = temporary.path().join("output");
+    let data = vec![0x5a; 128];
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(128),
+        minor_version: Some(6),
+        partitions: vec![PartitionUpdate {
+            partition_name: "vendor".into(),
+            new_partition_info: Some(partition_info(&vec![0; 256])),
+            operations: vec![InstallOperation {
+                operation_type: 0,
+                data_offset: Some(0),
+                data_length: Some(128),
+                dst_extents: vec![extent(0, 1)],
+                ..Default::default()
+            }],
+            fec_data_extent: Some(extent(0, 1)),
+            fec_extent: Some(extent(1, 1)),
+            fec_roots: Some(2),
+            ..Default::default()
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &data);
+
+    let error = ExtractOptions::new().extract(&payload, &output_dir).unwrap_err().to_string();
+
+    assert!(error.contains("FEC generation is not supported"), "unexpected error: {error}");
+    assert!(!output_dir.join("vendor.img").exists());
+    assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
+}
+
 #[test]
 fn verified_partitions_are_promoted_after_all_succeed() {
     let temporary = TempDir::new().unwrap();
@@ -577,6 +787,7 @@ fn verified_partitions_are_promoted_after_all_succeed() {
                     dst_extents: vec![extent(0, 1)],
                     ..Default::default()
                 }],
+                ..Default::default()
             },
             PartitionUpdate {
                 partition_name: "vendor".into(),
@@ -589,6 +800,7 @@ fn verified_partitions_are_promoted_after_all_succeed() {
                     dst_extents: vec![extent(0, 1)],
                     ..Default::default()
                 }],
+                ..Default::default()
             },
         ],
     };
@@ -625,6 +837,7 @@ fn no_clobber_rejects_existing_destination_without_modifying_source() {
                 dst_extents: vec![extent(0, 1)],
                 ..Default::default()
             }],
+            ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
@@ -664,6 +877,7 @@ fn verification_failure_preserves_existing_destinations_with_overwrite() {
                     dst_extents: vec![extent(0, 1)],
                     ..Default::default()
                 }],
+                ..Default::default()
             },
             PartitionUpdate {
                 partition_name: "vendor".into(),
@@ -676,6 +890,7 @@ fn verification_failure_preserves_existing_destinations_with_overwrite() {
                     dst_extents: vec![extent(0, 1)],
                     ..Default::default()
                 }],
+                ..Default::default()
             },
         ],
     };
@@ -714,6 +929,7 @@ fn partition_selection_does_not_require_unselected_delta_sources() {
                     dst_extents: vec![extent(0, 1)],
                     ..Default::default()
                 }],
+                ..Default::default()
             },
             PartitionUpdate {
                 partition_name: "system".into(),
@@ -725,6 +941,7 @@ fn partition_selection_does_not_require_unselected_delta_sources() {
                     dst_extents: vec![extent(0, 1)],
                     ..Default::default()
                 }],
+                ..Default::default()
             },
         ],
     };
@@ -779,6 +996,7 @@ fn cancellation_cleans_staging_without_promoting_or_modifying_source() {
             old_partition_info: Some(partition_info(&source)),
             new_partition_info: Some(partition_info(&source)),
             operations,
+            ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
@@ -830,6 +1048,7 @@ fn cli_extraction_error_exits_nonzero_and_reports_diagnostic() {
                 dst_extents: vec![extent(0, 1)],
                 ..Default::default()
             }],
+            ..Default::default()
         }],
     };
     write_payload(&payload, manifest, &[]);
@@ -882,6 +1101,7 @@ fn cli_sigint_exits_130_after_cleaning_staging() {
             old_partition_info: Some(partition_info(&source)),
             new_partition_info: Some(partition_info(&source)),
             operations,
+            ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
@@ -966,6 +1186,7 @@ fn source_and_destination_aliases_are_rejected_without_modifying_the_source() {
                     dst_extents: vec![extent(0, 1)],
                     ..Default::default()
                 }],
+                ..Default::default()
             }],
         };
         let payload = temporary.path().join("payload.bin");

From 381000ab83e585d338f5107fbd639efee648ab1c Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Fri, 11 Sep 2026 18:32:10 +0530
Subject: [PATCH 07/42] zucchini: Vendor audited native boundary

Compile the pinned Android 17 Zucchini and libchrome source closure in process. Add a safe Rust buffer/status wrapper and licensed golden fixtures for every Android executable type.

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 .gitignore                                    |    2 +
 Cargo.lock                                    |    1 +
 Cargo.toml                                    |    1 +
 build.rs                                      |  122 ++
 native/zucchini/README.md                     |   89 +
 native/zucchini/SOURCE_INVENTORY.sha256       |  216 ++
 .../include/components/zucchini/buildflags.h  |   12 +
 native/zucchini/include/gtest/gtest_prod.h    |    5 +
 native/zucchini/src/zucchini_ffi.cc           |  353 +++
 native/zucchini/src/zucchini_ffi.h            |   39 +
 .../vendor/libchrome/MODULE_LICENSE_BSD       |    0
 native/zucchini/vendor/libchrome/NOTICE       |   27 +
 .../zucchini/vendor/libchrome/base/at_exit.cc |  109 +
 .../zucchini/vendor/libchrome/base/at_exit.h  |   80 +
 .../vendor/libchrome/base/atomic_ref_count.h  |   67 +
 .../libchrome/base/atomic_sequence_num.h      |   33 +
 .../vendor/libchrome/base/atomicops.h         |  161 ++
 .../base/atomicops_internals_portable.h       |  229 ++
 .../vendor/libchrome/base/base_export.h       |   29 +
 .../vendor/libchrome/base/base_switches.h     |   51 +
 native/zucchini/vendor/libchrome/base/bind.h  |  482 +++++
 .../vendor/libchrome/base/bind_internal.h     |  971 +++++++++
 .../zucchini/vendor/libchrome/base/callback.h |  146 ++
 .../vendor/libchrome/base/callback_forward.h  |   27 +
 .../vendor/libchrome/base/callback_helpers.h  |  104 +
 .../libchrome/base/callback_internal.cc       |   84 +
 .../vendor/libchrome/base/callback_internal.h |  165 ++
 .../vendor/libchrome/base/cfi_buildflags.h    |    7 +
 .../vendor/libchrome/base/command_line.h      |  247 +++
 .../vendor/libchrome/base/compiler_specific.h |  236 ++
 .../base/containers/circular_deque.h          | 1111 ++++++++++
 .../vendor/libchrome/base/containers/queue.h  |   23 +
 .../vendor/libchrome/base/containers/span.h   |  453 ++++
 .../vendor/libchrome/base/containers/stack.h  |   23 +
 .../libchrome/base/containers/vector_buffer.h |  163 ++
 .../libchrome/base/debug/activity_tracker.cc  | 1828 ++++++++++++++++
 .../libchrome/base/debug/activity_tracker.h   | 1367 ++++++++++++
 .../vendor/libchrome/base/debug/alias.cc      |   27 +
 .../vendor/libchrome/base/debug/alias.h       |   43 +
 .../vendor/libchrome/base/debug/debugger.h    |   44 +
 .../libchrome/base/debug/debugger_posix.cc    |  272 +++
 .../base/debug/debugging_buildflags.h         |   12 +
 .../libchrome/base/debug/leak_annotations.h   |   46 +
 .../libchrome/base/debug/proc_maps_linux.h    |   94 +
 .../libchrome/base/debug/stack_trace.cc       |  277 +++
 .../vendor/libchrome/base/debug/stack_trace.h |  197 ++
 .../libchrome/base/debug/stack_trace_posix.cc |  898 ++++++++
 .../vendor/libchrome/base/environment.h       |   90 +
 .../vendor/libchrome/base/feature_list.h      |  310 +++
 .../libchrome/base/file_descriptor_posix.h    |   59 +
 .../vendor/libchrome/base/files/file.h        |  381 ++++
 .../vendor/libchrome/base/files/file_path.h   |  481 +++++
 .../libchrome/base/files/file_tracing.h       |   95 +
 .../vendor/libchrome/base/files/file_util.h   |  498 +++++
 .../libchrome/base/files/memory_mapped_file.h |  136 ++
 .../libchrome/base/files/platform_file.h      |   43 +
 .../vendor/libchrome/base/files/scoped_file.h |   62 +
 .../vendor/libchrome/base/format_macros.h     |   97 +
 .../vendor/libchrome/base/gtest_prod_util.h   |   66 +
 native/zucchini/vendor/libchrome/base/hash.h  |   69 +
 .../vendor/libchrome/base/lazy_instance.h     |  210 ++
 .../libchrome/base/lazy_instance_helpers.cc   |   64 +
 .../libchrome/base/lazy_instance_helpers.h    |  101 +
 .../vendor/libchrome/base/location.cc         |   77 +
 .../zucchini/vendor/libchrome/base/location.h |  117 +
 .../zucchini/vendor/libchrome/base/logging.cc | 1065 ++++++++++
 .../zucchini/vendor/libchrome/base/logging.h  | 1179 ++++++++++
 .../zucchini/vendor/libchrome/base/macros.h   |  114 +
 .../libchrome/base/memory/free_deleter.h      |   25 +
 .../vendor/libchrome/base/memory/ptr_util.h   |   23 +
 .../raw_scoped_refptr_mismatch_checker.h      |   52 +
 .../libchrome/base/memory/ref_counted.h       |  425 ++++
 .../libchrome/base/memory/scoped_refptr.h     |  337 +++
 .../libchrome/base/memory/shared_memory.h     |  254 +++
 .../base/memory/shared_memory_handle.h        |  238 +++
 .../vendor/libchrome/base/memory/singleton.h  |  262 +++
 .../vendor/libchrome/base/memory/weak_ptr.h   |  377 ++++
 .../libchrome/base/metrics/bucket_ranges.h    |  105 +
 .../libchrome/base/metrics/field_trial.h      |  802 +++++++
 .../vendor/libchrome/base/metrics/histogram.h |  610 ++++++
 .../libchrome/base/metrics/histogram_base.h   |  307 +++
 .../base/metrics/histogram_functions.h        |  158 ++
 .../libchrome/base/metrics/histogram_macros.h |  382 ++++
 .../base/metrics/histogram_macros_internal.h  |  268 +++
 .../base/metrics/histogram_macros_local.h     |   90 +
 .../base/metrics/histogram_samples.h          |  267 +++
 .../metrics/persistent_memory_allocator.cc    | 1204 +++++++++++
 .../metrics/persistent_memory_allocator.h     |  872 ++++++++
 .../libchrome/base/metrics/sparse_histogram.h |  108 +
 .../vendor/libchrome/base/no_destructor.h     |   99 +
 .../libchrome/base/numerics/checked_math.h    |  393 ++++
 .../base/numerics/checked_math_impl.h         |  567 +++++
 .../libchrome/base/numerics/clamped_math.h    |  262 +++
 .../base/numerics/clamped_math_impl.h         |  341 +++
 .../base/numerics/safe_conversions.h          |  344 +++
 .../base/numerics/safe_conversions_impl.h     |  850 ++++++++
 .../libchrome/base/numerics/safe_math.h       |   12 +
 .../base/numerics/safe_math_clang_gcc_impl.h  |  157 ++
 .../base/numerics/safe_math_shared_impl.h     |  237 +++
 .../vendor/libchrome/base/observer_list.h     |  307 +++
 .../libchrome/base/observer_list_threadsafe.h |  237 +++
 .../zucchini/vendor/libchrome/base/optional.h |  922 ++++++++
 .../vendor/libchrome/base/pending_task.h      |   68 +
 .../zucchini/vendor/libchrome/base/pickle.h   |  345 +++
 .../libchrome/base/posix/eintr_wrapper.h      |   68 +
 .../base/posix/file_descriptor_shuffle.h      |   87 +
 .../libchrome/base/posix/safe_strerror.h      |   44 +
 .../vendor/libchrome/base/process/launch.h    |  396 ++++
 .../vendor/libchrome/base/process/process.h   |  213 ++
 .../libchrome/base/process/process_handle.h   |  103 +
 .../libchrome/base/scoped_clear_errno.h       |   34 +
 .../vendor/libchrome/base/scoped_generic.h    |  189 ++
 .../vendor/libchrome/base/sequence_checker.h  |   88 +
 .../libchrome/base/sequence_checker_impl.h    |   48 +
 .../libchrome/base/sequenced_task_runner.h    |  176 ++
 .../base/sequenced_task_runner_helpers.h      |   42 +
 .../base/single_thread_task_runner.h          |   36 +
 .../zucchini/vendor/libchrome/base/stl_util.h |  410 ++++
 .../libchrome/base/strings/char_traits.h      |   92 +
 .../vendor/libchrome/base/strings/string16.h  |  219 ++
 .../base/strings/string_number_conversions.h  |  166 ++
 .../libchrome/base/strings/string_piece.cc    |  453 ++++
 .../libchrome/base/strings/string_piece.h     |  483 +++++
 .../base/strings/string_piece_forward.h       |   24 +
 .../libchrome/base/strings/string_util.cc     | 1124 ++++++++++
 .../libchrome/base/strings/string_util.h      |  485 +++++
 .../base/strings/string_util_posix.h          |   37 +
 .../libchrome/base/strings/stringprintf.cc    |  189 ++
 .../libchrome/base/strings/stringprintf.h     |   66 +
 .../base/strings/sys_string_conversions.h     |   84 +
 .../strings/utf_string_conversion_utils.h     |  100 +
 .../base/strings/utf_string_conversions.h     |   54 +
 .../libchrome/base/synchronization/lock.h     |  151 ++
 .../base/synchronization/lock_impl.h          |   78 +
 .../base/synchronization/lock_impl_posix.cc   |  133 ++
 .../synchronization_buildflags.h              |    4 +
 .../zucchini/vendor/libchrome/base/sys_info.h |  179 ++
 .../vendor/libchrome/base/task_runner.h       |  154 ++
 .../vendor/libchrome/base/template_util.h     |  154 ++
 .../libchrome/base/third_party/icu/LICENSE    |   76 +
 .../libchrome/base/third_party/icu/icu_utf.h  |  442 ++++
 .../libchrome/base/third_party/nspr/LICENSE   |   35 +
 .../base/third_party/nspr/MPL-1.1.txt         |  469 ++++
 .../libchrome/base/third_party/nspr/prtime.h  |  263 +++
 .../base/threading/platform_thread.h          |  240 +++
 .../platform_thread_internal_posix.h          |   48 +
 .../base/threading/platform_thread_posix.cc   |  305 +++
 .../threading/sequenced_task_runner_handle.h  |   43 +
 .../base/threading/thread_collision_warner.h  |  245 +++
 .../base/threading/thread_id_name_manager.h   |   80 +
 .../libchrome/base/threading/thread_local.h   |   99 +
 .../base/threading/thread_local_storage.cc    |  408 ++++
 .../base/threading/thread_local_storage.h     |  184 ++
 .../base/threading/thread_restrictions.h      |  536 +++++
 .../threading/thread_task_runner_handle.h     |   57 +
 .../vendor/libchrome/base/time/time.cc        |  420 ++++
 .../vendor/libchrome/base/time/time.h         |  993 +++++++++
 .../libchrome/base/time/time_now_posix.cc     |  123 ++
 .../libchrome/base/time/time_override.h       |   74 +
 native/zucchini/vendor/libchrome/base/token.h |   72 +
 .../vendor/libchrome/base/unguessable_token.h |  116 +
 native/zucchini/vendor/libchrome/base/vlog.h  |   77 +
 .../vendor/libchrome/build/build_config.h     |  263 +++
 .../testing/gtest/include/gtest/gtest_prod.h  |    1 +
 native/zucchini/vendor/zucchini/LICENSE       |   27 +
 .../vendor/zucchini/MODULE_LICENSE_CHROME     |    0
 .../zucchini/vendor/zucchini/abs32_utils.cc   |  211 ++
 .../vendor/zucchini/address_translator.cc     |  258 +++
 .../vendor/zucchini/aosp/include/base/check.h |   22 +
 .../zucchini/aosp/include/base/check_op.h     |   24 +
 .../include/base/containers/cxx20_erase.h     |   22 +
 .../zucchini/aosp/include/build/buildflag.h   |   47 +
 .../include/components/zucchini/abs32_utils.h |  142 ++
 .../components/zucchini/address_translator.h  |  199 ++
 .../include/components/zucchini/algorithm.h   |  147 ++
 .../include/components/zucchini/arm_utils.h   |  423 ++++
 .../include/components/zucchini/buffer_sink.h |   68 +
 .../components/zucchini/buffer_source.h       |  141 ++
 .../include/components/zucchini/buffer_view.h |  217 ++
 .../aosp/include/components/zucchini/crc32.h  |   17 +
 .../components/zucchini/disassembler.h        |  155 ++
 .../components/zucchini/disassembler_dex.h    |  295 +++
 .../components/zucchini/disassembler_elf.h    |  356 ++++
 .../components/zucchini/disassembler_no_op.h  |   41 +
 .../components/zucchini/element_detection.h   |   62 +
 .../components/zucchini/encoded_view.h        |  185 ++
 .../components/zucchini/equivalence_map.h     |  208 ++
 .../include/components/zucchini/image_index.h |  116 +
 .../include/components/zucchini/image_utils.h |  225 ++
 .../include/components/zucchini/io_utils.h    |  144 ++
 .../components/zucchini/patch_reader.h        |  285 +++
 .../include/components/zucchini/patch_utils.h |  139 ++
 .../components/zucchini/patch_writer.h        |  272 +++
 .../components/zucchini/reference_set.h       |   64 +
 .../components/zucchini/rel32_finder.h        |  284 +++
 .../include/components/zucchini/rel32_utils.h |  184 ++
 .../include/components/zucchini/reloc_elf.h   |  102 +
 .../components/zucchini/suffix_array.h        |  475 +++++
 .../include/components/zucchini/target_pool.h |   81 +
 .../components/zucchini/targets_affinity.h    |   74 +
 .../include/components/zucchini/type_dex.h    |  332 +++
 .../include/components/zucchini/type_elf.h    |  283 +++
 .../include/components/zucchini/typed_value.h |   57 +
 .../components/zucchini/version_info.h        |   30 +
 .../include/components/zucchini/zucchini.h    |   72 +
 .../components/zucchini/zucchini_apply.h      |   41 +
 native/zucchini/vendor/zucchini/arm_utils.cc  |  597 ++++++
 .../zucchini/vendor/zucchini/buffer_source.cc |  105 +
 native/zucchini/vendor/zucchini/crc32.cc      |   43 +
 .../zucchini/vendor/zucchini/disassembler.cc  |   52 +
 .../vendor/zucchini/disassembler_dex.cc       | 1890 +++++++++++++++++
 .../vendor/zucchini/disassembler_elf.cc       |  758 +++++++
 .../vendor/zucchini/disassembler_no_op.cc     |   31 +
 .../vendor/zucchini/element_detection.cc      |  200 ++
 .../vendor/zucchini/equivalence_map.cc        |  549 +++++
 .../zucchini/vendor/zucchini/patch_reader.cc  |  401 ++++
 .../zucchini/vendor/zucchini/rel32_finder.cc  |  294 +++
 .../zucchini/vendor/zucchini/rel32_utils.cc   |   67 +
 native/zucchini/vendor/zucchini/reloc_elf.cc  |  163 ++
 .../zucchini/vendor/zucchini/target_pool.cc   |   84 +
 .../vendor/zucchini/zucchini_apply.cc         |  217 ++
 src/lib.rs                                    |    1 +
 src/zucchini.rs                               |  135 ++
 tests/delta_extraction.rs                     |   50 +
 tests/fixtures/zucchini/LICENSE               |   29 +
 tests/fixtures/zucchini/README.md             |   22 +
 tests/fixtures/zucchini/SHA256SUMS            |   22 +
 tests/fixtures/zucchini/dex-large-new.dex     |  Bin 0 -> 786788 bytes
 tests/fixtures/zucchini/dex-large-old.dex     |  Bin 0 -> 786788 bytes
 .../fixtures/zucchini/dex-large-unsafe16.zuc  |  Bin 0 -> 65758 bytes
 tests/fixtures/zucchini/dex-large.zuc         |  Bin 0 -> 65758 bytes
 tests/fixtures/zucchini/dex-new.dex           |  Bin 0 -> 400 bytes
 tests/fixtures/zucchini/dex-old.dex           |  Bin 0 -> 400 bytes
 tests/fixtures/zucchini/dex.zuc               |  Bin 0 -> 223 bytes
 tests/fixtures/zucchini/elf-arm32-new         |  Bin 0 -> 280 bytes
 tests/fixtures/zucchini/elf-arm32-old         |  Bin 0 -> 280 bytes
 tests/fixtures/zucchini/elf-arm32.zuc         |  Bin 0 -> 103 bytes
 tests/fixtures/zucchini/elf-arm64-new         |  Bin 0 -> 384 bytes
 tests/fixtures/zucchini/elf-arm64-old         |  Bin 0 -> 384 bytes
 tests/fixtures/zucchini/elf-arm64.zuc         |  Bin 0 -> 104 bytes
 tests/fixtures/zucchini/elf-new               |  Bin 0 -> 4680 bytes
 tests/fixtures/zucchini/elf-old               |  Bin 0 -> 4680 bytes
 tests/fixtures/zucchini/elf-x86-new           |  Bin 0 -> 280 bytes
 tests/fixtures/zucchini/elf-x86-old           |  Bin 0 -> 280 bytes
 tests/fixtures/zucchini/elf-x86.zuc           |  Bin 0 -> 103 bytes
 tests/fixtures/zucchini/elf.zuc               |  Bin 0 -> 112 bytes
 tests/fixtures/zucchini/noop-new.bin          |    1 +
 tests/fixtures/zucchini/noop-old.bin          |    1 +
 tests/fixtures/zucchini/noop.zuc              |  Bin 0 -> 88 bytes
 249 files changed, 52865 insertions(+)
 create mode 100644 native/zucchini/README.md
 create mode 100644 native/zucchini/SOURCE_INVENTORY.sha256
 create mode 100644 native/zucchini/include/components/zucchini/buildflags.h
 create mode 100644 native/zucchini/include/gtest/gtest_prod.h
 create mode 100644 native/zucchini/src/zucchini_ffi.cc
 create mode 100644 native/zucchini/src/zucchini_ffi.h
 create mode 100644 native/zucchini/vendor/libchrome/MODULE_LICENSE_BSD
 create mode 100644 native/zucchini/vendor/libchrome/NOTICE
 create mode 100644 native/zucchini/vendor/libchrome/base/at_exit.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/at_exit.h
 create mode 100644 native/zucchini/vendor/libchrome/base/atomic_ref_count.h
 create mode 100644 native/zucchini/vendor/libchrome/base/atomic_sequence_num.h
 create mode 100644 native/zucchini/vendor/libchrome/base/atomicops.h
 create mode 100644 native/zucchini/vendor/libchrome/base/atomicops_internals_portable.h
 create mode 100644 native/zucchini/vendor/libchrome/base/base_export.h
 create mode 100644 native/zucchini/vendor/libchrome/base/base_switches.h
 create mode 100644 native/zucchini/vendor/libchrome/base/bind.h
 create mode 100644 native/zucchini/vendor/libchrome/base/bind_internal.h
 create mode 100644 native/zucchini/vendor/libchrome/base/callback.h
 create mode 100644 native/zucchini/vendor/libchrome/base/callback_forward.h
 create mode 100644 native/zucchini/vendor/libchrome/base/callback_helpers.h
 create mode 100644 native/zucchini/vendor/libchrome/base/callback_internal.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/callback_internal.h
 create mode 100644 native/zucchini/vendor/libchrome/base/cfi_buildflags.h
 create mode 100644 native/zucchini/vendor/libchrome/base/command_line.h
 create mode 100644 native/zucchini/vendor/libchrome/base/compiler_specific.h
 create mode 100644 native/zucchini/vendor/libchrome/base/containers/circular_deque.h
 create mode 100644 native/zucchini/vendor/libchrome/base/containers/queue.h
 create mode 100644 native/zucchini/vendor/libchrome/base/containers/span.h
 create mode 100644 native/zucchini/vendor/libchrome/base/containers/stack.h
 create mode 100644 native/zucchini/vendor/libchrome/base/containers/vector_buffer.h
 create mode 100644 native/zucchini/vendor/libchrome/base/debug/activity_tracker.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/debug/activity_tracker.h
 create mode 100644 native/zucchini/vendor/libchrome/base/debug/alias.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/debug/alias.h
 create mode 100644 native/zucchini/vendor/libchrome/base/debug/debugger.h
 create mode 100644 native/zucchini/vendor/libchrome/base/debug/debugger_posix.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/debug/debugging_buildflags.h
 create mode 100644 native/zucchini/vendor/libchrome/base/debug/leak_annotations.h
 create mode 100644 native/zucchini/vendor/libchrome/base/debug/proc_maps_linux.h
 create mode 100644 native/zucchini/vendor/libchrome/base/debug/stack_trace.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/debug/stack_trace.h
 create mode 100644 native/zucchini/vendor/libchrome/base/debug/stack_trace_posix.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/environment.h
 create mode 100644 native/zucchini/vendor/libchrome/base/feature_list.h
 create mode 100644 native/zucchini/vendor/libchrome/base/file_descriptor_posix.h
 create mode 100644 native/zucchini/vendor/libchrome/base/files/file.h
 create mode 100644 native/zucchini/vendor/libchrome/base/files/file_path.h
 create mode 100644 native/zucchini/vendor/libchrome/base/files/file_tracing.h
 create mode 100644 native/zucchini/vendor/libchrome/base/files/file_util.h
 create mode 100644 native/zucchini/vendor/libchrome/base/files/memory_mapped_file.h
 create mode 100644 native/zucchini/vendor/libchrome/base/files/platform_file.h
 create mode 100644 native/zucchini/vendor/libchrome/base/files/scoped_file.h
 create mode 100644 native/zucchini/vendor/libchrome/base/format_macros.h
 create mode 100644 native/zucchini/vendor/libchrome/base/gtest_prod_util.h
 create mode 100644 native/zucchini/vendor/libchrome/base/hash.h
 create mode 100644 native/zucchini/vendor/libchrome/base/lazy_instance.h
 create mode 100644 native/zucchini/vendor/libchrome/base/lazy_instance_helpers.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/lazy_instance_helpers.h
 create mode 100644 native/zucchini/vendor/libchrome/base/location.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/location.h
 create mode 100644 native/zucchini/vendor/libchrome/base/logging.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/logging.h
 create mode 100644 native/zucchini/vendor/libchrome/base/macros.h
 create mode 100644 native/zucchini/vendor/libchrome/base/memory/free_deleter.h
 create mode 100644 native/zucchini/vendor/libchrome/base/memory/ptr_util.h
 create mode 100644 native/zucchini/vendor/libchrome/base/memory/raw_scoped_refptr_mismatch_checker.h
 create mode 100644 native/zucchini/vendor/libchrome/base/memory/ref_counted.h
 create mode 100644 native/zucchini/vendor/libchrome/base/memory/scoped_refptr.h
 create mode 100644 native/zucchini/vendor/libchrome/base/memory/shared_memory.h
 create mode 100644 native/zucchini/vendor/libchrome/base/memory/shared_memory_handle.h
 create mode 100644 native/zucchini/vendor/libchrome/base/memory/singleton.h
 create mode 100644 native/zucchini/vendor/libchrome/base/memory/weak_ptr.h
 create mode 100644 native/zucchini/vendor/libchrome/base/metrics/bucket_ranges.h
 create mode 100644 native/zucchini/vendor/libchrome/base/metrics/field_trial.h
 create mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram.h
 create mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram_base.h
 create mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram_functions.h
 create mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram_macros.h
 create mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram_macros_internal.h
 create mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram_macros_local.h
 create mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram_samples.h
 create mode 100644 native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.h
 create mode 100644 native/zucchini/vendor/libchrome/base/metrics/sparse_histogram.h
 create mode 100644 native/zucchini/vendor/libchrome/base/no_destructor.h
 create mode 100644 native/zucchini/vendor/libchrome/base/numerics/checked_math.h
 create mode 100644 native/zucchini/vendor/libchrome/base/numerics/checked_math_impl.h
 create mode 100644 native/zucchini/vendor/libchrome/base/numerics/clamped_math.h
 create mode 100644 native/zucchini/vendor/libchrome/base/numerics/clamped_math_impl.h
 create mode 100644 native/zucchini/vendor/libchrome/base/numerics/safe_conversions.h
 create mode 100644 native/zucchini/vendor/libchrome/base/numerics/safe_conversions_impl.h
 create mode 100644 native/zucchini/vendor/libchrome/base/numerics/safe_math.h
 create mode 100644 native/zucchini/vendor/libchrome/base/numerics/safe_math_clang_gcc_impl.h
 create mode 100644 native/zucchini/vendor/libchrome/base/numerics/safe_math_shared_impl.h
 create mode 100644 native/zucchini/vendor/libchrome/base/observer_list.h
 create mode 100644 native/zucchini/vendor/libchrome/base/observer_list_threadsafe.h
 create mode 100644 native/zucchini/vendor/libchrome/base/optional.h
 create mode 100644 native/zucchini/vendor/libchrome/base/pending_task.h
 create mode 100644 native/zucchini/vendor/libchrome/base/pickle.h
 create mode 100644 native/zucchini/vendor/libchrome/base/posix/eintr_wrapper.h
 create mode 100644 native/zucchini/vendor/libchrome/base/posix/file_descriptor_shuffle.h
 create mode 100644 native/zucchini/vendor/libchrome/base/posix/safe_strerror.h
 create mode 100644 native/zucchini/vendor/libchrome/base/process/launch.h
 create mode 100644 native/zucchini/vendor/libchrome/base/process/process.h
 create mode 100644 native/zucchini/vendor/libchrome/base/process/process_handle.h
 create mode 100644 native/zucchini/vendor/libchrome/base/scoped_clear_errno.h
 create mode 100644 native/zucchini/vendor/libchrome/base/scoped_generic.h
 create mode 100644 native/zucchini/vendor/libchrome/base/sequence_checker.h
 create mode 100644 native/zucchini/vendor/libchrome/base/sequence_checker_impl.h
 create mode 100644 native/zucchini/vendor/libchrome/base/sequenced_task_runner.h
 create mode 100644 native/zucchini/vendor/libchrome/base/sequenced_task_runner_helpers.h
 create mode 100644 native/zucchini/vendor/libchrome/base/single_thread_task_runner.h
 create mode 100644 native/zucchini/vendor/libchrome/base/stl_util.h
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/char_traits.h
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/string16.h
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/string_number_conversions.h
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/string_piece.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/string_piece.h
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/string_piece_forward.h
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/string_util.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/string_util.h
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/string_util_posix.h
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/stringprintf.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/stringprintf.h
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/sys_string_conversions.h
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/utf_string_conversion_utils.h
 create mode 100644 native/zucchini/vendor/libchrome/base/strings/utf_string_conversions.h
 create mode 100644 native/zucchini/vendor/libchrome/base/synchronization/lock.h
 create mode 100644 native/zucchini/vendor/libchrome/base/synchronization/lock_impl.h
 create mode 100644 native/zucchini/vendor/libchrome/base/synchronization/lock_impl_posix.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/synchronization/synchronization_buildflags.h
 create mode 100644 native/zucchini/vendor/libchrome/base/sys_info.h
 create mode 100644 native/zucchini/vendor/libchrome/base/task_runner.h
 create mode 100644 native/zucchini/vendor/libchrome/base/template_util.h
 create mode 100644 native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE
 create mode 100644 native/zucchini/vendor/libchrome/base/third_party/icu/icu_utf.h
 create mode 100644 native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE
 create mode 100644 native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
 create mode 100644 native/zucchini/vendor/libchrome/base/third_party/nspr/prtime.h
 create mode 100644 native/zucchini/vendor/libchrome/base/threading/platform_thread.h
 create mode 100644 native/zucchini/vendor/libchrome/base/threading/platform_thread_internal_posix.h
 create mode 100644 native/zucchini/vendor/libchrome/base/threading/platform_thread_posix.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/threading/sequenced_task_runner_handle.h
 create mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_collision_warner.h
 create mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_id_name_manager.h
 create mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_local.h
 create mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_local_storage.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_local_storage.h
 create mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_restrictions.h
 create mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_task_runner_handle.h
 create mode 100644 native/zucchini/vendor/libchrome/base/time/time.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/time/time.h
 create mode 100644 native/zucchini/vendor/libchrome/base/time/time_now_posix.cc
 create mode 100644 native/zucchini/vendor/libchrome/base/time/time_override.h
 create mode 100644 native/zucchini/vendor/libchrome/base/token.h
 create mode 100644 native/zucchini/vendor/libchrome/base/unguessable_token.h
 create mode 100644 native/zucchini/vendor/libchrome/base/vlog.h
 create mode 100644 native/zucchini/vendor/libchrome/build/build_config.h
 create mode 100644 native/zucchini/vendor/libchrome/testing/gtest/include/gtest/gtest_prod.h
 create mode 100644 native/zucchini/vendor/zucchini/LICENSE
 create mode 100644 native/zucchini/vendor/zucchini/MODULE_LICENSE_CHROME
 create mode 100644 native/zucchini/vendor/zucchini/abs32_utils.cc
 create mode 100644 native/zucchini/vendor/zucchini/address_translator.cc
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/base/check.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/base/check_op.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/base/containers/cxx20_erase.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/build/buildflag.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/abs32_utils.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/address_translator.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/algorithm.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/arm_utils.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_sink.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_source.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_view.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/crc32.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_dex.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_elf.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_no_op.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/element_detection.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/encoded_view.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/equivalence_map.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_index.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_utils.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/io_utils.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_reader.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_utils.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_writer.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reference_set.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_finder.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_utils.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reloc_elf.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/suffix_array.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/target_pool.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/targets_affinity.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_dex.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_elf.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/typed_value.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/version_info.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini.h
 create mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini_apply.h
 create mode 100644 native/zucchini/vendor/zucchini/arm_utils.cc
 create mode 100644 native/zucchini/vendor/zucchini/buffer_source.cc
 create mode 100644 native/zucchini/vendor/zucchini/crc32.cc
 create mode 100644 native/zucchini/vendor/zucchini/disassembler.cc
 create mode 100644 native/zucchini/vendor/zucchini/disassembler_dex.cc
 create mode 100644 native/zucchini/vendor/zucchini/disassembler_elf.cc
 create mode 100644 native/zucchini/vendor/zucchini/disassembler_no_op.cc
 create mode 100644 native/zucchini/vendor/zucchini/element_detection.cc
 create mode 100644 native/zucchini/vendor/zucchini/equivalence_map.cc
 create mode 100644 native/zucchini/vendor/zucchini/patch_reader.cc
 create mode 100644 native/zucchini/vendor/zucchini/rel32_finder.cc
 create mode 100644 native/zucchini/vendor/zucchini/rel32_utils.cc
 create mode 100644 native/zucchini/vendor/zucchini/reloc_elf.cc
 create mode 100644 native/zucchini/vendor/zucchini/target_pool.cc
 create mode 100644 native/zucchini/vendor/zucchini/zucchini_apply.cc
 create mode 100644 src/zucchini.rs
 create mode 100644 tests/fixtures/zucchini/LICENSE
 create mode 100644 tests/fixtures/zucchini/README.md
 create mode 100644 tests/fixtures/zucchini/SHA256SUMS
 create mode 100644 tests/fixtures/zucchini/dex-large-new.dex
 create mode 100644 tests/fixtures/zucchini/dex-large-old.dex
 create mode 100644 tests/fixtures/zucchini/dex-large-unsafe16.zuc
 create mode 100644 tests/fixtures/zucchini/dex-large.zuc
 create mode 100644 tests/fixtures/zucchini/dex-new.dex
 create mode 100644 tests/fixtures/zucchini/dex-old.dex
 create mode 100644 tests/fixtures/zucchini/dex.zuc
 create mode 100644 tests/fixtures/zucchini/elf-arm32-new
 create mode 100644 tests/fixtures/zucchini/elf-arm32-old
 create mode 100644 tests/fixtures/zucchini/elf-arm32.zuc
 create mode 100644 tests/fixtures/zucchini/elf-arm64-new
 create mode 100644 tests/fixtures/zucchini/elf-arm64-old
 create mode 100644 tests/fixtures/zucchini/elf-arm64.zuc
 create mode 100755 tests/fixtures/zucchini/elf-new
 create mode 100755 tests/fixtures/zucchini/elf-old
 create mode 100644 tests/fixtures/zucchini/elf-x86-new
 create mode 100644 tests/fixtures/zucchini/elf-x86-old
 create mode 100644 tests/fixtures/zucchini/elf-x86.zuc
 create mode 100644 tests/fixtures/zucchini/elf.zuc
 create mode 100644 tests/fixtures/zucchini/noop-new.bin
 create mode 100644 tests/fixtures/zucchini/noop-old.bin
 create mode 100644 tests/fixtures/zucchini/noop.zuc

diff --git a/.gitignore b/.gitignore
index 43d1f25..1e54029 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,8 @@
 # Generated by Cargo
 # will have compiled files and executables
 debug/
+!native/zucchini/vendor/libchrome/base/debug/
+!native/zucchini/vendor/libchrome/base/debug/**
 dist/
 target/
 
diff --git a/Cargo.lock b/Cargo.lock
index a550f90..75f87b4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -635,6 +635,7 @@ dependencies = [
  "brotli",
  "bsdiff-android",
  "bzip2",
+ "cc",
  "clap",
  "color-print",
  "ctrlc",
diff --git a/Cargo.toml b/Cargo.toml
index 1920a7b..06fb104 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,6 +21,7 @@ crate-type = ["cdylib", "rlib"]
 python = ["dep:pyo3"]
 
 [build-dependencies]
+cc = "=1.2.27"
 prost-build = "0.14.1"
 protoc-bin-vendored = "3.2.0"
 
diff --git a/build.rs b/build.rs
index 38cec17..9060e65 100644
--- a/build.rs
+++ b/build.rs
@@ -1,4 +1,57 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+const ZUCCHINI_SOURCES: &[&str] = &[
+    "native/zucchini/src/zucchini_ffi.cc",
+    "native/zucchini/vendor/zucchini/abs32_utils.cc",
+    "native/zucchini/vendor/zucchini/address_translator.cc",
+    "native/zucchini/vendor/zucchini/arm_utils.cc",
+    "native/zucchini/vendor/zucchini/buffer_source.cc",
+    "native/zucchini/vendor/zucchini/crc32.cc",
+    "native/zucchini/vendor/zucchini/disassembler.cc",
+    "native/zucchini/vendor/zucchini/disassembler_dex.cc",
+    "native/zucchini/vendor/zucchini/disassembler_elf.cc",
+    "native/zucchini/vendor/zucchini/disassembler_no_op.cc",
+    "native/zucchini/vendor/zucchini/element_detection.cc",
+    "native/zucchini/vendor/zucchini/equivalence_map.cc",
+    "native/zucchini/vendor/zucchini/patch_reader.cc",
+    "native/zucchini/vendor/zucchini/rel32_finder.cc",
+    "native/zucchini/vendor/zucchini/rel32_utils.cc",
+    "native/zucchini/vendor/zucchini/reloc_elf.cc",
+    "native/zucchini/vendor/zucchini/target_pool.cc",
+    "native/zucchini/vendor/zucchini/zucchini_apply.cc",
+    "native/zucchini/vendor/libchrome/base/at_exit.cc",
+    "native/zucchini/vendor/libchrome/base/callback_internal.cc",
+    "native/zucchini/vendor/libchrome/base/debug/activity_tracker.cc",
+    "native/zucchini/vendor/libchrome/base/debug/alias.cc",
+    "native/zucchini/vendor/libchrome/base/debug/debugger_posix.cc",
+    "native/zucchini/vendor/libchrome/base/debug/stack_trace.cc",
+    "native/zucchini/vendor/libchrome/base/debug/stack_trace_posix.cc",
+    "native/zucchini/vendor/libchrome/base/lazy_instance_helpers.cc",
+    "native/zucchini/vendor/libchrome/base/location.cc",
+    "native/zucchini/vendor/libchrome/base/logging.cc",
+    "native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.cc",
+    "native/zucchini/vendor/libchrome/base/strings/string_piece.cc",
+    "native/zucchini/vendor/libchrome/base/strings/stringprintf.cc",
+    "native/zucchini/vendor/libchrome/base/strings/string_util.cc",
+    "native/zucchini/vendor/libchrome/base/synchronization/lock_impl_posix.cc",
+    "native/zucchini/vendor/libchrome/base/threading/platform_thread_posix.cc",
+    "native/zucchini/vendor/libchrome/base/threading/thread_local_storage.cc",
+    "native/zucchini/vendor/libchrome/base/time/time.cc",
+    "native/zucchini/vendor/libchrome/base/time/time_now_posix.cc",
+];
+
 fn main() {
+    println!("cargo:rustc-check-cfg=cfg(otadump_zucchini)");
+    println!("cargo:rerun-if-changed=src/protos/chromeos_update_engine/update_metadata.proto");
+    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("linux")
+        && std::env::var("CARGO_CFG_TARGET_ARCH").as_deref() == Ok("x86_64")
+        && std::env::var("CARGO_CFG_TARGET_ENV").as_deref() == Ok("gnu")
+    {
+        build_zucchini();
+        println!("cargo:rustc-cfg=otadump_zucchini");
+    }
+
     let protoc = protoc_bin_vendored::protoc_bin_path().expect("unable to find vendored protoc");
     let mut config = prost_build::Config::new();
     config.protoc_executable(protoc);
@@ -9,3 +62,72 @@ fn main() {
         )
         .expect("error compiling protobuf files");
 }
+
+fn build_zucchini() {
+    let root = Path::new("native/zucchini");
+    let mut tracked = Vec::new();
+    collect_files(root, &mut tracked);
+    tracked.sort();
+    for path in tracked {
+        println!("cargo:rerun-if-changed={}", path.display());
+    }
+
+    let mut build = cc::Build::new();
+    build
+        .cpp(true)
+        .cpp_link_stdlib(None)
+        .std("c++17")
+        .opt_level(2)
+        .define("NDEBUG", None)
+        .define("OFFICIAL_BUILD", None)
+        .define("__ANDROID_HOST__", None)
+        .define("DONT_EMBED_BUILD_METADATA", None)
+        .flag("-ffunction-sections")
+        .flag("-fdata-sections")
+        .flag("-fno-exceptions")
+        .flag("-fno-rtti")
+        .flag("-Wno-deprecated-declarations")
+        .flag("-Wno-unused-parameter")
+        .include(root.join("include"))
+        .include(root.join("src"))
+        .include(root.join("vendor/zucchini/aosp/include"))
+        .include(root.join("vendor/zucchini/aosp/include/components"))
+        .include(root.join("vendor/libchrome"))
+        .files(ZUCCHINI_SOURCES);
+
+    let compiler = build.get_compiler();
+    build.compile("otadump_zucchini");
+    add_static_runtime(&compiler, "libstdc++.a", "stdc++");
+    add_static_runtime(&compiler, "libgcc.a", "gcc");
+    println!("cargo:rustc-link-arg=-static-libgcc");
+}
+
+fn add_static_runtime(compiler: &cc::Tool, archive: &str, library: &str) {
+    let output = compiler
+        .to_command()
+        .arg(format!("-print-file-name={archive}"))
+        .output()
+        .unwrap_or_else(|error| panic!("unable to locate {archive}: {error}"));
+    assert!(output.status.success(), "unable to locate {archive}");
+    let path =
+        PathBuf::from(String::from_utf8(output.stdout).expect("compiler path is not UTF-8").trim());
+    let directory = path
+        .parent()
+        .filter(|_| path.is_absolute() && path.is_file())
+        .unwrap_or_else(|| panic!("compiler did not provide a usable {archive} path"));
+    println!("cargo:rustc-link-search=native={}", directory.display());
+    println!("cargo:rustc-link-lib=static={library}");
+}
+
+fn collect_files(directory: &Path, files: &mut Vec<PathBuf>) {
+    let entries = fs::read_dir(directory)
+        .unwrap_or_else(|error| panic!("unable to read {}: {error}", directory.display()));
+    for entry in entries {
+        let path = entry.expect("unable to read native source entry").path();
+        if path.is_dir() {
+            collect_files(&path, files);
+        } else {
+            files.push(path);
+        }
+    }
+}
diff --git a/native/zucchini/README.md b/native/zucchini/README.md
new file mode 100644
index 0000000..55d6a60
--- /dev/null
+++ b/native/zucchini/README.md
@@ -0,0 +1,89 @@
+# Zucchini native boundary
+
+This directory contains the audited apply-only closure used by `otadump` on Linux x86_64.
+It does not contain either complete upstream repository, patch generators, command-line tools, tests, binaries, or object files.
+
+## Source pins
+
+- AOSP `external/zucchini`: `e256025d9d9c906caba814fd7b99a311ac8b8ec1`
+- AOSP `external/libchrome`: `0aba0dccfcd93d8303678a4beb61594f7582c73c`
+
+`SOURCE_INVENTORY.sha256` lists every vendored file and its digest.
+The apply closure contains these upstream Zucchini translation units:
+
+```text
+abs32_utils.cc
+address_translator.cc
+arm_utils.cc
+buffer_source.cc
+crc32.cc
+disassembler.cc
+disassembler_dex.cc
+disassembler_elf.cc
+disassembler_no_op.cc
+element_detection.cc
+equivalence_map.cc
+patch_reader.cc
+rel32_finder.cc
+rel32_utils.cc
+reloc_elf.cc
+target_pool.cc
+zucchini_apply.cc
+```
+
+It contains these upstream libchrome translation units:
+
+```text
+base/at_exit.cc
+base/callback_internal.cc
+base/debug/activity_tracker.cc
+base/debug/alias.cc
+base/debug/debugger_posix.cc
+base/debug/stack_trace.cc
+base/debug/stack_trace_posix.cc
+base/lazy_instance_helpers.cc
+base/location.cc
+base/logging.cc
+base/metrics/persistent_memory_allocator.cc
+base/strings/string_piece.cc
+base/strings/stringprintf.cc
+base/strings/string_util.cc
+base/synchronization/lock_impl_posix.cc
+base/threading/platform_thread_posix.cc
+base/threading/thread_local_storage.cc
+base/time/time.cc
+base/time/time_now_posix.cc
+```
+
+Headers in the inventory are the compiler-reported transitive header closure for these units and the FFI wrapper.
+
+## Build configuration
+
+`build.rs` uses `cc` with the audited release configuration:
+
+```text
+-std=c++17 -O2 -DNDEBUG -DOFFICIAL_BUILD -D__ANDROID_HOST__
+-DDONT_EMBED_BUILD_METADATA -ffunction-sections -fdata-sections
+-fno-exceptions -fno-rtti
+```
+
+The generated `include/components/zucchini/buildflags.h` is copied from the pinned Android build.
+It enables DEX and ELF and disables Win32 and ZTF.
+`include/gtest/gtest_prod.h` is a declaration-only generated-header substitute used by the proof.
+The build links the native C++ and GCC support archives statically.
+Rust's Linux GNU target still links its baseline `libgcc_s.so.1`, as an empty Rust binary does, and retains dynamic glibc.
+
+## Local boundary code
+
+`src/zucchini_ffi.cc` and `src/zucchini_ffi.h` started as the project-owned Milestone 5a proof boundary.
+The local copy changes the exported prefix from `zucchini_proof` to `otadump_zucchini`.
+It also extends the audited DEX preflight to allow more than 65,536 strings.
+The extension resolves each reference delta without writing and rejects any `const-string` 16-bit writer target above index 65,535 before upstream apply can reach its checked narrowing cast.
+The 32-bit and jumbo writers retain the full DEX string range.
+
+## License notices
+
+The Zucchini sources use the BSD-style license in `vendor/zucchini/LICENSE` and retain `vendor/zucchini/MODULE_LICENSE_CHROME`.
+The libchrome sources retain `vendor/libchrome/NOTICE` and `vendor/libchrome/MODULE_LICENSE_BSD`.
+The copied ICU declarations retain `vendor/libchrome/base/third_party/icu/LICENSE`.
+The copied NSPR declarations retain their tri-license notice in `vendor/libchrome/base/third_party/nspr/LICENSE` and the canonical full MPL 1.1 text in `vendor/libchrome/base/third_party/nspr/MPL-1.1.txt`.
diff --git a/native/zucchini/SOURCE_INVENTORY.sha256 b/native/zucchini/SOURCE_INVENTORY.sha256
new file mode 100644
index 0000000..cdecc7d
--- /dev/null
+++ b/native/zucchini/SOURCE_INVENTORY.sha256
@@ -0,0 +1,216 @@
+b518d60f01ff369072d4c538af21735c7eadf1e7b4da6672b9d97747cdd90aee  ./README.md
+46910208394401b1554d4d7f72a29321825a69f56d652757416df82d233fc1ca  ./include/components/zucchini/buildflags.h
+c70eca6f124dd593ae6315bc4576e7d740776614248302e176bd4facd3fd8f46  ./include/gtest/gtest_prod.h
+525112dc60b8361681d6977a74b8a07d06e20fb266ef412e4a11e1a113068fb2  ./src/zucchini_ffi.cc
+11696b3b8d3dc920e2375d98fd95028cd32c6c1ea86b082d6f800e00fb357703  ./src/zucchini_ffi.h
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  ./vendor/libchrome/MODULE_LICENSE_BSD
+7a209dd1b94cabdb5ea9c6f9164b9546ffa5daaa671e7767d49510db055f5c51  ./vendor/libchrome/NOTICE
+7eea8279dea1533467acb0e6b21e7506843c75540455b79a1fb08be6b4ffa999  ./vendor/libchrome/base/at_exit.cc
+ab949b0cff351bb03783efae73468610a26ef4ae4dcce130a91777df9ea87c16  ./vendor/libchrome/base/at_exit.h
+95925ae1ec4daff96d8233d4c0a95405481542b50d58d33cafc2f46dce121e52  ./vendor/libchrome/base/atomic_ref_count.h
+ff55aafc7cdfd61ce5fd0f3fdd3deadcfe651171a195984bf2ecef7a6ee51e7e  ./vendor/libchrome/base/atomic_sequence_num.h
+e11cc9ca44c0d03b7fe7bbb75251f8946f2ff0faec7c34f93784d5bbca41a9af  ./vendor/libchrome/base/atomicops.h
+66aba23e522d58c43a150bf5b4d27c9fe568518a498ef36e8686bd6ad606ee50  ./vendor/libchrome/base/atomicops_internals_portable.h
+a115f8bb46d074a4c882b7ba45d3b9d63b89db80b81c48e334e7da3d31e1b24a  ./vendor/libchrome/base/base_export.h
+fcaf8cb6e8d7e8844d53e8a79152d313ff7d1fb2faa4bad867a7d629855ba9a0  ./vendor/libchrome/base/base_switches.h
+0a5c281222b7ed05e208bb255ec597c6386314d02e57b8f7f871dc9445e9dcc4  ./vendor/libchrome/base/bind.h
+3e9d5557534a399d69813cab3bc2b41a7c68a4ea2a9c868979576fcf05933414  ./vendor/libchrome/base/bind_internal.h
+14acefaa5942c15a522d943d88422e8f1d6e861998248ed2654b303752434ebf  ./vendor/libchrome/base/callback.h
+6a3fe03450edca7552622704220e7bfd8b7455b8898e84b0d4c68fda7a8492f3  ./vendor/libchrome/base/callback_forward.h
+1f6dd284ea3299ef73ddd1a6c1adc8b83c7192a36cb48ca747a364cba837f533  ./vendor/libchrome/base/callback_helpers.h
+0f2c1cbf003f898f298a74ac9c247d52a8b825e2d6d0f251155e43be8f297c2b  ./vendor/libchrome/base/callback_internal.cc
+f43005e3ae91bc78a6493b7f0ba9e41603bd2c4e5cf079d7f4a3075ccf9e0911  ./vendor/libchrome/base/callback_internal.h
+763e91c9dc45aed5f350df32ec0f2ada535e9d36f7e28c9924fa02dcf07e28d4  ./vendor/libchrome/base/cfi_buildflags.h
+6256e005c8a1d0a3af1038064b851feacd021605e0017c0e3481512e279c6804  ./vendor/libchrome/base/command_line.h
+ddf87b6d8ada67f84b3032ee303ae67f3cac666303e532930af7eb64818fc88f  ./vendor/libchrome/base/compiler_specific.h
+16be70435e9ea50e74da48e11f40cbddd8d9a508a8ba5ee86fa611b6ed81f183  ./vendor/libchrome/base/containers/circular_deque.h
+4d1d402d9b199e292d06dad9ef9fcfdd453d8e6ba6f93c9b305d7e4cc4d7ac06  ./vendor/libchrome/base/containers/queue.h
+8b290149ae390c707d5120690b5f7dc016325276ff83e3231fb31e62de5543ca  ./vendor/libchrome/base/containers/span.h
+d524a463cc85d6c3359d79cd2d8e619ba4894b1820930296115c8685cf8a0615  ./vendor/libchrome/base/containers/stack.h
+2095c72078ff48d5cd31fb16f8c131c4b037ba8afdf42e01c21358b069dbd5a3  ./vendor/libchrome/base/containers/vector_buffer.h
+5248ace2637fd8a66e235de1e0eec6371b5f5036f360105bccf3c0e824f6ab04  ./vendor/libchrome/base/debug/activity_tracker.cc
+660e2682919377aef71bd26189022d665583dcaeff1933666ae82d0dedb2cc22  ./vendor/libchrome/base/debug/activity_tracker.h
+7e60b2250a92dddad5c0aff52d0ba7d8988e1662549943334604b6120d4710f9  ./vendor/libchrome/base/debug/alias.cc
+19d038abbeb20294dae3dd7bee5f17ec166d981c45e664a3d627a930f860d479  ./vendor/libchrome/base/debug/alias.h
+384808eaf4c764a17104d7e42d28ebed58ded5c06cfc1d618e673c4a44959978  ./vendor/libchrome/base/debug/debugger.h
+5e7ccee5d6abf15827f1bbb054528af3d3ad105f8bf517ef8d06671bdf913414  ./vendor/libchrome/base/debug/debugger_posix.cc
+ef306a4df95ee2e7325dfe59ad00b8f328a5f4a6a83cef95295a7ad32ef9af9c  ./vendor/libchrome/base/debug/debugging_buildflags.h
+577cc68c01e8fc3195301091d0dea125358d3d1012a735480fa965a79f2775c6  ./vendor/libchrome/base/debug/leak_annotations.h
+c0a70a2d084504e5995ced489c99b27699aae553982934a4a8bf45310c86ba31  ./vendor/libchrome/base/debug/proc_maps_linux.h
+abbad5021abe5d0610cd527a1c32fbf21ca66b387d66de25eb2754f6cdab8dad  ./vendor/libchrome/base/debug/stack_trace.cc
+8983e7f6cef3edcf2e61b8dfa1f3ef59801f6ce921967718164b955ef0a1c3be  ./vendor/libchrome/base/debug/stack_trace.h
+509ccef03a82f241e79dc5eb697c274a099c41459494bc4192cb2c9a33a71e0f  ./vendor/libchrome/base/debug/stack_trace_posix.cc
+6f1023488e5778f8918240f820a21822995a52bd33e122ad559a06aeb099f9b6  ./vendor/libchrome/base/environment.h
+6847915693d962edb7c003221ef28c463b38450fc4fb0778d6ee42ee5b4e392a  ./vendor/libchrome/base/feature_list.h
+898df95516fd3d653460682a50bac033bd634211007e1aa26522db31993c2425  ./vendor/libchrome/base/file_descriptor_posix.h
+6331fcdf07251dd8ff20df9b0b63cc356d9e65b15fae4f0ffd37dc8d865dc21b  ./vendor/libchrome/base/files/file.h
+abd100566d3872fdb06542f9eba167b825b3dd716969769125d2219152535b49  ./vendor/libchrome/base/files/file_path.h
+1edbaf0012fac3c3b0b7750548a400c82ddcb8303fa3e2a0ef1cbec4fc7706e0  ./vendor/libchrome/base/files/file_tracing.h
+98e9466692904f0201b6d3ce9ed1655b7a8e7fb9b4fac7794bd9c17823b44038  ./vendor/libchrome/base/files/file_util.h
+2c8211841884991837e1f674e9e472e5ce2e33d3a00f3d0e282fd6310d05a140  ./vendor/libchrome/base/files/memory_mapped_file.h
+356a0860f98e07c65fb55bab6c1358ce798deeb0926f36c6366d8ce2d50725ae  ./vendor/libchrome/base/files/platform_file.h
+4bc310531e4c3a0ef738451c12c1c2c8075b2d3b578ca769687f86f28ca82c3c  ./vendor/libchrome/base/files/scoped_file.h
+c7867f094c7341c1908171982cac96da60a4e8ff636d565bd41f38f331bee0b7  ./vendor/libchrome/base/format_macros.h
+39f1ed8adf4d8c130ccf26985fc9e248d50810231d1f337fdcc2fd23cb5c2841  ./vendor/libchrome/base/gtest_prod_util.h
+0b29c9dc2964398c0e106032951219bae13038f3752e74c5d4103e65ed43771e  ./vendor/libchrome/base/hash.h
+faaa17dc769a74fa9d4a3471e318b96cdd13f273bb0389bbbbccdcc127c6fb90  ./vendor/libchrome/base/lazy_instance.h
+25edacb2c87e390ce637d53a8fca9238dbeb93bd499775b80630af3f02c20b2a  ./vendor/libchrome/base/lazy_instance_helpers.cc
+a3c6aeefd21c577d5c943a6e57ba275a0ea9510871a08c10ce2667e42f2a46b7  ./vendor/libchrome/base/lazy_instance_helpers.h
+e4448091f421abc708425d6f7edbd3cb54024f624269c2c2365845d72edc21b9  ./vendor/libchrome/base/location.cc
+ea21ca73df75d082d8054fff602c3504c0b7e1fe47bb7d61469890eec55d5887  ./vendor/libchrome/base/location.h
+db1ed6dd2bd092bfb20f526ac4c1ebfd73b175bcc9c78bcf99d5686f5179c67f  ./vendor/libchrome/base/logging.cc
+4c16e632e60a9033a0d5bdcc840dbc339001b2f8dff90992213b2ac3655cd566  ./vendor/libchrome/base/logging.h
+b8d421b95f0707ebddcb68f73aa9b52018c0918e0745ed537a5079df61640ccd  ./vendor/libchrome/base/macros.h
+39eee8aa7118e77b59b571cf1275a1e7ab8cf6038be511e3fc239f41ef07f49b  ./vendor/libchrome/base/memory/free_deleter.h
+12b1c3664472a7e0f9f860f09e204433210a6c466c059d6550a80b37d2c5ea32  ./vendor/libchrome/base/memory/ptr_util.h
+0ad0481767efdee6ded70882010b370ab8c440010271216ce6c5ac1485dcee2c  ./vendor/libchrome/base/memory/raw_scoped_refptr_mismatch_checker.h
+3a8c7bee6566182520d980bdb7c84a2f8115e92e800b6570042ab835947b875f  ./vendor/libchrome/base/memory/ref_counted.h
+3d76ab6dcc4b61f201e5addb6f7e75104af267fdeb2cf0108fc454bcf1ee4433  ./vendor/libchrome/base/memory/scoped_refptr.h
+adb6c67fde3e25c44a8c6167f77b31f925cf888d0f8a6b77715915e549dd7990  ./vendor/libchrome/base/memory/shared_memory.h
+7cfd65f746b47c18f17beed5d590f766b6bf1a46842a6981a6aa8546cf79697d  ./vendor/libchrome/base/memory/shared_memory_handle.h
+6d767a757eeb586fc1db68f531e15e6a25ea411fc4d803f9e581feeeecbcd9ae  ./vendor/libchrome/base/memory/singleton.h
+d98c1ee76f99ab424c1130d0cdb6f91c115c2840b424884687f0b54cc703ddb1  ./vendor/libchrome/base/memory/weak_ptr.h
+53e8213f2af73f0e4589ab80d23044fc9b3c4613eaa942e339311c0153168723  ./vendor/libchrome/base/metrics/bucket_ranges.h
+566636ba6da0c61032f573fc00787adecb6749bf090d55a0ae26ae3afcf75745  ./vendor/libchrome/base/metrics/field_trial.h
+04bb4fcdeaf28852ddaa9dee4b52121fa773533f7cedb6d16819a0404c8a5425  ./vendor/libchrome/base/metrics/histogram.h
+002a9bcb9e23b91e262ba1591a41b4980750ad9c651cc20c40341dabf3df0dd4  ./vendor/libchrome/base/metrics/histogram_base.h
+b0a4f1f19a60d420d36e37c4e35a49b09d2dddf185fef2c2ecbc3677ce5b8faf  ./vendor/libchrome/base/metrics/histogram_functions.h
+d8207dfd23a62e3ee0f8f15d22f905f97893826afbce31f3bd92475366f2b4a1  ./vendor/libchrome/base/metrics/histogram_macros.h
+26b160d21fdf9e326661872cf277c833c71f1df079d8b468e2e901a9a476db47  ./vendor/libchrome/base/metrics/histogram_macros_internal.h
+f12f2fe5cdc0ad5b3c0f7f0eda55eefda882c4a64730ac7220137ff5e0819f1d  ./vendor/libchrome/base/metrics/histogram_macros_local.h
+879a70627882d3e5c61d745d3dce90f499575380d159a6af652f29b838ac401b  ./vendor/libchrome/base/metrics/histogram_samples.h
+950b5200b8b79ad3f17647df2d6be1c9857edf53c6b12ac5a5af711c78197e8d  ./vendor/libchrome/base/metrics/persistent_memory_allocator.cc
+fddf573151d2bb41823eee2cb6a287f3693907ba7e5aadc5dcce38a414171e73  ./vendor/libchrome/base/metrics/persistent_memory_allocator.h
+3128707a2e0d6ceca20e38525dc0f36001fe28cd9f804d6d410e3ecf6e14d7fb  ./vendor/libchrome/base/metrics/sparse_histogram.h
+7f1973655f80dcf22a56859302666c4f585ec18cb4bd57f2a18e1b8b0f68aec6  ./vendor/libchrome/base/no_destructor.h
+0bb2cfd67028f404afe4eecdb25685faa3cefe49580ed6c45d04b4cda119eade  ./vendor/libchrome/base/numerics/checked_math.h
+6b7c4cdfce938c30e60b842ccdabd126796fd4b099abd7f26326ec4b479d7952  ./vendor/libchrome/base/numerics/checked_math_impl.h
+b48654af190a06d2689fa3d74846700e94639f6354d9aaba9f44a502f9617c16  ./vendor/libchrome/base/numerics/clamped_math.h
+81ed1886215ce8529a67fba88f9489acaba34eb3d135043484502e9933d125a1  ./vendor/libchrome/base/numerics/clamped_math_impl.h
+5cfe96da219c074e6c663663a307da3400ff3929c84331543152e9a2d413aec1  ./vendor/libchrome/base/numerics/safe_conversions.h
+5dd3f1a915832056c17acb2d6dd3b090e77b6fe43a6793730dc1b6a74173d285  ./vendor/libchrome/base/numerics/safe_conversions_impl.h
+bca10c42ff950f1f1e4cef59c34b48b9ff5f70f248ed12eead48d74fc0e38de2  ./vendor/libchrome/base/numerics/safe_math.h
+656227ab097d774ee47371f7ad50c94bd86d9ab83ab43531c57c9c78052417cd  ./vendor/libchrome/base/numerics/safe_math_clang_gcc_impl.h
+ee8d59a9e7c0b79319787aba29622a1bbaec08987d4b587d4ef91184b7788c5d  ./vendor/libchrome/base/numerics/safe_math_shared_impl.h
+bb44ae253fa52ccdd2bad7c3a1122a1923d64f341d95ab148397aea97b783950  ./vendor/libchrome/base/observer_list.h
+f711d658592ab18b49edaa43672263ee9a4cf116e4891e0fa9b5e314740eb167  ./vendor/libchrome/base/observer_list_threadsafe.h
+f3af785ce37e88f8cdb42e76f8a6d27fb09c63d4071aff38926c980c4d5eb66d  ./vendor/libchrome/base/optional.h
+aedd02ae4884b5ecf2de228e6444eb297f093d566cfd09a7de06e5ef900505dd  ./vendor/libchrome/base/pending_task.h
+42808892f816366f75f101f8adb830dec6d808c785cefd490d8fa8cc06f343fb  ./vendor/libchrome/base/pickle.h
+cb298c5e1569f0f85ef07d569a6beb76637ba0310a52cf9741a68690d2f8c7ef  ./vendor/libchrome/base/posix/eintr_wrapper.h
+8746ddfd8cbc57e67fbde0033b3616d5b868ee23179d2c1846c3a7c01317eadc  ./vendor/libchrome/base/posix/file_descriptor_shuffle.h
+fdc5328da33867488cc291f4654f9a69502307390f7f9d876739f530016ed9f3  ./vendor/libchrome/base/posix/safe_strerror.h
+1b6ef4a5ce4fc7b7bedad53ec48d340be9fff8215f209a03134ecc7612fcc3d6  ./vendor/libchrome/base/process/launch.h
+7d0eaedf65343835f38d16c7281cd096491866e8156417c379940feeb316e2db  ./vendor/libchrome/base/process/process.h
+d45eb69e02ac8d950d8aebc87946dbbb0fc5e927e34302128665cc6c5700c881  ./vendor/libchrome/base/process/process_handle.h
+5eef370b91123e0b12854ff383947d9a6bd9e553315d75f8d7f2a394456d3c06  ./vendor/libchrome/base/scoped_clear_errno.h
+4f68c4c5758cc579cfdab0405d437c54161e4d3ec2761ea5bdadfbdc9d65619a  ./vendor/libchrome/base/scoped_generic.h
+863a1fb61810bd5d308439428d5301155030dd2d51a73244c4a75ce07ebc3b35  ./vendor/libchrome/base/sequence_checker.h
+3b55182f87a1b4c57979f3fe2fcff4833404ed9be6e75ec0423bc8e253afc537  ./vendor/libchrome/base/sequence_checker_impl.h
+0b41692ee85e5781605eb68d0e51e3ca4191cede5bb0c37372cb25633f482ec0  ./vendor/libchrome/base/sequenced_task_runner.h
+73aee8f58898e1b0f0e0f713003d753b76f901dba5abb5598333a23f38781afe  ./vendor/libchrome/base/sequenced_task_runner_helpers.h
+a6123b3785d441a2e3d348954d72c90cce063444195e28fef3e5ee4652cd55d1  ./vendor/libchrome/base/single_thread_task_runner.h
+b1d59c6adc27090ae8dce081d7ba4f61e38d7fad34ac435d186c53f838bdb4e3  ./vendor/libchrome/base/stl_util.h
+36761f94411e4dea7e10d51d6f73f8d850073fffb2810cdbf61a4cbc9781c5b2  ./vendor/libchrome/base/strings/char_traits.h
+e307adafcec337b2c94aebbf0895f9895a10e3144a340de022a591329d3cfd83  ./vendor/libchrome/base/strings/string16.h
+d5566a0b4d8a72eff8c29981486a256ac311db017fe83440ca28df91a597064d  ./vendor/libchrome/base/strings/string_number_conversions.h
+d1a7eb29ef12aac370ce7440fd762a3c895df482bfbfce91fe389f8fc02a207c  ./vendor/libchrome/base/strings/string_piece.cc
+cabcd4c342b5517ca10ca87822167007909a6eb1ea55c56dbf17b399355f2c8e  ./vendor/libchrome/base/strings/string_piece.h
+aa31bae42314a2cb199178d5b89344e7e238bb87794fcff05a5f4fb14a234680  ./vendor/libchrome/base/strings/string_piece_forward.h
+135247764c1c921b0e29227ea50fa6888fcb1f9df1edae94a634c22a2ef9e2ce  ./vendor/libchrome/base/strings/string_util.cc
+2742eb72e2b4b24c188428bf4fbbf13abfffa0d7ff36d1a1236686f0e02b1174  ./vendor/libchrome/base/strings/string_util.h
+65d8a40c660e94776b8062a3ff99362fc0105438cc6b829a31b3ac0042251eda  ./vendor/libchrome/base/strings/string_util_posix.h
+dc764a4d57c22571762baa7020b2aade45efd771e48de4df1f61864977015427  ./vendor/libchrome/base/strings/stringprintf.cc
+f34b0fce20b11198a643713112ce8d896ddbb4c3a9422e91f6d00a2cd836147a  ./vendor/libchrome/base/strings/stringprintf.h
+af2490563321b285c2c7c4b5d3f37c3769599b227755b2c5b7dae2fe374147b5  ./vendor/libchrome/base/strings/sys_string_conversions.h
+dfac333abfe781d854063c6857f91025d34923267d5c2ce25a264a57b1812d2b  ./vendor/libchrome/base/strings/utf_string_conversion_utils.h
+d1245a0efe12da92fe31ac87a563143612f4192dd569bc88b22114556399d231  ./vendor/libchrome/base/strings/utf_string_conversions.h
+2c27513476338b412cfd0c4ea101568e13d82e147dc034bac9c27a37ba5af2c0  ./vendor/libchrome/base/synchronization/lock.h
+8bd9a1409ae597c71970d684ef35569ef75640722b51f5f63a17b04cd3173788  ./vendor/libchrome/base/synchronization/lock_impl.h
+2ae402e3a5261b4366f889ee2a7e2819c0ce204cf3cafa2db612d142a84020ed  ./vendor/libchrome/base/synchronization/lock_impl_posix.cc
+b8b9d2bd6274cdafbecc0dfe305629304ad2ae5294d5732e7753ae12fb3cc497  ./vendor/libchrome/base/synchronization/synchronization_buildflags.h
+7e422f463d25ff45bfe4790d9f03db767834391dff615aa1776ef27d03f7eb41  ./vendor/libchrome/base/sys_info.h
+7f686442f979e845be8587b7512104f691ee19c2adf7c84d766194d2007dccc1  ./vendor/libchrome/base/task_runner.h
+68c12b240d5d3b448ac9284c2c6e97b1433f00306316fb6b11a2d1d2cc2f99a6  ./vendor/libchrome/base/template_util.h
+5d85142a5609ad177a2d7a2e7cae060b886b8b42f25c5b9803cf0cb5ee04ad2f  ./vendor/libchrome/base/third_party/icu/LICENSE
+19bafc2118bc6b45b99c38ce1af08bf8aaee09cf97045d1d98085876b5a1b1b7  ./vendor/libchrome/base/third_party/icu/icu_utf.h
+d55a403514532af12dc2fbfb2e41900090a5dd6c7c76c8e4d9b20bcc737eac35  ./vendor/libchrome/base/third_party/nspr/LICENSE
+f849fc26a7a99981611a3a370e83078deb617d12a45776d6c4cada4d338be469  ./vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
+fde038204e73c962e053ac163369338ffe8ac54fd84e3aa21391b3369fd63aca  ./vendor/libchrome/base/third_party/nspr/prtime.h
+f4b6e1de49233de43b0ce2500468a2c1f5b8783af3fb7761220f38315bc2df67  ./vendor/libchrome/base/threading/platform_thread.h
+136e195f9176bcd14c3a3549ea5d8541094439993a4ace95eba87ee0e02288ef  ./vendor/libchrome/base/threading/platform_thread_internal_posix.h
+40044c247b6b06af72ff5eb62da18dd37ff2f48031f087ba7ed9f86ead7fc04d  ./vendor/libchrome/base/threading/platform_thread_posix.cc
+2a9146e0a822daad3282d81c663eed290d0a536a11ea0265ae6262f11630e2dd  ./vendor/libchrome/base/threading/sequenced_task_runner_handle.h
+b1bdbadeed33ddb77193f0844c32e8baa67a5ae5d5dbe3b9f54cadc6a631b972  ./vendor/libchrome/base/threading/thread_collision_warner.h
+09573a81341f073ff72e141847c45445e4b41029bcc54ef469416ce34e7f4e1a  ./vendor/libchrome/base/threading/thread_id_name_manager.h
+39f1e448827d544c6a4ea6052730a23774e43d805675dc4eff1e62dac7430fbb  ./vendor/libchrome/base/threading/thread_local.h
+4ce66ab1de62adcd404711aed89d5ce6866930cf0903275b32a67d83c78e5dfc  ./vendor/libchrome/base/threading/thread_local_storage.cc
+9ec1a85d04bdf1e460791ec8825f0af1e25d4a9962069dbf90b55089a41b4408  ./vendor/libchrome/base/threading/thread_local_storage.h
+294837f7209f5398f09fc050a4dc7737fe7a35f48c5fedb7be49102a36ceb7c8  ./vendor/libchrome/base/threading/thread_restrictions.h
+20a42edaec24cb2b33d7134c1efb0b9343a0dcf4c825f676cefee6e09be7454d  ./vendor/libchrome/base/threading/thread_task_runner_handle.h
+f3045ca162b851e605cf21dd3b5369f74d5d937c41bab06770b7d45369cf8833  ./vendor/libchrome/base/time/time.cc
+fd4782801bfdf9286362116a6a7a905ccfbc55df32645f1967d8cbc265f0e6a8  ./vendor/libchrome/base/time/time.h
+6817b3e18ea1f6dc3c67195380e5b873cd6952acbf7600edd54df1526623d997  ./vendor/libchrome/base/time/time_now_posix.cc
+5fd3201d87e6d2e314f6397ad2e81b7a7d0100df233af3f2a488c4480e096640  ./vendor/libchrome/base/time/time_override.h
+f69f40e3b8536c7df01132d4d4028fc0c25ec0d4223c965536564691e50344fe  ./vendor/libchrome/base/token.h
+bc23ab463856a5e56ab83b1ef3c4226099bbb7bf6c427c32ae15d42a21f6bfed  ./vendor/libchrome/base/unguessable_token.h
+c23322de7ef5b172228c9009237d15d2faf7106e30e0278f3d4519d78bfc4cd3  ./vendor/libchrome/base/vlog.h
+12b6cd8acf682fe2a6d90c469619c4b9d794d7fe9c3172d9d5e024d5a1659bfd  ./vendor/libchrome/build/build_config.h
+3039541e5c5d018230b8bee6a5e59eb4d6bafa7c68732b9e61b41fd81a27bc3f  ./vendor/libchrome/testing/gtest/include/gtest/gtest_prod.h
+845022e0c1db1abb41a6ba4cd3c4b674ec290f3359d9d3c78ae558d4c0ed9308  ./vendor/zucchini/LICENSE
+e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  ./vendor/zucchini/MODULE_LICENSE_CHROME
+4701a0af1d9be83a5b24d65490c75c2c37772333b38ad3fc7878e8fc9d8267e0  ./vendor/zucchini/abs32_utils.cc
+859d2681911be3697121b7eea7b5382b28da16deb8b068a03ef6e0c361dbd445  ./vendor/zucchini/address_translator.cc
+ab9c9deb93f16a550ac6a34907b78c272f2a19604e5409473895315e29bcb2c3  ./vendor/zucchini/aosp/include/base/check.h
+05525647e279146b36863904530dd0006d1f82f99fd2767ff39d69239e235aea  ./vendor/zucchini/aosp/include/base/check_op.h
+43d9d019e637b750a7bc1e0a3944d1d4cea12cdff4e0905474e16db58415b6a2  ./vendor/zucchini/aosp/include/base/containers/cxx20_erase.h
+30ef02104a03e0d55e3bc63c048f9057312f0131b2b949397e1d978dd011695a  ./vendor/zucchini/aosp/include/build/buildflag.h
+9df450f653d9e0026b162f57a2c77133836cd62df378e25534322b6ee3e98ab5  ./vendor/zucchini/aosp/include/components/zucchini/abs32_utils.h
+3ed0c865d024dcce6538903397ce6ac72c40c2a3ba0f16bc4a92f1180924269d  ./vendor/zucchini/aosp/include/components/zucchini/address_translator.h
+4ab4a0705c8376ae4619d6122afd390118d94ad90e7909da2e532884423f1d2e  ./vendor/zucchini/aosp/include/components/zucchini/algorithm.h
+3f069245e00549328cbf36cfb78dcc9b2ab90c08a5476d82c49f6c7fa165b8a7  ./vendor/zucchini/aosp/include/components/zucchini/arm_utils.h
+f149c8b80c4234ad7be88d896e4498524f48f168cb1c31637e9c1d1695b2cf8e  ./vendor/zucchini/aosp/include/components/zucchini/buffer_sink.h
+c25889b6dd08e241d8903f460284a2792e73ad88776c787f41b1ac480b51fb0a  ./vendor/zucchini/aosp/include/components/zucchini/buffer_source.h
+5bd8910752183f45f840b6065dd94e5bc9e7481f83fb7631c4ef25df687b854d  ./vendor/zucchini/aosp/include/components/zucchini/buffer_view.h
+f739b6c029ec40a9f7bd5305c3d0ae5e428c085797fa18739fddd46a0fb98663  ./vendor/zucchini/aosp/include/components/zucchini/crc32.h
+03780b011ee7c187fce41b42aee32de5ce1078c76c32366fb16b4c9aaf6e05db  ./vendor/zucchini/aosp/include/components/zucchini/disassembler.h
+b9c91a0dd897bfaa26df6c3247aaf99e75cd264357f615bf2e109b9f7b119080  ./vendor/zucchini/aosp/include/components/zucchini/disassembler_dex.h
+852e3797431f194424044d210da3f53cdeceefb23e8baa51a21ec73b38dd5733  ./vendor/zucchini/aosp/include/components/zucchini/disassembler_elf.h
+69bc539bf723efccb937c5fe93d29f49f6639559920d9259ee44a4f46e134c19  ./vendor/zucchini/aosp/include/components/zucchini/disassembler_no_op.h
+b5e86cf5987049adb790b81a485b108f2a5db180fcef9234a7b5948159cf5ce0  ./vendor/zucchini/aosp/include/components/zucchini/element_detection.h
+ccd17f233302411ba5d2df59071ab7201893422aa9d54db54b2d75dddbad22ba  ./vendor/zucchini/aosp/include/components/zucchini/encoded_view.h
+952c790d808deb6bb9c5bccd00a8e6504ecf474ade5312303e078b1de3fb5065  ./vendor/zucchini/aosp/include/components/zucchini/equivalence_map.h
+7c6f41c221036f83051e057eeffcbcd509a556ca994bba85b0b78c6a6cb5dcc4  ./vendor/zucchini/aosp/include/components/zucchini/image_index.h
+908655de17bfebe5eaeeade4cdd2a567a2907e5e013cb0bb19d820a92aa8ec96  ./vendor/zucchini/aosp/include/components/zucchini/image_utils.h
+a3bc23d7687bcf4e5d316b7e8e7771797be973dc9bde2977bab80ef946665cc0  ./vendor/zucchini/aosp/include/components/zucchini/io_utils.h
+d28d66e9de9ba132d6f9b907e18ae7c61801a4fe8737a2a5e5206b5906315e19  ./vendor/zucchini/aosp/include/components/zucchini/patch_reader.h
+53f48d894382fec2677ac434e139b770bcad69a8f642a945f1ccfe44938be211  ./vendor/zucchini/aosp/include/components/zucchini/patch_utils.h
+d6556ba0cf992253dbfa0e469927b3238279865ebb8b9795752b08ad55adaff5  ./vendor/zucchini/aosp/include/components/zucchini/patch_writer.h
+6562d611fab6975c17fbf375d9654878c5f6ea9c711394d5f54fa6a2b34ba7a7  ./vendor/zucchini/aosp/include/components/zucchini/reference_set.h
+e461b4da6a293817f7aba5005f8d53b3597e931899ab5b4a0f725c830cf442b3  ./vendor/zucchini/aosp/include/components/zucchini/rel32_finder.h
+92214559985d7813f39651fc56820c9aad03cd360398cd778fd84880f6abe08d  ./vendor/zucchini/aosp/include/components/zucchini/rel32_utils.h
+85deddab8aec5f2eb2c7d38e35900434ab0bdb98ca82d03be1114920c229ef12  ./vendor/zucchini/aosp/include/components/zucchini/reloc_elf.h
+608a7b2e6a6c998d9641d46f0b138e44c95acf2559ddfc31fdf52fe61806d7d6  ./vendor/zucchini/aosp/include/components/zucchini/suffix_array.h
+e7a1365b362bda44cf68df75f21d3c6df49f6c75e04a53788d3d3d3451cab935  ./vendor/zucchini/aosp/include/components/zucchini/target_pool.h
+8dc3dab58827d8c1432eafa7714a1d39e7e9e2d132b895b9997f4226b9937a4a  ./vendor/zucchini/aosp/include/components/zucchini/targets_affinity.h
+f4e5ad0c852f80f2929e95fb81ff095abb3f2c9ecc9257254558bf49cc99d453  ./vendor/zucchini/aosp/include/components/zucchini/type_dex.h
+9204b7970c7b1f3ec27f5f3970fc5131c5d4d3177052a93f47a9ab378e16c958  ./vendor/zucchini/aosp/include/components/zucchini/type_elf.h
+74733f75da09ff5e3a3d7e15c662eac946f6acd58033579673c3ddfc6952692f  ./vendor/zucchini/aosp/include/components/zucchini/typed_value.h
+480438e1cde53fecf15fba573aaf3c60c0a0870c6cc53efdd6746d6ad5b00a43  ./vendor/zucchini/aosp/include/components/zucchini/version_info.h
+f78d8351a1483bdb35774eb37b4f68f64eeca722eaf433437d1cdb32b5db0a5b  ./vendor/zucchini/aosp/include/components/zucchini/zucchini.h
+9033c748e797f9db69ee599d994d51763fd531cd2bf1793a635d52ce22994972  ./vendor/zucchini/aosp/include/components/zucchini/zucchini_apply.h
+027123695382e7a5630d5da6841fe87d9b229b8bfb2e5cca6467da266ae95c9a  ./vendor/zucchini/arm_utils.cc
+ab75e4e8d05002d9db732fb92d3d36ac862a823d92d8be14ef595f452dc746eb  ./vendor/zucchini/buffer_source.cc
+9994adabd554adf6992231d74ca4dec66651e86b3987017f432cb04d04d8d48e  ./vendor/zucchini/crc32.cc
+3403dcba9034f039cfe245fe143b6e73e1ea7515ca3fd307eb8ee4be6cbf8128  ./vendor/zucchini/disassembler.cc
+02948825abc47bffaa1dd1c774b06394fe7192b4e74e33f14d4a61d263989f7e  ./vendor/zucchini/disassembler_dex.cc
+5b853a907c7bb883d7485cb22ec7d8def7c6df432ddfd54c49f96c8cf558276a  ./vendor/zucchini/disassembler_elf.cc
+4054b3a647ef5d16e3006526db1b34a39b8de8ba49871c1a88ea4778b0599d9d  ./vendor/zucchini/disassembler_no_op.cc
+e21f53a5d599a256f97d54abe890e21722847fe7aa2373b4a5968b74976e2ae8  ./vendor/zucchini/element_detection.cc
+5dc41a3c41970077b99dc5c6028cf9c5fa74b3fd9d115a2936f0064814761fb5  ./vendor/zucchini/equivalence_map.cc
+b0d6670916d0d5f6f0668605551d6fed1701231986f4e40538394dab7dd1660c  ./vendor/zucchini/patch_reader.cc
+175c78a1b4b9026c78fb891b5419ad3a90db7d75d0a39147e11f11d400fedd34  ./vendor/zucchini/rel32_finder.cc
+74e3c8f99128448b0fe75d0daf8efc31748491d1a3ea523d0a129c743d37440f  ./vendor/zucchini/rel32_utils.cc
+e472b81aebe0a511112dc88da24a70c65abfcbbc97c4cbe14b20372d690dec4b  ./vendor/zucchini/reloc_elf.cc
+a687290bda9b85b6696a9e983cb39c7e1477bc0da92ce46734ebd00302cae85f  ./vendor/zucchini/target_pool.cc
+e301b504ee2df95fbca1be829cd7f47384e07145b6316df14e370da5e9c7647f  ./vendor/zucchini/zucchini_apply.cc
diff --git a/native/zucchini/include/components/zucchini/buildflags.h b/native/zucchini/include/components/zucchini/buildflags.h
new file mode 100644
index 0000000..fbd2c41
--- /dev/null
+++ b/native/zucchini/include/components/zucchini/buildflags.h
@@ -0,0 +1,12 @@
+// Proof-only copy of the pinned Android generated buildflags.h.
+#ifndef COMPONENTS_ZUCCHINI_BUILDFLAGS_H_
+#define COMPONENTS_ZUCCHINI_BUILDFLAGS_H_
+
+#include "build/buildflag.h"
+
+#define BUILDFLAG_INTERNAL_ENABLE_DEX() (1)
+#define BUILDFLAG_INTERNAL_ENABLE_ELF() (1)
+#define BUILDFLAG_INTERNAL_ENABLE_WIN() (0)
+#define BUILDFLAG_INTERNAL_ENABLE_ZTF() (0)
+
+#endif  // COMPONENTS_ZUCCHINI_BUILDFLAGS_H_
diff --git a/native/zucchini/include/gtest/gtest_prod.h b/native/zucchini/include/gtest/gtest_prod.h
new file mode 100644
index 0000000..125a46c
--- /dev/null
+++ b/native/zucchini/include/gtest/gtest_prod.h
@@ -0,0 +1,5 @@
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
+#define FRIEND_TEST(test_case_name, test_name) \
+  friend class test_case_name##_##test_name##_Test
+#endif
diff --git a/native/zucchini/src/zucchini_ffi.cc b/native/zucchini/src/zucchini_ffi.cc
new file mode 100644
index 0000000..d2faf47
--- /dev/null
+++ b/native/zucchini/src/zucchini_ffi.cc
@@ -0,0 +1,353 @@
+#include "zucchini_ffi.h"
+
+#include <stdint.h>
+
+#include <algorithm>
+#include <cstring>
+#include <limits>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "components/zucchini/disassembler.h"
+#include "components/zucchini/disassembler_dex.h"
+#include "components/zucchini/element_detection.h"
+#include "components/zucchini/equivalence_map.h"
+#include "components/zucchini/image_utils.h"
+#include "components/zucchini/patch_reader.h"
+#include "components/zucchini/target_pool.h"
+#include "components/zucchini/type_dex.h"
+#include "components/zucchini/type_elf.h"
+#include "components/zucchini/zucchini_apply.h"
+
+namespace {
+
+otadump_zucchini_result Error(otadump_zucchini_status status, const char* error) {
+  return {status, error};
+}
+
+bool RangeIsRepresentable(const uint8_t* data, size_t size) {
+  uintptr_t begin = reinterpret_cast<uintptr_t>(data);
+  return size <= std::numeric_limits<uintptr_t>::max() - begin;
+}
+
+bool RangesOverlap(const uint8_t* left,
+                   size_t left_size,
+                   const uint8_t* right,
+                   size_t right_size) {
+  if (!left_size || !right_size)
+    return false;
+  uintptr_t left_begin = reinterpret_cast<uintptr_t>(left);
+  uintptr_t right_begin = reinterpret_cast<uintptr_t>(right);
+  return left_begin < right_begin + right_size &&
+         right_begin < left_begin + left_size;
+}
+
+bool IsAndroidExecutable(zucchini::ExecutableType exe_type) {
+  return exe_type == zucchini::kExeTypeDex ||
+         exe_type == zucchini::kExeTypeElfX86 ||
+         exe_type == zucchini::kExeTypeElfX64 ||
+         exe_type == zucchini::kExeTypeElfAArch32 ||
+         exe_type == zucchini::kExeTypeElfAArch64;
+}
+
+bool ReadDexMapItem(zucchini::ConstBufferView image,
+                    uint16_t type,
+                    zucchini::dex::MapItem* result) {
+  using Header = zucchini::dex::HeaderItem;
+  using MapItem = zucchini::dex::MapItem;
+  if (!image.can_access<Header>(0))
+    return false;
+  Header header;
+  std::memcpy(&header, image.begin(), sizeof(header));
+  if (!image.can_access<uint32_t>(header.map_off))
+    return false;
+  uint32_t count = 0;
+  std::memcpy(&count, image.begin() + header.map_off, sizeof(count));
+  size_t items_offset = header.map_off + sizeof(count);
+  if (!image.covers_array(items_offset, count, sizeof(MapItem)))
+    return false;
+  for (uint32_t index = 0; index < count; ++index) {
+    MapItem item;
+    std::memcpy(&item, image.begin() + items_offset + index * sizeof(item),
+                sizeof(item));
+    if (item.type == type) {
+      *result = item;
+      return true;
+    }
+  }
+  return false;
+}
+
+bool ValidateDexWriterWidths(zucchini::ConstBufferView image) {
+  const uint16_t narrow_types[] = {
+      zucchini::dex::kTypeTypeIdItem,
+      zucchini::dex::kTypeProtoIdItem,
+      zucchini::dex::kTypeFieldIdItem,
+      zucchini::dex::kTypeMethodIdItem,
+      zucchini::dex::kTypeCallSiteIdItem,
+      zucchini::dex::kTypeMethodHandleItem,
+  };
+  for (uint16_t type : narrow_types) {
+    zucchini::dex::MapItem item;
+    if (ReadDexMapItem(image, type, &item) &&
+        item.size > static_cast<uint32_t>(UINT16_MAX) + 1) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool ValidateDexReferenceTargets(
+    const zucchini::PatchElementReader& element,
+    zucchini::Disassembler* old_disasm,
+    zucchini::Disassembler* new_disasm,
+    size_t old_size,
+    size_t new_size,
+    zucchini::ConstBufferView new_image) {
+  zucchini::dex::MapItem string_ids;
+  if (!ReadDexMapItem(new_image, zucchini::dex::kTypeStringIdItem,
+                      &string_ids)) {
+    return false;
+  }
+
+  zucchini::ReferenceDeltaSource deltas = element.GetReferenceDeltaSource();
+  std::map<zucchini::PoolTag, std::vector<zucchini::ReferenceGroup>> pools;
+  for (const auto& group : old_disasm->MakeReferenceGroups())
+    pools[group.pool_tag()].push_back(group);
+  std::vector<zucchini::ReferenceGroup> new_groups =
+      new_disasm->MakeReferenceGroups();
+  zucchini::OffsetMapper mapper(
+      element.GetEquivalenceSource(),
+      base::checked_cast<zucchini::offset_t>(old_size),
+      base::checked_cast<zucchini::offset_t>(new_size));
+
+  for (const auto& pool : pools) {
+    zucchini::TargetPool targets;
+    for (zucchini::ReferenceGroup group : pool.second)
+      targets.InsertTargets(std::move(*group.GetReader(old_disasm)));
+    targets.FilterAndProject(mapper);
+
+    zucchini::TargetSource extras = element.GetExtraTargetSource(pool.first);
+    targets.InsertTargets(&extras);
+    if (!extras.Done())
+      return false;
+
+    for (const zucchini::ReferenceGroup& group : pool.second) {
+      if (group.type_tag().value() >= new_groups.size())
+        return false;
+      zucchini::EquivalenceSource equivalences =
+          element.GetEquivalenceSource();
+      for (auto equivalence = equivalences.GetNext(); equivalence.has_value();
+           equivalence = equivalences.GetNext()) {
+        std::unique_ptr<zucchini::ReferenceReader> references =
+            group.GetReader(equivalence->src_offset, equivalence->src_end(),
+                            old_disasm);
+        for (auto reference = references->GetNext(); reference.has_value();
+             reference = references->GetNext()) {
+          zucchini::offset_t projected =
+              mapper.ExtendedForwardProject(reference->target);
+          zucchini::key_t expected = targets.KeyForNearestOffset(projected);
+          std::optional<int32_t> delta = deltas.GetNext();
+          if (!delta.has_value())
+            return false;
+          int64_t key = static_cast<int64_t>(expected) + delta.value();
+          if (key < 0 || key > UINT32_MAX ||
+              !targets.KeyIsValid(static_cast<zucchini::key_t>(key))) {
+            return false;
+          }
+          if (group.type_tag().value() ==
+              zucchini::DisassemblerDex::kCodeToStringId16) {
+            zucchini::offset_t target =
+                targets.OffsetForKey(static_cast<zucchini::key_t>(key));
+            if (target < string_ids.offset ||
+                (target - string_ids.offset) %
+                        sizeof(zucchini::dex::StringIdItem) !=
+                    0 ||
+                (target - string_ids.offset) /
+                        sizeof(zucchini::dex::StringIdItem) >
+                    UINT16_MAX) {
+              return false;
+            }
+          }
+        }
+      }
+    }
+  }
+  return deltas.Done();
+}
+
+bool ValidateReferenceBoundaries(
+    const zucchini::PatchElementReader& element,
+    zucchini::Disassembler* old_disasm,
+    zucchini::ExecutableType exe_type,
+    size_t new_size) {
+  std::vector<zucchini::offset_t> boundaries;
+  std::vector<zucchini::Equivalence> parsed_equivalences;
+  zucchini::EquivalenceSource equivalences = element.GetEquivalenceSource();
+  for (auto equivalence = equivalences.GetNext(); equivalence.has_value();
+       equivalence = equivalences.GetNext()) {
+    boundaries.push_back(equivalence->src_offset);
+    boundaries.push_back(equivalence->src_end());
+    parsed_equivalences.push_back(*equivalence);
+  }
+  std::sort(boundaries.begin(), boundaries.end());
+
+  for (const auto& group : old_disasm->MakeReferenceGroups()) {
+    size_t writer_width = group.width();
+    if (group.type_tag().value() == 0) {
+      if (exe_type == zucchini::kExeTypeElfX86 ||
+          exe_type == zucchini::kExeTypeElfAArch32) {
+        writer_width = sizeof(zucchini::elf::Elf32_Rel);
+      } else if (exe_type == zucchini::kExeTypeElfX64 ||
+                 exe_type == zucchini::kExeTypeElfAArch64) {
+        writer_width = sizeof(zucchini::elf::Elf64_Rel);
+      }
+    }
+
+    std::unique_ptr<zucchini::ReferenceReader> reader =
+        group.GetReader(old_disasm);
+    for (auto reference = reader->GetNext(); reference.has_value();
+         reference = reader->GetNext()) {
+      auto boundary =
+          std::upper_bound(boundaries.begin(), boundaries.end(),
+                           reference->location);
+      if (boundary != boundaries.end() &&
+          *boundary < reference->location + group.width()) {
+        return false;
+      }
+    }
+
+    // Upstream creates a fresh ranged reader for each equivalence. Mirror
+    // those reads so an invalid target before a later equivalence cannot hide
+    // a reference whose source or projected writer body crosses a boundary.
+    for (const auto& equivalence : parsed_equivalences) {
+      std::unique_ptr<zucchini::ReferenceReader> ranged_reader =
+          group.GetReader(equivalence.src_offset, equivalence.src_end(),
+                          old_disasm);
+      for (auto reference = ranged_reader->GetNext(); reference.has_value();
+           reference = ranged_reader->GetNext()) {
+        if (reference->location < equivalence.src_offset ||
+            reference->location > equivalence.src_end() ||
+            group.width() > equivalence.src_end() - reference->location) {
+          return false;
+        }
+        size_t projected = equivalence.dst_offset +
+                           reference->location - equivalence.src_offset;
+        if (projected > new_size || writer_width > new_size - projected)
+          return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool PreflightAndroidElements(
+    zucchini::ConstBufferView old_image,
+    const zucchini::EnsemblePatchReader& patch,
+    zucchini::MutableBufferView new_image) {
+  if (!patch.CheckOldFile(old_image))
+    return false;
+  for (const auto& element : patch.elements()) {
+    zucchini::ExecutableType exe_type = element.element_match().exe_type();
+    if (!IsAndroidExecutable(exe_type))
+      continue;
+    zucchini::ConstBufferView old_element = old_image[element.old_element()];
+    zucchini::MutableBufferView new_element = new_image[element.new_element()];
+    if (!zucchini::ApplyEquivalenceAndExtraData(old_element, element,
+                                                 new_element) ||
+        !zucchini::ApplyRawDelta(element, new_element)) {
+      return false;
+    }
+    auto old_disasm = zucchini::MakeDisassemblerOfType(old_element, exe_type);
+    auto new_disasm = zucchini::MakeDisassemblerOfType(
+        zucchini::ConstBufferView(new_element), exe_type);
+    if (!old_disasm || !new_disasm ||
+        old_disasm->size() != old_element.size() ||
+        new_disasm->size() != new_element.size() ||
+        !ValidateReferenceBoundaries(element, old_disasm.get(), exe_type,
+                                     new_element.size())) {
+      return false;
+    }
+    if (exe_type == zucchini::kExeTypeDex) {
+      if (!ValidateDexWriterWidths(zucchini::ConstBufferView(new_element)) ||
+          !ValidateDexReferenceTargets(
+              element, old_disasm.get(), new_disasm.get(), old_element.size(),
+              new_element.size(), zucchini::ConstBufferView(new_element))) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+}  // namespace
+
+extern "C" otadump_zucchini_result otadump_zucchini_apply(
+    const uint8_t* old_data,
+    size_t old_size,
+    const uint8_t* patch_data,
+    size_t patch_size,
+    uint8_t* new_data,
+    size_t new_size) {
+  if ((!old_data && old_size) || (!patch_data && patch_size) ||
+      (!new_data && new_size)) {
+    return Error(OTADUMP_ZUCCHINI_INVALID_ARGUMENT, "null non-empty buffer");
+  }
+  if (!RangeIsRepresentable(old_data, old_size) ||
+      !RangeIsRepresentable(patch_data, patch_size) ||
+      !RangeIsRepresentable(new_data, new_size)) {
+    return Error(OTADUMP_ZUCCHINI_INVALID_ARGUMENT, "buffer range wraps");
+  }
+  if (RangesOverlap(new_data, new_size, old_data, old_size) ||
+      RangesOverlap(new_data, new_size, patch_data, patch_size)) {
+    return Error(OTADUMP_ZUCCHINI_INVALID_ARGUMENT,
+                 "output overlaps an input buffer");
+  }
+  if (old_size >= zucchini::kOffsetBound || new_size >= zucchini::kOffsetBound) {
+    return Error(OTADUMP_ZUCCHINI_INVALID_ARGUMENT,
+                 "image exceeds Zucchini offset bound");
+  }
+
+  // BufferView performs pointer arithmetic in its constructor. Normalize
+  // empty null buffers to a valid one-past-capable address.
+  static const uint8_t empty_input = 0;
+  static uint8_t empty_output = 0;
+  old_data = old_data ? old_data : &empty_input;
+  patch_data = patch_data ? patch_data : &empty_input;
+  new_data = new_data ? new_data : &empty_output;
+
+  auto patch = zucchini::EnsemblePatchReader::Create(
+      zucchini::ConstBufferView(patch_data, patch_size));
+  if (!patch) {
+    return Error(OTADUMP_ZUCCHINI_INVALID_PATCH, "invalid ensemble patch");
+  }
+  if (patch->header().new_size != new_size) {
+    return Error(OTADUMP_ZUCCHINI_WRONG_OUTPUT_SIZE,
+                 "output buffer size does not match patch");
+  }
+
+  for (const auto& element : patch->elements()) {
+    const zucchini::ExecutableType exe_type =
+        element.element_match().exe_type();
+    if (exe_type != zucchini::kExeTypeNoOp && !IsAndroidExecutable(exe_type)) {
+      return Error(OTADUMP_ZUCCHINI_UNSUPPORTED_ELEMENT,
+                    "element format is not enabled by Android");
+    }
+  }
+
+  if (!PreflightAndroidElements(
+          zucchini::ConstBufferView(old_data, old_size), *patch,
+          zucchini::MutableBufferView(new_data, new_size))) {
+    return Error(OTADUMP_ZUCCHINI_APPLY_ERROR,
+                 "android executable preflight failed");
+  }
+
+  zucchini::status::Code status = zucchini::ApplyBuffer(
+      zucchini::ConstBufferView(old_data, old_size), *patch,
+      zucchini::MutableBufferView(new_data, new_size));
+  if (status != zucchini::status::kStatusSuccess) {
+    return Error(OTADUMP_ZUCCHINI_APPLY_ERROR, "zucchini apply failed");
+  }
+  return {OTADUMP_ZUCCHINI_OK, nullptr};
+}
diff --git a/native/zucchini/src/zucchini_ffi.h b/native/zucchini/src/zucchini_ffi.h
new file mode 100644
index 0000000..18ec992
--- /dev/null
+++ b/native/zucchini/src/zucchini_ffi.h
@@ -0,0 +1,39 @@
+#ifndef OTADUMP_ZUCCHINI_FFI_H_
+#define OTADUMP_ZUCCHINI_FFI_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum otadump_zucchini_status {
+  OTADUMP_ZUCCHINI_OK = 0,
+  OTADUMP_ZUCCHINI_INVALID_ARGUMENT = 1,
+  OTADUMP_ZUCCHINI_INVALID_PATCH = 2,
+  OTADUMP_ZUCCHINI_UNSUPPORTED_ELEMENT = 3,
+  OTADUMP_ZUCCHINI_WRONG_OUTPUT_SIZE = 4,
+  OTADUMP_ZUCCHINI_APPLY_ERROR = 5,
+};
+
+struct otadump_zucchini_result {
+  int status;
+  const char* error;
+};
+
+// All non-empty buffers must remain valid for the complete call. Input buffers
+// are read-only. The output buffer must not overlap either input buffer.
+struct otadump_zucchini_result otadump_zucchini_apply(
+    const uint8_t* old_data,
+    size_t old_size,
+    const uint8_t* patch_data,
+    size_t patch_size,
+    uint8_t* new_data,
+    size_t new_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // OTADUMP_ZUCCHINI_FFI_H_
diff --git a/native/zucchini/vendor/libchrome/MODULE_LICENSE_BSD b/native/zucchini/vendor/libchrome/MODULE_LICENSE_BSD
new file mode 100644
index 0000000..e69de29
diff --git a/native/zucchini/vendor/libchrome/NOTICE b/native/zucchini/vendor/libchrome/NOTICE
new file mode 100644
index 0000000..972bb2e
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/NOTICE
@@ -0,0 +1,27 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/native/zucchini/vendor/libchrome/base/at_exit.cc b/native/zucchini/vendor/libchrome/base/at_exit.cc
new file mode 100644
index 0000000..52c2151
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/at_exit.cc
@@ -0,0 +1,109 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/at_exit.h"
+
+#include <stddef.h>
+#include <ostream>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/logging.h"
+
+namespace base {
+
+// Keep a stack of registered AtExitManagers.  We always operate on the most
+// recent, and we should never have more than one outside of testing (for a
+// statically linked version of this library).  Testing may use the shadow
+// version of the constructor, and if we are building a dynamic library we may
+// end up with multiple AtExitManagers on the same process.  We don't protect
+// this for thread-safe access, since it will only be modified in testing.
+static AtExitManager* g_top_manager = nullptr;
+
+static bool g_disable_managers = false;
+
+AtExitManager::AtExitManager()
+    : processing_callbacks_(false), next_manager_(g_top_manager) {
+// If multiple modules instantiate AtExitManagers they'll end up living in this
+// module... they have to coexist.
+#if !defined(COMPONENT_BUILD)
+  DCHECK(!g_top_manager);
+#endif
+  g_top_manager = this;
+}
+
+AtExitManager::~AtExitManager() {
+  if (!g_top_manager) {
+    NOTREACHED() << "Tried to ~AtExitManager without an AtExitManager";
+    return;
+  }
+  DCHECK_EQ(this, g_top_manager);
+
+  if (!g_disable_managers)
+    ProcessCallbacksNow();
+  g_top_manager = next_manager_;
+}
+
+// static
+void AtExitManager::RegisterCallback(AtExitCallbackType func, void* param) {
+  DCHECK(func);
+  RegisterTask(base::Bind(func, param));
+}
+
+// static
+void AtExitManager::RegisterTask(base::Closure task) {
+  if (!g_top_manager) {
+    NOTREACHED() << "Tried to RegisterCallback without an AtExitManager";
+    return;
+  }
+
+  AutoLock lock(g_top_manager->lock_);
+  DCHECK(!g_top_manager->processing_callbacks_);
+  g_top_manager->stack_.push(std::move(task));
+}
+
+// static
+void AtExitManager::ProcessCallbacksNow() {
+  if (!g_top_manager) {
+    NOTREACHED() << "Tried to ProcessCallbacksNow without an AtExitManager";
+    return;
+  }
+
+  // Callbacks may try to add new callbacks, so run them without holding
+  // |lock_|. This is an error and caught by the DCHECK in RegisterTask(), but
+  // handle it gracefully in release builds so we don't deadlock.
+  base::stack<base::Closure> tasks;
+  {
+    AutoLock lock(g_top_manager->lock_);
+    tasks.swap(g_top_manager->stack_);
+    g_top_manager->processing_callbacks_ = true;
+  }
+
+  // Relax the cross-thread access restriction to non-thread-safe RefCount.
+  // It's safe since all other threads should be terminated at this point.
+  ScopedAllowCrossThreadRefCountAccess allow_cross_thread_ref_count_access;
+
+  while (!tasks.empty()) {
+    base::Closure task = tasks.top();
+    task.Run();
+    tasks.pop();
+  }
+
+  // Expect that all callbacks have been run.
+  DCHECK(g_top_manager->stack_.empty());
+}
+
+void AtExitManager::DisableAllAtExitManagers() {
+  AutoLock lock(g_top_manager->lock_);
+  g_disable_managers = true;
+}
+
+AtExitManager::AtExitManager(bool shadow)
+    : processing_callbacks_(false), next_manager_(g_top_manager) {
+  DCHECK(shadow || !g_top_manager);
+  g_top_manager = this;
+}
+
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/at_exit.h b/native/zucchini/vendor/libchrome/base/at_exit.h
new file mode 100644
index 0000000..e74de8d
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/at_exit.h
@@ -0,0 +1,80 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_AT_EXIT_H_
+#define BASE_AT_EXIT_H_
+
+#include "base/base_export.h"
+#include "base/callback.h"
+#include "base/containers/stack.h"
+#include "base/macros.h"
+#include "base/synchronization/lock.h"
+
+namespace base {
+
+// This class provides a facility similar to the CRT atexit(), except that
+// we control when the callbacks are executed. Under Windows for a DLL they
+// happen at a really bad time and under the loader lock. This facility is
+// mostly used by base::Singleton.
+//
+// The usage is simple. Early in the main() or WinMain() scope create an
+// AtExitManager object on the stack:
+// int main(...) {
+//    base::AtExitManager exit_manager;
+//
+// }
+// When the exit_manager object goes out of scope, all the registered
+// callbacks and singleton destructors will be called.
+
+class BASE_EXPORT AtExitManager {
+ public:
+  typedef void (*AtExitCallbackType)(void*);
+
+  AtExitManager();
+
+  // The dtor calls all the registered callbacks. Do not try to register more
+  // callbacks after this point.
+  ~AtExitManager();
+
+  // Registers the specified function to be called at exit. The prototype of
+  // the callback function is void func(void*).
+  static void RegisterCallback(AtExitCallbackType func, void* param);
+
+  // Registers the specified task to be called at exit.
+  static void RegisterTask(base::Closure task);
+
+  // Calls the functions registered with RegisterCallback in LIFO order. It
+  // is possible to register new callbacks after calling this function.
+  static void ProcessCallbacksNow();
+
+  // Disable all registered at-exit callbacks. This is used only in a single-
+  // process mode.
+  static void DisableAllAtExitManagers();
+
+ protected:
+  // This constructor will allow this instance of AtExitManager to be created
+  // even if one already exists.  This should only be used for testing!
+  // AtExitManagers are kept on a global stack, and it will be removed during
+  // destruction.  This allows you to shadow another AtExitManager.
+  explicit AtExitManager(bool shadow);
+
+ private:
+  base::Lock lock_;
+  base::stack<base::Closure> stack_;
+  bool processing_callbacks_;
+  AtExitManager* next_manager_;  // Stack of managers to allow shadowing.
+
+  DISALLOW_COPY_AND_ASSIGN(AtExitManager);
+};
+
+#if defined(UNIT_TEST)
+class ShadowingAtExitManager : public AtExitManager {
+ public:
+  ShadowingAtExitManager() : AtExitManager(true) {}
+};
+#endif  // defined(UNIT_TEST)
+
+}  // namespace base
+
+#endif  // BASE_AT_EXIT_H_
diff --git a/native/zucchini/vendor/libchrome/base/atomic_ref_count.h b/native/zucchini/vendor/libchrome/base/atomic_ref_count.h
new file mode 100644
index 0000000..3ffa017
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/atomic_ref_count.h
@@ -0,0 +1,67 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This is a low level implementation of atomic semantics for reference
+// counting.  Please use base/memory/ref_counted.h directly instead.
+
+#ifndef BASE_ATOMIC_REF_COUNT_H_
+#define BASE_ATOMIC_REF_COUNT_H_
+
+#include <atomic>
+
+namespace base {
+
+class AtomicRefCount {
+ public:
+  constexpr AtomicRefCount() : ref_count_(0) {}
+  explicit constexpr AtomicRefCount(int initial_value)
+      : ref_count_(initial_value) {}
+
+  // Increment a reference count.
+  void Increment() { Increment(1); }
+
+  // Increment a reference count by "increment", which must exceed 0.
+  void Increment(int increment) {
+    ref_count_.fetch_add(increment, std::memory_order_relaxed);
+  }
+
+  // Decrement a reference count, and return whether the result is non-zero.
+  // Insert barriers to ensure that state written before the reference count
+  // became zero will be visible to a thread that has just made the count zero.
+  bool Decrement() {
+    // TODO(jbroman): Technically this doesn't need to be an acquire operation
+    // unless the result is 1 (i.e., the ref count did indeed reach zero).
+    // However, there are toolchain issues that make that not work as well at
+    // present (notably TSAN doesn't like it).
+    return ref_count_.fetch_sub(1, std::memory_order_acq_rel) != 1;
+  }
+
+  // Return whether the reference count is one.  If the reference count is used
+  // in the conventional way, a refrerence count of 1 implies that the current
+  // thread owns the reference and no other thread shares it.  This call
+  // performs the test for a reference count of one, and performs the memory
+  // barrier needed for the owning thread to act on the object, knowing that it
+  // has exclusive access to the object.
+  bool IsOne() const { return ref_count_.load(std::memory_order_acquire) == 1; }
+
+  // Return whether the reference count is zero.  With conventional object
+  // referencing counting, the object will be destroyed, so the reference count
+  // should never be zero.  Hence this is generally used for a debug check.
+  bool IsZero() const {
+    return ref_count_.load(std::memory_order_acquire) == 0;
+  }
+
+  // Returns the current reference count (with no barriers). This is subtle, and
+  // should be used only for debugging.
+  int SubtleRefCountForDebug() const {
+    return ref_count_.load(std::memory_order_relaxed);
+  }
+
+ private:
+  std::atomic_int ref_count_;
+};
+
+}  // namespace base
+
+#endif  // BASE_ATOMIC_REF_COUNT_H_
diff --git a/native/zucchini/vendor/libchrome/base/atomic_sequence_num.h b/native/zucchini/vendor/libchrome/base/atomic_sequence_num.h
new file mode 100644
index 0000000..717e37a
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/atomic_sequence_num.h
@@ -0,0 +1,33 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_ATOMIC_SEQUENCE_NUM_H_
+#define BASE_ATOMIC_SEQUENCE_NUM_H_
+
+#include <atomic>
+
+#include "base/macros.h"
+
+namespace base {
+
+// AtomicSequenceNumber is a thread safe increasing sequence number generator.
+// Its constructor doesn't emit a static initializer, so it's safe to use as a
+// global variable or static member.
+class AtomicSequenceNumber {
+ public:
+  constexpr AtomicSequenceNumber() = default;
+
+  // Returns an increasing sequence number starts from 0 for each call.
+  // This function can be called from any thread without data race.
+  inline int GetNext() { return seq_.fetch_add(1, std::memory_order_relaxed); }
+
+ private:
+  std::atomic_int seq_{0};
+
+  DISALLOW_COPY_AND_ASSIGN(AtomicSequenceNumber);
+};
+
+}  // namespace base
+
+#endif  // BASE_ATOMIC_SEQUENCE_NUM_H_
diff --git a/native/zucchini/vendor/libchrome/base/atomicops.h b/native/zucchini/vendor/libchrome/base/atomicops.h
new file mode 100644
index 0000000..4d8510e
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/atomicops.h
@@ -0,0 +1,161 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// For atomic operations on reference counts, see atomic_refcount.h.
+// For atomic operations on sequence numbers, see atomic_sequence_num.h.
+
+// The routines exported by this module are subtle.  If you use them, even if
+// you get the code right, it will depend on careful reasoning about atomicity
+// and memory ordering; it will be less readable, and harder to maintain.  If
+// you plan to use these routines, you should have a good reason, such as solid
+// evidence that performance would otherwise suffer, or there being no
+// alternative.  You should assume only properties explicitly guaranteed by the
+// specifications in this file.  You are almost certainly _not_ writing code
+// just for the x86; if you assume x86 semantics, x86 hardware bugs and
+// implementations on other archtectures will cause your code to break.  If you
+// do not know what you are doing, avoid these routines, and use a Mutex.
+//
+// It is incorrect to make direct assignments to/from an atomic variable.
+// You should use one of the Load or Store routines.  The NoBarrier
+// versions are provided when no barriers are needed:
+//   NoBarrier_Store()
+//   NoBarrier_Load()
+// Although there are currently no compiler enforcement, you are encouraged
+// to use these.
+//
+
+#ifndef BASE_ATOMICOPS_H_
+#define BASE_ATOMICOPS_H_
+
+#include <stdint.h>
+
+// Small C++ header which defines implementation specific macros used to
+// identify the STL implementation.
+// - libc++: captures __config for _LIBCPP_VERSION
+// - libstdc++: captures bits/c++config.h for __GLIBCXX__
+#include <cstddef>
+
+#include "base/base_export.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN) && defined(ARCH_CPU_64_BITS)
+// windows.h #defines this (only on x64). This causes problems because the
+// public API also uses MemoryBarrier at the public name for this fence. So, on
+// X64, undef it, and call its documented
+// (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx)
+// implementation directly.
+#undef MemoryBarrier
+#endif
+
+namespace base {
+namespace subtle {
+
+typedef int32_t Atomic32;
+#ifdef ARCH_CPU_64_BITS
+// We need to be able to go between Atomic64 and AtomicWord implicitly.  This
+// means Atomic64 and AtomicWord should be the same type on 64-bit.
+#if defined(__ILP32__) || defined(OS_NACL)
+// NaCl's intptr_t is not actually 64-bits on 64-bit!
+// http://code.google.com/p/nativeclient/issues/detail?id=1162
+typedef int64_t Atomic64;
+#else
+typedef intptr_t Atomic64;
+#endif
+#endif
+
+// Use AtomicWord for a machine-sized pointer.  It will use the Atomic32 or
+// Atomic64 routines below, depending on your architecture.
+typedef intptr_t AtomicWord;
+
+// Atomically execute:
+//      result = *ptr;
+//      if (*ptr == old_value)
+//        *ptr = new_value;
+//      return result;
+//
+// I.e., replace "*ptr" with "new_value" if "*ptr" used to be "old_value".
+// Always return the old value of "*ptr"
+//
+// This routine implies no memory barriers.
+Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                  Atomic32 old_value,
+                                  Atomic32 new_value);
+
+// Atomically store new_value into *ptr, returning the previous value held in
+// *ptr.  This routine implies no memory barriers.
+Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value);
+
+// Atomically increment *ptr by "increment".  Returns the new value of
+// *ptr with the increment applied.  This routine implies no memory barriers.
+Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);
+
+Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                 Atomic32 increment);
+
+// These following lower-level operations are typically useful only to people
+// implementing higher-level synchronization operations like spinlocks,
+// mutexes, and condition-variables.  They combine CompareAndSwap(), a load, or
+// a store with appropriate memory-ordering instructions.  "Acquire" operations
+// ensure that no later memory access can be reordered ahead of the operation.
+// "Release" operations ensure that no previous memory access can be reordered
+// after the operation.  "Barrier" operations have both "Acquire" and "Release"
+// semantics.   A MemoryBarrier() has "Barrier" semantics, but does no memory
+// access.
+Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                Atomic32 old_value,
+                                Atomic32 new_value);
+Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                Atomic32 old_value,
+                                Atomic32 new_value);
+
+void MemoryBarrier();
+void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value);
+void Acquire_Store(volatile Atomic32* ptr, Atomic32 value);
+void Release_Store(volatile Atomic32* ptr, Atomic32 value);
+
+Atomic32 NoBarrier_Load(volatile const Atomic32* ptr);
+Atomic32 Acquire_Load(volatile const Atomic32* ptr);
+Atomic32 Release_Load(volatile const Atomic32* ptr);
+
+// 64-bit atomic operations (only available on 64-bit processors).
+#ifdef ARCH_CPU_64_BITS
+Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                  Atomic64 old_value,
+                                  Atomic64 new_value);
+Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value);
+Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);
+Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);
+
+Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                Atomic64 old_value,
+                                Atomic64 new_value);
+Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                Atomic64 old_value,
+                                Atomic64 new_value);
+void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value);
+void Acquire_Store(volatile Atomic64* ptr, Atomic64 value);
+void Release_Store(volatile Atomic64* ptr, Atomic64 value);
+Atomic64 NoBarrier_Load(volatile const Atomic64* ptr);
+Atomic64 Acquire_Load(volatile const Atomic64* ptr);
+Atomic64 Release_Load(volatile const Atomic64* ptr);
+#endif  // ARCH_CPU_64_BITS
+
+}  // namespace subtle
+}  // namespace base
+
+#if defined(OS_WIN)
+// TODO(jfb): Try to use base/atomicops_internals_portable.h everywhere.
+// https://crbug.com/559247.
+#  include "base/atomicops_internals_x86_msvc.h"
+#else
+#  include "base/atomicops_internals_portable.h"
+#endif
+
+// On some platforms we need additional declarations to make
+// AtomicWord compatible with our other Atomic* types.
+#if defined(OS_MACOSX) || defined(OS_OPENBSD)
+#include "base/atomicops_internals_atomicword_compat.h"
+#endif
+
+#endif  // BASE_ATOMICOPS_H_
diff --git a/native/zucchini/vendor/libchrome/base/atomicops_internals_portable.h b/native/zucchini/vendor/libchrome/base/atomicops_internals_portable.h
new file mode 100644
index 0000000..ee034de
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/atomicops_internals_portable.h
@@ -0,0 +1,229 @@
+// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+//
+// This implementation uses C++11 atomics' member functions. The code base is
+// currently written assuming atomicity revolves around accesses instead of
+// C++11's memory locations. The burden is on the programmer to ensure that all
+// memory locations accessed atomically are never accessed non-atomically (tsan
+// should help with this).
+//
+// TODO(jfb) Modify the atomicops.h API and user code to declare atomic
+//           locations as truly atomic. See the static_assert below.
+//
+// Of note in this implementation:
+//  * All NoBarrier variants are implemented as relaxed.
+//  * All Barrier variants are implemented as sequentially-consistent.
+//  * Compare exchange's failure ordering is always the same as the success one
+//    (except for release, which fails as relaxed): using a weaker ordering is
+//    only valid under certain uses of compare exchange.
+//  * Acquire store doesn't exist in the C11 memory model, it is instead
+//    implemented as a relaxed store followed by a sequentially consistent
+//    fence.
+//  * Release load doesn't exist in the C11 memory model, it is instead
+//    implemented as sequentially consistent fence followed by a relaxed load.
+//  * Atomic increment is expected to return the post-incremented value, whereas
+//    C11 fetch add returns the previous value. The implementation therefore
+//    needs to increment twice (which the compiler should be able to detect and
+//    optimize).
+
+#ifndef BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
+#define BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
+
+#include <atomic>
+
+#include "build/build_config.h"
+
+namespace base {
+namespace subtle {
+
+// This implementation is transitional and maintains the original API for
+// atomicops.h. This requires casting memory locations to the atomic types, and
+// assumes that the API and the C++11 implementation are layout-compatible,
+// which isn't true for all implementations or hardware platforms. The static
+// assertion should detect this issue, were it to fire then this header
+// shouldn't be used.
+//
+// TODO(jfb) If this header manages to stay committed then the API should be
+//           modified, and all call sites updated.
+typedef volatile std::atomic<Atomic32>* AtomicLocation32;
+static_assert(sizeof(*(AtomicLocation32) nullptr) == sizeof(Atomic32),
+              "incompatible 32-bit atomic layout");
+
+inline void MemoryBarrier() {
+#if defined(__GLIBCXX__)
+  // Work around libstdc++ bug 51038 where atomic_thread_fence was declared but
+  // not defined, leading to the linker complaining about undefined references.
+  __atomic_thread_fence(std::memory_order_seq_cst);
+#else
+  std::atomic_thread_fence(std::memory_order_seq_cst);
+#endif
+}
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  ((AtomicLocation32)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_relaxed,
+                                std::memory_order_relaxed);
+  return old_value;
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+                                         Atomic32 new_value) {
+  return ((AtomicLocation32)ptr)
+      ->exchange(new_value, std::memory_order_relaxed);
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                          Atomic32 increment) {
+  return increment +
+         ((AtomicLocation32)ptr)
+             ->fetch_add(increment, std::memory_order_relaxed);
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                        Atomic32 increment) {
+  return increment + ((AtomicLocation32)ptr)->fetch_add(increment);
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  ((AtomicLocation32)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_acquire,
+                                std::memory_order_acquire);
+  return old_value;
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  ((AtomicLocation32)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_release,
+                                std::memory_order_relaxed);
+  return old_value;
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+  ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed);
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed);
+  MemoryBarrier();
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+  ((AtomicLocation32)ptr)->store(value, std::memory_order_release);
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed);
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+  return ((AtomicLocation32)ptr)->load(std::memory_order_acquire);
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+  MemoryBarrier();
+  return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed);
+}
+
+#if defined(ARCH_CPU_64_BITS)
+
+typedef volatile std::atomic<Atomic64>* AtomicLocation64;
+static_assert(sizeof(*(AtomicLocation64) nullptr) == sizeof(Atomic64),
+              "incompatible 64-bit atomic layout");
+
+inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                         Atomic64 old_value,
+                                         Atomic64 new_value) {
+  ((AtomicLocation64)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_relaxed,
+                                std::memory_order_relaxed);
+  return old_value;
+}
+
+inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
+                                         Atomic64 new_value) {
+  return ((AtomicLocation64)ptr)
+      ->exchange(new_value, std::memory_order_relaxed);
+}
+
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
+                                          Atomic64 increment) {
+  return increment +
+         ((AtomicLocation64)ptr)
+             ->fetch_add(increment, std::memory_order_relaxed);
+}
+
+inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
+                                        Atomic64 increment) {
+  return increment + ((AtomicLocation64)ptr)->fetch_add(increment);
+}
+
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  ((AtomicLocation64)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_acquire,
+                                std::memory_order_acquire);
+  return old_value;
+}
+
+inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  ((AtomicLocation64)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_release,
+                                std::memory_order_relaxed);
+  return old_value;
+}
+
+inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
+  ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed);
+}
+
+inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
+  ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed);
+  MemoryBarrier();
+}
+
+inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
+  ((AtomicLocation64)ptr)->store(value, std::memory_order_release);
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
+  return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed);
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
+  return ((AtomicLocation64)ptr)->load(std::memory_order_acquire);
+}
+
+inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
+  MemoryBarrier();
+  return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed);
+}
+
+#endif  // defined(ARCH_CPU_64_BITS)
+}  // namespace subtle
+}  // namespace base
+
+#endif  // BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/base_export.h b/native/zucchini/vendor/libchrome/base/base_export.h
new file mode 100644
index 0000000..cf7ebd7
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/base_export.h
@@ -0,0 +1,29 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_BASE_EXPORT_H_
+#define BASE_BASE_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(BASE_IMPLEMENTATION)
+#define BASE_EXPORT __declspec(dllexport)
+#else
+#define BASE_EXPORT __declspec(dllimport)
+#endif  // defined(BASE_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(BASE_IMPLEMENTATION)
+#define BASE_EXPORT __attribute__((visibility("default")))
+#else
+#define BASE_EXPORT
+#endif  // defined(BASE_IMPLEMENTATION)
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define BASE_EXPORT
+#endif
+
+#endif  // BASE_BASE_EXPORT_H_
diff --git a/native/zucchini/vendor/libchrome/base/base_switches.h b/native/zucchini/vendor/libchrome/base/base_switches.h
new file mode 100644
index 0000000..4ef070d
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/base_switches.h
@@ -0,0 +1,51 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Defines all the "base" command-line switches.
+
+#ifndef BASE_BASE_SWITCHES_H_
+#define BASE_BASE_SWITCHES_H_
+
+#include "build/build_config.h"
+
+namespace switches {
+
+extern const char kDisableBackgroundTasks[];
+extern const char kDisableBreakpad[];
+extern const char kDisableFeatures[];
+extern const char kDisableLowEndDeviceMode[];
+extern const char kEnableCrashReporter[];
+extern const char kEnableFeatures[];
+extern const char kEnableLowEndDeviceMode[];
+extern const char kForceFieldTrials[];
+extern const char kFullMemoryCrashReport[];
+extern const char kNoErrorDialogs[];
+extern const char kProfilingFile[];
+extern const char kTestChildProcess[];
+extern const char kTestDoNotInitializeIcu[];
+extern const char kTraceToFile[];
+extern const char kTraceToFileName[];
+extern const char kV[];
+extern const char kVModule[];
+extern const char kWaitForDebugger[];
+
+#if defined(OS_WIN)
+extern const char kDisableUsbKeyboardDetect[];
+#endif
+
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+extern const char kDisableDevShmUsage[];
+#endif
+
+#if defined(OS_POSIX)
+extern const char kEnableCrashReporterForTesting[];
+#endif
+
+#if defined(OS_ANDROID)
+extern const char kOrderfileMemoryOptimization[];
+#endif
+
+}  // namespace switches
+
+#endif  // BASE_BASE_SWITCHES_H_
diff --git a/native/zucchini/vendor/libchrome/base/bind.h b/native/zucchini/vendor/libchrome/base/bind.h
new file mode 100644
index 0000000..66d5d82
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/bind.h
@@ -0,0 +1,482 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_BIND_H_
+#define BASE_BIND_H_
+
+#include <utility>
+
+#include "base/bind_internal.h"
+#include "base/compiler_specific.h"
+#include "build/build_config.h"
+
+#if defined(OS_MACOSX) && !HAS_FEATURE(objc_arc)
+#include "base/mac/scoped_block.h"
+#endif
+
+// -----------------------------------------------------------------------------
+// Usage documentation
+// -----------------------------------------------------------------------------
+//
+// Overview:
+// base::BindOnce() and base::BindRepeating() are helpers for creating
+// base::OnceCallback and base::RepeatingCallback objects respectively.
+//
+// For a runnable object of n-arity, the base::Bind*() family allows partial
+// application of the first m arguments. The remaining n - m arguments must be
+// passed when invoking the callback with Run().
+//
+//   // The first argument is bound at callback creation; the remaining
+//   // two must be passed when calling Run() on the callback object.
+//   base::OnceCallback<void(int, long)> cb = base::BindOnce(
+//       [](short x, int y, long z) { return x * y * z; }, 42);
+//
+// When binding to a method, the receiver object must also be specified at
+// callback creation time. When Run() is invoked, the method will be invoked on
+// the specified receiver object.
+//
+//   class C : public base::RefCounted<C> { void F(); };
+//   auto instance = base::MakeRefCounted<C>();
+//   auto cb = base::BindOnce(&C::F, instance);
+//   cb.Run();  // Identical to instance->F()
+//
+// base::Bind is currently a type alias for base::BindRepeating(). In the
+// future, we expect to flip this to default to base::BindOnce().
+//
+// See //docs/callback.md for the full documentation.
+//
+// -----------------------------------------------------------------------------
+// Implementation notes
+// -----------------------------------------------------------------------------
+//
+// If you're reading the implementation, before proceeding further, you should
+// read the top comment of base/bind_internal.h for a definition of common
+// terms and concepts.
+
+namespace base {
+
+namespace internal {
+
+// IsOnceCallback<T> is a std::true_type if |T| is a OnceCallback.
+template <typename T>
+struct IsOnceCallback : std::false_type {};
+
+template <typename Signature>
+struct IsOnceCallback<OnceCallback<Signature>> : std::true_type {};
+
+// Helper to assert that parameter |i| of type |Arg| can be bound, which means:
+// - |Arg| can be retained internally as |Storage|.
+// - |Arg| can be forwarded as |Unwrapped| to |Param|.
+template <size_t i,
+          typename Arg,
+          typename Storage,
+          typename Unwrapped,
+          typename Param>
+struct AssertConstructible {
+ private:
+  static constexpr bool param_is_forwardable =
+      std::is_constructible<Param, Unwrapped>::value;
+  // Unlike the check for binding into storage below, the check for
+  // forwardability drops the const qualifier for repeating callbacks. This is
+  // to try to catch instances where std::move()--which forwards as a const
+  // reference with repeating callbacks--is used instead of base::Passed().
+  static_assert(
+      param_is_forwardable ||
+          !std::is_constructible<Param, std::decay_t<Unwrapped>&&>::value,
+      "Bound argument |i| is move-only but will be forwarded by copy. "
+      "Ensure |Arg| is bound using base::Passed(), not std::move().");
+  static_assert(
+      param_is_forwardable,
+      "Bound argument |i| of type |Arg| cannot be forwarded as "
+      "|Unwrapped| to the bound functor, which declares it as |Param|.");
+
+  static constexpr bool arg_is_storable =
+      std::is_constructible<Storage, Arg>::value;
+  static_assert(arg_is_storable ||
+                    !std::is_constructible<Storage, std::decay_t<Arg>&&>::value,
+                "Bound argument |i| is move-only but will be bound by copy. "
+                "Ensure |Arg| is mutable and bound using std::move().");
+  static_assert(arg_is_storable,
+                "Bound argument |i| of type |Arg| cannot be converted and "
+                "bound as |Storage|.");
+};
+
+// Takes three same-length TypeLists, and applies AssertConstructible for each
+// triples.
+template <typename Index,
+          typename Args,
+          typename UnwrappedTypeList,
+          typename ParamsList>
+struct AssertBindArgsValidity;
+
+template <size_t... Ns,
+          typename... Args,
+          typename... Unwrapped,
+          typename... Params>
+struct AssertBindArgsValidity<std::index_sequence<Ns...>,
+                              TypeList<Args...>,
+                              TypeList<Unwrapped...>,
+                              TypeList<Params...>>
+    : AssertConstructible<Ns, Args, std::decay_t<Args>, Unwrapped, Params>... {
+  static constexpr bool ok = true;
+};
+
+// The implementation of TransformToUnwrappedType below.
+template <bool is_once, typename T>
+struct TransformToUnwrappedTypeImpl;
+
+template <typename T>
+struct TransformToUnwrappedTypeImpl<true, T> {
+  using StoredType = std::decay_t<T>;
+  using ForwardType = StoredType&&;
+  using Unwrapped = decltype(Unwrap(std::declval<ForwardType>()));
+};
+
+template <typename T>
+struct TransformToUnwrappedTypeImpl<false, T> {
+  using StoredType = std::decay_t<T>;
+  using ForwardType = const StoredType&;
+  using Unwrapped = decltype(Unwrap(std::declval<ForwardType>()));
+};
+
+// Transform |T| into `Unwrapped` type, which is passed to the target function.
+// Example:
+//   In is_once == true case,
+//     `int&&` -> `int&&`,
+//     `const int&` -> `int&&`,
+//     `OwnedWrapper<int>&` -> `int*&&`.
+//   In is_once == false case,
+//     `int&&` -> `const int&`,
+//     `const int&` -> `const int&`,
+//     `OwnedWrapper<int>&` -> `int* const &`.
+template <bool is_once, typename T>
+using TransformToUnwrappedType =
+    typename TransformToUnwrappedTypeImpl<is_once, T>::Unwrapped;
+
+// Transforms |Args| into `Unwrapped` types, and packs them into a TypeList.
+// If |is_method| is true, tries to dereference the first argument to support
+// smart pointers.
+template <bool is_once, bool is_method, typename... Args>
+struct MakeUnwrappedTypeListImpl {
+  using Type = TypeList<TransformToUnwrappedType<is_once, Args>...>;
+};
+
+// Performs special handling for this pointers.
+// Example:
+//   int* -> int*,
+//   std::unique_ptr<int> -> int*.
+template <bool is_once, typename Receiver, typename... Args>
+struct MakeUnwrappedTypeListImpl<is_once, true, Receiver, Args...> {
+  using UnwrappedReceiver = TransformToUnwrappedType<is_once, Receiver>;
+  using Type = TypeList<decltype(&*std::declval<UnwrappedReceiver>()),
+                        TransformToUnwrappedType<is_once, Args>...>;
+};
+
+template <bool is_once, bool is_method, typename... Args>
+using MakeUnwrappedTypeList =
+    typename MakeUnwrappedTypeListImpl<is_once, is_method, Args...>::Type;
+
+}  // namespace internal
+
+// Bind as OnceCallback.
+template <typename Functor, typename... Args>
+inline OnceCallback<MakeUnboundRunType<Functor, Args...>>
+BindOnce(Functor&& functor, Args&&... args) {
+  static_assert(!internal::IsOnceCallback<std::decay_t<Functor>>() ||
+                    (std::is_rvalue_reference<Functor&&>() &&
+                     !std::is_const<std::remove_reference_t<Functor>>()),
+                "BindOnce requires non-const rvalue for OnceCallback binding."
+                " I.e.: base::BindOnce(std::move(callback)).");
+
+  // This block checks if each |args| matches to the corresponding params of the
+  // target function. This check does not affect the behavior of Bind, but its
+  // error message should be more readable.
+  using Helper = internal::BindTypeHelper<Functor, Args...>;
+  using FunctorTraits = typename Helper::FunctorTraits;
+  using BoundArgsList = typename Helper::BoundArgsList;
+  using UnwrappedArgsList =
+      internal::MakeUnwrappedTypeList<true, FunctorTraits::is_method,
+                                      Args&&...>;
+  using BoundParamsList = typename Helper::BoundParamsList;
+  static_assert(internal::AssertBindArgsValidity<
+                    std::make_index_sequence<Helper::num_bounds>, BoundArgsList,
+                    UnwrappedArgsList, BoundParamsList>::ok,
+                "The bound args need to be convertible to the target params.");
+
+  using BindState = internal::MakeBindStateType<Functor, Args...>;
+  using UnboundRunType = MakeUnboundRunType<Functor, Args...>;
+  using Invoker = internal::Invoker<BindState, UnboundRunType>;
+  using CallbackType = OnceCallback<UnboundRunType>;
+
+  // Store the invoke func into PolymorphicInvoke before casting it to
+  // InvokeFuncStorage, so that we can ensure its type matches to
+  // PolymorphicInvoke, to which CallbackType will cast back.
+  using PolymorphicInvoke = typename CallbackType::PolymorphicInvoke;
+  PolymorphicInvoke invoke_func = &Invoker::RunOnce;
+
+  using InvokeFuncStorage = internal::BindStateBase::InvokeFuncStorage;
+  return CallbackType(new BindState(
+      reinterpret_cast<InvokeFuncStorage>(invoke_func),
+      std::forward<Functor>(functor),
+      std::forward<Args>(args)...));
+}
+
+// Bind as RepeatingCallback.
+template <typename Functor, typename... Args>
+inline RepeatingCallback<MakeUnboundRunType<Functor, Args...>>
+BindRepeating(Functor&& functor, Args&&... args) {
+  static_assert(
+      !internal::IsOnceCallback<std::decay_t<Functor>>(),
+      "BindRepeating cannot bind OnceCallback. Use BindOnce with std::move().");
+
+  // This block checks if each |args| matches to the corresponding params of the
+  // target function. This check does not affect the behavior of Bind, but its
+  // error message should be more readable.
+  using Helper = internal::BindTypeHelper<Functor, Args...>;
+  using FunctorTraits = typename Helper::FunctorTraits;
+  using BoundArgsList = typename Helper::BoundArgsList;
+  using UnwrappedArgsList =
+      internal::MakeUnwrappedTypeList<false, FunctorTraits::is_method,
+                                      Args&&...>;
+  using BoundParamsList = typename Helper::BoundParamsList;
+  static_assert(internal::AssertBindArgsValidity<
+                    std::make_index_sequence<Helper::num_bounds>, BoundArgsList,
+                    UnwrappedArgsList, BoundParamsList>::ok,
+                "The bound args need to be convertible to the target params.");
+
+  using BindState = internal::MakeBindStateType<Functor, Args...>;
+  using UnboundRunType = MakeUnboundRunType<Functor, Args...>;
+  using Invoker = internal::Invoker<BindState, UnboundRunType>;
+  using CallbackType = RepeatingCallback<UnboundRunType>;
+
+  // Store the invoke func into PolymorphicInvoke before casting it to
+  // InvokeFuncStorage, so that we can ensure its type matches to
+  // PolymorphicInvoke, to which CallbackType will cast back.
+  using PolymorphicInvoke = typename CallbackType::PolymorphicInvoke;
+  PolymorphicInvoke invoke_func = &Invoker::Run;
+
+  using InvokeFuncStorage = internal::BindStateBase::InvokeFuncStorage;
+  return CallbackType(new BindState(
+      reinterpret_cast<InvokeFuncStorage>(invoke_func),
+      std::forward<Functor>(functor),
+      std::forward<Args>(args)...));
+}
+
+// Unannotated Bind.
+// TODO(tzik): Deprecate this and migrate to OnceCallback and
+// RepeatingCallback, once they get ready.
+template <typename Functor, typename... Args>
+inline Callback<MakeUnboundRunType<Functor, Args...>>
+Bind(Functor&& functor, Args&&... args) {
+  return base::BindRepeating(std::forward<Functor>(functor),
+                             std::forward<Args>(args)...);
+}
+
+// Special cases for binding to a base::Callback without extra bound arguments.
+template <typename Signature>
+OnceCallback<Signature> BindOnce(OnceCallback<Signature> closure) {
+  return closure;
+}
+
+template <typename Signature>
+RepeatingCallback<Signature> BindRepeating(
+    RepeatingCallback<Signature> closure) {
+  return closure;
+}
+
+template <typename Signature>
+Callback<Signature> Bind(Callback<Signature> closure) {
+  return closure;
+}
+
+// Unretained() allows Bind() to bind a non-refcounted class, and to disable
+// refcounting on arguments that are refcounted objects.
+//
+// EXAMPLE OF Unretained():
+//
+//   class Foo {
+//    public:
+//     void func() { cout << "Foo:f" << endl; }
+//   };
+//
+//   // In some function somewhere.
+//   Foo foo;
+//   Closure foo_callback =
+//       Bind(&Foo::func, Unretained(&foo));
+//   foo_callback.Run();  // Prints "Foo:f".
+//
+// Without the Unretained() wrapper on |&foo|, the above call would fail
+// to compile because Foo does not support the AddRef() and Release() methods.
+template <typename T>
+static inline internal::UnretainedWrapper<T> Unretained(T* o) {
+  return internal::UnretainedWrapper<T>(o);
+}
+
+// RetainedRef() accepts a ref counted object and retains a reference to it.
+// When the callback is called, the object is passed as a raw pointer.
+//
+// EXAMPLE OF RetainedRef():
+//
+//    void foo(RefCountedBytes* bytes) {}
+//
+//    scoped_refptr<RefCountedBytes> bytes = ...;
+//    Closure callback = Bind(&foo, base::RetainedRef(bytes));
+//    callback.Run();
+//
+// Without RetainedRef, the scoped_refptr would try to implicitly convert to
+// a raw pointer and fail compilation:
+//
+//    Closure callback = Bind(&foo, bytes); // ERROR!
+template <typename T>
+static inline internal::RetainedRefWrapper<T> RetainedRef(T* o) {
+  return internal::RetainedRefWrapper<T>(o);
+}
+template <typename T>
+static inline internal::RetainedRefWrapper<T> RetainedRef(scoped_refptr<T> o) {
+  return internal::RetainedRefWrapper<T>(std::move(o));
+}
+
+// ConstRef() allows binding a constant reference to an argument rather
+// than a copy.
+//
+// EXAMPLE OF ConstRef():
+//
+//   void foo(int arg) { cout << arg << endl }
+//
+//   int n = 1;
+//   Closure no_ref = Bind(&foo, n);
+//   Closure has_ref = Bind(&foo, ConstRef(n));
+//
+//   no_ref.Run();  // Prints "1"
+//   has_ref.Run();  // Prints "1"
+//
+//   n = 2;
+//   no_ref.Run();  // Prints "1"
+//   has_ref.Run();  // Prints "2"
+//
+// Note that because ConstRef() takes a reference on |n|, |n| must outlive all
+// its bound callbacks.
+template <typename T>
+static inline internal::ConstRefWrapper<T> ConstRef(const T& o) {
+  return internal::ConstRefWrapper<T>(o);
+}
+
+// Owned() transfers ownership of an object to the Callback resulting from
+// bind; the object will be deleted when the Callback is deleted.
+//
+// EXAMPLE OF Owned():
+//
+//   void foo(int* arg) { cout << *arg << endl }
+//
+//   int* pn = new int(1);
+//   Closure foo_callback = Bind(&foo, Owned(pn));
+//
+//   foo_callback.Run();  // Prints "1"
+//   foo_callback.Run();  // Prints "1"
+//   *n = 2;
+//   foo_callback.Run();  // Prints "2"
+//
+//   foo_callback.Reset();  // |pn| is deleted.  Also will happen when
+//                          // |foo_callback| goes out of scope.
+//
+// Without Owned(), someone would have to know to delete |pn| when the last
+// reference to the Callback is deleted.
+template <typename T>
+static inline internal::OwnedWrapper<T> Owned(T* o) {
+  return internal::OwnedWrapper<T>(o);
+}
+
+// Passed() is for transferring movable-but-not-copyable types (eg. unique_ptr)
+// through a Callback. Logically, this signifies a destructive transfer of
+// the state of the argument into the target function.  Invoking
+// Callback::Run() twice on a Callback that was created with a Passed()
+// argument will CHECK() because the first invocation would have already
+// transferred ownership to the target function.
+//
+// Note that Passed() is not necessary with BindOnce(), as std::move() does the
+// same thing. Avoid Passed() in favor of std::move() with BindOnce().
+//
+// EXAMPLE OF Passed():
+//
+//   void TakesOwnership(std::unique_ptr<Foo> arg) { }
+//   std::unique_ptr<Foo> CreateFoo() { return std::make_unique<Foo>();
+//   }
+//
+//   auto f = std::make_unique<Foo>();
+//
+//   // |cb| is given ownership of Foo(). |f| is now NULL.
+//   // You can use std::move(f) in place of &f, but it's more verbose.
+//   Closure cb = Bind(&TakesOwnership, Passed(&f));
+//
+//   // Run was never called so |cb| still owns Foo() and deletes
+//   // it on Reset().
+//   cb.Reset();
+//
+//   // |cb| is given a new Foo created by CreateFoo().
+//   cb = Bind(&TakesOwnership, Passed(CreateFoo()));
+//
+//   // |arg| in TakesOwnership() is given ownership of Foo(). |cb|
+//   // no longer owns Foo() and, if reset, would not delete Foo().
+//   cb.Run();  // Foo() is now transferred to |arg| and deleted.
+//   cb.Run();  // This CHECK()s since Foo() already been used once.
+//
+// We offer 2 syntaxes for calling Passed().  The first takes an rvalue and
+// is best suited for use with the return value of a function or other temporary
+// rvalues. The second takes a pointer to the scoper and is just syntactic sugar
+// to avoid having to write Passed(std::move(scoper)).
+//
+// Both versions of Passed() prevent T from being an lvalue reference. The first
+// via use of enable_if, and the second takes a T* which will not bind to T&.
+template <typename T,
+          std::enable_if_t<!std::is_lvalue_reference<T>::value>* = nullptr>
+static inline internal::PassedWrapper<T> Passed(T&& scoper) {
+  return internal::PassedWrapper<T>(std::move(scoper));
+}
+template <typename T>
+static inline internal::PassedWrapper<T> Passed(T* scoper) {
+  return internal::PassedWrapper<T>(std::move(*scoper));
+}
+
+// IgnoreResult() is used to adapt a function or Callback with a return type to
+// one with a void return. This is most useful if you have a function with,
+// say, a pesky ignorable bool return that you want to use with PostTask or
+// something else that expect a Callback with a void return.
+//
+// EXAMPLE OF IgnoreResult():
+//
+//   int DoSomething(int arg) { cout << arg << endl; }
+//
+//   // Assign to a Callback with a void return type.
+//   Callback<void(int)> cb = Bind(IgnoreResult(&DoSomething));
+//   cb->Run(1);  // Prints "1".
+//
+//   // Prints "1" on |ml|.
+//   ml->PostTask(FROM_HERE, Bind(IgnoreResult(&DoSomething), 1);
+template <typename T>
+static inline internal::IgnoreResultHelper<T> IgnoreResult(T data) {
+  return internal::IgnoreResultHelper<T>(std::move(data));
+}
+
+#if defined(OS_MACOSX) && !HAS_FEATURE(objc_arc)
+
+// RetainBlock() is used to adapt an Objective-C block when Automated Reference
+// Counting (ARC) is disabled. This is unnecessary when ARC is enabled, as the
+// BindOnce and BindRepeating already support blocks then.
+//
+// EXAMPLE OF RetainBlock():
+//
+//   // Wrap the block and bind it to a callback.
+//   Callback<void(int)> cb = Bind(RetainBlock(^(int n) { NSLog(@"%d", n); }));
+//   cb.Run(1);  // Logs "1".
+template <typename R, typename... Args>
+base::mac::ScopedBlock<R (^)(Args...)> RetainBlock(R (^block)(Args...)) {
+  return base::mac::ScopedBlock<R (^)(Args...)>(block,
+                                                base::scoped_policy::RETAIN);
+}
+
+#endif  // defined(OS_MACOSX) && !HAS_FEATURE(objc_arc)
+
+}  // namespace base
+
+#endif  // BASE_BIND_H_
diff --git a/native/zucchini/vendor/libchrome/base/bind_internal.h b/native/zucchini/vendor/libchrome/base/bind_internal.h
new file mode 100644
index 0000000..4ebecfa
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/bind_internal.h
@@ -0,0 +1,971 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_BIND_INTERNAL_H_
+#define BASE_BIND_INTERNAL_H_
+
+#include <stddef.h>
+
+#include <type_traits>
+#include <utility>
+
+#include "base/callback_internal.h"
+#include "base/compiler_specific.h"
+#include "base/memory/raw_scoped_refptr_mismatch_checker.h"
+#include "base/memory/weak_ptr.h"
+#include "base/template_util.h"
+#include "build/build_config.h"
+
+#if defined(OS_MACOSX) && !HAS_FEATURE(objc_arc)
+#include "base/mac/scoped_block.h"
+#endif
+
+// See base/callback.h for user documentation.
+//
+//
+// CONCEPTS:
+//  Functor -- A movable type representing something that should be called.
+//             All function pointers and Callback<> are functors even if the
+//             invocation syntax differs.
+//  RunType -- A function type (as opposed to function _pointer_ type) for
+//             a Callback<>::Run().  Usually just a convenience typedef.
+//  (Bound)Args -- A set of types that stores the arguments.
+//
+// Types:
+//  ForceVoidReturn<> -- Helper class for translating function signatures to
+//                       equivalent forms with a "void" return type.
+//  FunctorTraits<> -- Type traits used to determine the correct RunType and
+//                     invocation manner for a Functor.  This is where function
+//                     signature adapters are applied.
+//  InvokeHelper<> -- Take a Functor + arguments and actully invokes it.
+//                    Handle the differing syntaxes needed for WeakPtr<>
+//                    support.  This is separate from Invoker to avoid creating
+//                    multiple version of Invoker<>.
+//  Invoker<> -- Unwraps the curried parameters and executes the Functor.
+//  BindState<> -- Stores the curried parameters, and is the main entry point
+//                 into the Bind() system.
+
+namespace base {
+
+template <typename T>
+struct IsWeakReceiver;
+
+template <typename>
+struct BindUnwrapTraits;
+
+template <typename Functor, typename BoundArgsTuple, typename SFINAE = void>
+struct CallbackCancellationTraits;
+
+namespace internal {
+
+template <typename Functor, typename SFINAE = void>
+struct FunctorTraits;
+
+template <typename T>
+class UnretainedWrapper {
+ public:
+  explicit UnretainedWrapper(T* o) : ptr_(o) {}
+  T* get() const { return ptr_; }
+
+ private:
+  T* ptr_;
+};
+
+template <typename T>
+class ConstRefWrapper {
+ public:
+  explicit ConstRefWrapper(const T& o) : ptr_(&o) {}
+  const T& get() const { return *ptr_; }
+
+ private:
+  const T* ptr_;
+};
+
+template <typename T>
+class RetainedRefWrapper {
+ public:
+  explicit RetainedRefWrapper(T* o) : ptr_(o) {}
+  explicit RetainedRefWrapper(scoped_refptr<T> o) : ptr_(std::move(o)) {}
+  T* get() const { return ptr_.get(); }
+
+ private:
+  scoped_refptr<T> ptr_;
+};
+
+template <typename T>
+struct IgnoreResultHelper {
+  explicit IgnoreResultHelper(T functor) : functor_(std::move(functor)) {}
+  explicit operator bool() const { return !!functor_; }
+
+  T functor_;
+};
+
+// An alternate implementation is to avoid the destructive copy, and instead
+// specialize ParamTraits<> for OwnedWrapper<> to change the StorageType to
+// a class that is essentially a std::unique_ptr<>.
+//
+// The current implementation has the benefit though of leaving ParamTraits<>
+// fully in callback_internal.h as well as avoiding type conversions during
+// storage.
+template <typename T>
+class OwnedWrapper {
+ public:
+  explicit OwnedWrapper(T* o) : ptr_(o) {}
+  ~OwnedWrapper() { delete ptr_; }
+  T* get() const { return ptr_; }
+  OwnedWrapper(OwnedWrapper&& other) {
+    ptr_ = other.ptr_;
+    other.ptr_ = NULL;
+  }
+
+ private:
+  mutable T* ptr_;
+};
+
+// PassedWrapper is a copyable adapter for a scoper that ignores const.
+//
+// It is needed to get around the fact that Bind() takes a const reference to
+// all its arguments.  Because Bind() takes a const reference to avoid
+// unnecessary copies, it is incompatible with movable-but-not-copyable
+// types; doing a destructive "move" of the type into Bind() would violate
+// the const correctness.
+//
+// This conundrum cannot be solved without either C++11 rvalue references or
+// a O(2^n) blowup of Bind() templates to handle each combination of regular
+// types and movable-but-not-copyable types.  Thus we introduce a wrapper type
+// that is copyable to transmit the correct type information down into
+// BindState<>. Ignoring const in this type makes sense because it is only
+// created when we are explicitly trying to do a destructive move.
+//
+// Two notes:
+//  1) PassedWrapper supports any type that has a move constructor, however
+//     the type will need to be specifically whitelisted in order for it to be
+//     bound to a Callback. We guard this explicitly at the call of Passed()
+//     to make for clear errors. Things not given to Passed() will be forwarded
+//     and stored by value which will not work for general move-only types.
+//  2) is_valid_ is distinct from NULL because it is valid to bind a "NULL"
+//     scoper to a Callback and allow the Callback to execute once.
+template <typename T>
+class PassedWrapper {
+ public:
+  explicit PassedWrapper(T&& scoper)
+      : is_valid_(true), scoper_(std::move(scoper)) {}
+  PassedWrapper(PassedWrapper&& other)
+      : is_valid_(other.is_valid_), scoper_(std::move(other.scoper_)) {}
+  T Take() const {
+    CHECK(is_valid_);
+    is_valid_ = false;
+    return std::move(scoper_);
+  }
+
+ private:
+  mutable bool is_valid_;
+  mutable T scoper_;
+};
+
+template <typename T>
+using Unwrapper = BindUnwrapTraits<std::decay_t<T>>;
+
+template <typename T>
+decltype(auto) Unwrap(T&& o) {
+  return Unwrapper<T>::Unwrap(std::forward<T>(o));
+}
+
+// IsWeakMethod is a helper that determine if we are binding a WeakPtr<> to a
+// method.  It is used internally by Bind() to select the correct
+// InvokeHelper that will no-op itself in the event the WeakPtr<> for
+// the target object is invalidated.
+//
+// The first argument should be the type of the object that will be received by
+// the method.
+template <bool is_method, typename... Args>
+struct IsWeakMethod : std::false_type {};
+
+template <typename T, typename... Args>
+struct IsWeakMethod<true, T, Args...> : IsWeakReceiver<T> {};
+
+// Packs a list of types to hold them in a single type.
+template <typename... Types>
+struct TypeList {};
+
+// Used for DropTypeListItem implementation.
+template <size_t n, typename List>
+struct DropTypeListItemImpl;
+
+// Do not use enable_if and SFINAE here to avoid MSVC2013 compile failure.
+template <size_t n, typename T, typename... List>
+struct DropTypeListItemImpl<n, TypeList<T, List...>>
+    : DropTypeListItemImpl<n - 1, TypeList<List...>> {};
+
+template <typename T, typename... List>
+struct DropTypeListItemImpl<0, TypeList<T, List...>> {
+  using Type = TypeList<T, List...>;
+};
+
+template <>
+struct DropTypeListItemImpl<0, TypeList<>> {
+  using Type = TypeList<>;
+};
+
+// A type-level function that drops |n| list item from given TypeList.
+template <size_t n, typename List>
+using DropTypeListItem = typename DropTypeListItemImpl<n, List>::Type;
+
+// Used for TakeTypeListItem implementation.
+template <size_t n, typename List, typename... Accum>
+struct TakeTypeListItemImpl;
+
+// Do not use enable_if and SFINAE here to avoid MSVC2013 compile failure.
+template <size_t n, typename T, typename... List, typename... Accum>
+struct TakeTypeListItemImpl<n, TypeList<T, List...>, Accum...>
+    : TakeTypeListItemImpl<n - 1, TypeList<List...>, Accum..., T> {};
+
+template <typename T, typename... List, typename... Accum>
+struct TakeTypeListItemImpl<0, TypeList<T, List...>, Accum...> {
+  using Type = TypeList<Accum...>;
+};
+
+template <typename... Accum>
+struct TakeTypeListItemImpl<0, TypeList<>, Accum...> {
+  using Type = TypeList<Accum...>;
+};
+
+// A type-level function that takes first |n| list item from given TypeList.
+// E.g. TakeTypeListItem<3, TypeList<A, B, C, D>> is evaluated to
+// TypeList<A, B, C>.
+template <size_t n, typename List>
+using TakeTypeListItem = typename TakeTypeListItemImpl<n, List>::Type;
+
+// Used for ConcatTypeLists implementation.
+template <typename List1, typename List2>
+struct ConcatTypeListsImpl;
+
+template <typename... Types1, typename... Types2>
+struct ConcatTypeListsImpl<TypeList<Types1...>, TypeList<Types2...>> {
+  using Type = TypeList<Types1..., Types2...>;
+};
+
+// A type-level function that concats two TypeLists.
+template <typename List1, typename List2>
+using ConcatTypeLists = typename ConcatTypeListsImpl<List1, List2>::Type;
+
+// Used for MakeFunctionType implementation.
+template <typename R, typename ArgList>
+struct MakeFunctionTypeImpl;
+
+template <typename R, typename... Args>
+struct MakeFunctionTypeImpl<R, TypeList<Args...>> {
+  // MSVC 2013 doesn't support Type Alias of function types.
+  // Revisit this after we update it to newer version.
+  typedef R Type(Args...);
+};
+
+// A type-level function that constructs a function type that has |R| as its
+// return type and has TypeLists items as its arguments.
+template <typename R, typename ArgList>
+using MakeFunctionType = typename MakeFunctionTypeImpl<R, ArgList>::Type;
+
+// Used for ExtractArgs and ExtractReturnType.
+template <typename Signature>
+struct ExtractArgsImpl;
+
+template <typename R, typename... Args>
+struct ExtractArgsImpl<R(Args...)> {
+  using ReturnType = R;
+  using ArgsList = TypeList<Args...>;
+};
+
+// A type-level function that extracts function arguments into a TypeList.
+// E.g. ExtractArgs<R(A, B, C)> is evaluated to TypeList<A, B, C>.
+template <typename Signature>
+using ExtractArgs = typename ExtractArgsImpl<Signature>::ArgsList;
+
+// A type-level function that extracts the return type of a function.
+// E.g. ExtractReturnType<R(A, B, C)> is evaluated to R.
+template <typename Signature>
+using ExtractReturnType = typename ExtractArgsImpl<Signature>::ReturnType;
+
+template <typename Callable,
+          typename Signature = decltype(&Callable::operator())>
+struct ExtractCallableRunTypeImpl;
+
+template <typename Callable, typename R, typename... Args>
+struct ExtractCallableRunTypeImpl<Callable, R (Callable::*)(Args...)> {
+  using Type = R(Args...);
+};
+
+template <typename Callable, typename R, typename... Args>
+struct ExtractCallableRunTypeImpl<Callable, R (Callable::*)(Args...) const> {
+  using Type = R(Args...);
+};
+
+// Evaluated to RunType of the given callable type.
+// Example:
+//   auto f = [](int, char*) { return 0.1; };
+//   ExtractCallableRunType<decltype(f)>
+//   is evaluated to
+//   double(int, char*);
+template <typename Callable>
+using ExtractCallableRunType =
+    typename ExtractCallableRunTypeImpl<Callable>::Type;
+
+// IsCallableObject<Functor> is std::true_type if |Functor| has operator().
+// Otherwise, it's std::false_type.
+// Example:
+//   IsCallableObject<void(*)()>::value is false.
+//
+//   struct Foo {};
+//   IsCallableObject<void(Foo::*)()>::value is false.
+//
+//   int i = 0;
+//   auto f = [i]() {};
+//   IsCallableObject<decltype(f)>::value is false.
+template <typename Functor, typename SFINAE = void>
+struct IsCallableObject : std::false_type {};
+
+template <typename Callable>
+struct IsCallableObject<Callable, void_t<decltype(&Callable::operator())>>
+    : std::true_type {};
+
+// HasRefCountedTypeAsRawPtr selects true_type when any of the |Args| is a raw
+// pointer to a RefCounted type.
+// Implementation note: This non-specialized case handles zero-arity case only.
+// Non-zero-arity cases should be handled by the specialization below.
+template <typename... Args>
+struct HasRefCountedTypeAsRawPtr : std::false_type {};
+
+// Implementation note: Select true_type if the first parameter is a raw pointer
+// to a RefCounted type. Otherwise, skip the first parameter and check rest of
+// parameters recursively.
+template <typename T, typename... Args>
+struct HasRefCountedTypeAsRawPtr<T, Args...>
+    : std::conditional_t<NeedsScopedRefptrButGetsRawPtr<T>::value,
+                         std::true_type,
+                         HasRefCountedTypeAsRawPtr<Args...>> {};
+
+// ForceVoidReturn<>
+//
+// Set of templates that support forcing the function return type to void.
+template <typename Sig>
+struct ForceVoidReturn;
+
+template <typename R, typename... Args>
+struct ForceVoidReturn<R(Args...)> {
+  using RunType = void(Args...);
+};
+
+// FunctorTraits<>
+//
+// See description at top of file.
+template <typename Functor, typename SFINAE>
+struct FunctorTraits;
+
+// For empty callable types.
+// This specialization is intended to allow binding captureless lambdas by
+// base::Bind(), based on the fact that captureless lambdas are empty while
+// capturing lambdas are not. This also allows any functors as far as it's an
+// empty class.
+// Example:
+//
+//   // Captureless lambdas are allowed.
+//   []() {return 42;};
+//
+//   // Capturing lambdas are *not* allowed.
+//   int x;
+//   [x]() {return x;};
+//
+//   // Any empty class with operator() is allowed.
+//   struct Foo {
+//     void operator()() const {}
+//     // No non-static member variable and no virtual functions.
+//   };
+template <typename Functor>
+struct FunctorTraits<Functor,
+                     std::enable_if_t<IsCallableObject<Functor>::value &&
+                                      std::is_empty<Functor>::value>> {
+  using RunType = ExtractCallableRunType<Functor>;
+  static constexpr bool is_method = false;
+  static constexpr bool is_nullable = false;
+
+  template <typename RunFunctor, typename... RunArgs>
+  static ExtractReturnType<RunType> Invoke(RunFunctor&& functor,
+                                           RunArgs&&... args) {
+    return std::forward<RunFunctor>(functor)(std::forward<RunArgs>(args)...);
+  }
+};
+
+// For functions.
+template <typename R, typename... Args>
+struct FunctorTraits<R (*)(Args...)> {
+  using RunType = R(Args...);
+  static constexpr bool is_method = false;
+  static constexpr bool is_nullable = true;
+
+  template <typename Function, typename... RunArgs>
+  static R Invoke(Function&& function, RunArgs&&... args) {
+    return std::forward<Function>(function)(std::forward<RunArgs>(args)...);
+  }
+};
+
+#if defined(OS_WIN) && !defined(ARCH_CPU_X86_64)
+
+// For functions.
+template <typename R, typename... Args>
+struct FunctorTraits<R(__stdcall*)(Args...)> {
+  using RunType = R(Args...);
+  static constexpr bool is_method = false;
+  static constexpr bool is_nullable = true;
+
+  template <typename... RunArgs>
+  static R Invoke(R(__stdcall* function)(Args...), RunArgs&&... args) {
+    return function(std::forward<RunArgs>(args)...);
+  }
+};
+
+// For functions.
+template <typename R, typename... Args>
+struct FunctorTraits<R(__fastcall*)(Args...)> {
+  using RunType = R(Args...);
+  static constexpr bool is_method = false;
+  static constexpr bool is_nullable = true;
+
+  template <typename... RunArgs>
+  static R Invoke(R(__fastcall* function)(Args...), RunArgs&&... args) {
+    return function(std::forward<RunArgs>(args)...);
+  }
+};
+
+#endif  // defined(OS_WIN) && !defined(ARCH_CPU_X86_64)
+
+#if defined(OS_MACOSX)
+
+// Support for Objective-C blocks. There are two implementation depending
+// on whether Automated Reference Counting (ARC) is enabled. When ARC is
+// enabled, then the block itself can be bound as the compiler will ensure
+// its lifetime will be correctly managed. Otherwise, require the block to
+// be wrapped in a base::mac::ScopedBlock (via base::RetainBlock) that will
+// correctly manage the block lifetime.
+//
+// The two implementation ensure that the One Definition Rule (ODR) is not
+// broken (it is not possible to write a template base::RetainBlock that would
+// work correctly both with ARC enabled and disabled).
+
+#if HAS_FEATURE(objc_arc)
+
+template <typename R, typename... Args>
+struct FunctorTraits<R (^)(Args...)> {
+  using RunType = R(Args...);
+  static constexpr bool is_method = false;
+  static constexpr bool is_nullable = true;
+
+  template <typename BlockType, typename... RunArgs>
+  static R Invoke(BlockType&& block, RunArgs&&... args) {
+    // According to LLVM documentation (§ 6.3), "local variables of automatic
+    // storage duration do not have precise lifetime." Use objc_precise_lifetime
+    // to ensure that the Objective-C block is not deallocated until it has
+    // finished executing even if the Callback<> is destroyed during the block
+    // execution.
+    // https://clang.llvm.org/docs/AutomaticReferenceCounting.html#precise-lifetime-semantics
+    __attribute__((objc_precise_lifetime)) R (^scoped_block)(Args...) = block;
+    return scoped_block(std::forward<RunArgs>(args)...);
+  }
+};
+
+#else  // HAS_FEATURE(objc_arc)
+
+template <typename R, typename... Args>
+struct FunctorTraits<base::mac::ScopedBlock<R (^)(Args...)>> {
+  using RunType = R(Args...);
+  static constexpr bool is_method = false;
+  static constexpr bool is_nullable = true;
+
+  template <typename BlockType, typename... RunArgs>
+  static R Invoke(BlockType&& block, RunArgs&&... args) {
+    // Copy the block to ensure that the Objective-C block is not deallocated
+    // until it has finished executing even if the Callback<> is destroyed
+    // during the block execution.
+    base::mac::ScopedBlock<R (^)(Args...)> scoped_block(block);
+    return scoped_block.get()(std::forward<RunArgs>(args)...);
+  }
+};
+
+#endif  // HAS_FEATURE(objc_arc)
+#endif  // defined(OS_MACOSX)
+
+// For methods.
+template <typename R, typename Receiver, typename... Args>
+struct FunctorTraits<R (Receiver::*)(Args...)> {
+  using RunType = R(Receiver*, Args...);
+  static constexpr bool is_method = true;
+  static constexpr bool is_nullable = true;
+
+  template <typename Method, typename ReceiverPtr, typename... RunArgs>
+  static R Invoke(Method method,
+                  ReceiverPtr&& receiver_ptr,
+                  RunArgs&&... args) {
+    return ((*receiver_ptr).*method)(std::forward<RunArgs>(args)...);
+  }
+};
+
+// For const methods.
+template <typename R, typename Receiver, typename... Args>
+struct FunctorTraits<R (Receiver::*)(Args...) const> {
+  using RunType = R(const Receiver*, Args...);
+  static constexpr bool is_method = true;
+  static constexpr bool is_nullable = true;
+
+  template <typename Method, typename ReceiverPtr, typename... RunArgs>
+  static R Invoke(Method method,
+                  ReceiverPtr&& receiver_ptr,
+                  RunArgs&&... args) {
+    return ((*receiver_ptr).*method)(std::forward<RunArgs>(args)...);
+  }
+};
+
+#ifdef __cpp_noexcept_function_type
+// noexcept makes a distinct function type in C++17.
+// I.e. `void(*)()` and `void(*)() noexcept` are same in pre-C++17, and
+// different in C++17.
+template <typename R, typename... Args>
+struct FunctorTraits<R (*)(Args...) noexcept> : FunctorTraits<R (*)(Args...)> {
+};
+
+template <typename R, typename Receiver, typename... Args>
+struct FunctorTraits<R (Receiver::*)(Args...) noexcept>
+    : FunctorTraits<R (Receiver::*)(Args...)> {};
+
+template <typename R, typename Receiver, typename... Args>
+struct FunctorTraits<R (Receiver::*)(Args...) const noexcept>
+    : FunctorTraits<R (Receiver::*)(Args...) const> {};
+#endif
+
+// For IgnoreResults.
+template <typename T>
+struct FunctorTraits<IgnoreResultHelper<T>> : FunctorTraits<T> {
+  using RunType =
+      typename ForceVoidReturn<typename FunctorTraits<T>::RunType>::RunType;
+
+  template <typename IgnoreResultType, typename... RunArgs>
+  static void Invoke(IgnoreResultType&& ignore_result_helper,
+                     RunArgs&&... args) {
+    FunctorTraits<T>::Invoke(
+        std::forward<IgnoreResultType>(ignore_result_helper).functor_,
+        std::forward<RunArgs>(args)...);
+  }
+};
+
+// For OnceCallbacks.
+template <typename R, typename... Args>
+struct FunctorTraits<OnceCallback<R(Args...)>> {
+  using RunType = R(Args...);
+  static constexpr bool is_method = false;
+  static constexpr bool is_nullable = true;
+
+  template <typename CallbackType, typename... RunArgs>
+  static R Invoke(CallbackType&& callback, RunArgs&&... args) {
+    DCHECK(!callback.is_null());
+    return std::forward<CallbackType>(callback).Run(
+        std::forward<RunArgs>(args)...);
+  }
+};
+
+// For RepeatingCallbacks.
+template <typename R, typename... Args>
+struct FunctorTraits<RepeatingCallback<R(Args...)>> {
+  using RunType = R(Args...);
+  static constexpr bool is_method = false;
+  static constexpr bool is_nullable = true;
+
+  template <typename CallbackType, typename... RunArgs>
+  static R Invoke(CallbackType&& callback, RunArgs&&... args) {
+    DCHECK(!callback.is_null());
+    return std::forward<CallbackType>(callback).Run(
+        std::forward<RunArgs>(args)...);
+  }
+};
+
+template <typename Functor>
+using MakeFunctorTraits = FunctorTraits<std::decay_t<Functor>>;
+
+// InvokeHelper<>
+//
+// There are 2 logical InvokeHelper<> specializations: normal, WeakCalls.
+//
+// The normal type just calls the underlying runnable.
+//
+// WeakCalls need special syntax that is applied to the first argument to check
+// if they should no-op themselves.
+template <bool is_weak_call, typename ReturnType>
+struct InvokeHelper;
+
+template <typename ReturnType>
+struct InvokeHelper<false, ReturnType> {
+  template <typename Functor, typename... RunArgs>
+  static inline ReturnType MakeItSo(Functor&& functor, RunArgs&&... args) {
+    using Traits = MakeFunctorTraits<Functor>;
+    return Traits::Invoke(std::forward<Functor>(functor),
+                          std::forward<RunArgs>(args)...);
+  }
+};
+
+template <typename ReturnType>
+struct InvokeHelper<true, ReturnType> {
+  // WeakCalls are only supported for functions with a void return type.
+  // Otherwise, the function result would be undefined if the the WeakPtr<>
+  // is invalidated.
+  static_assert(std::is_void<ReturnType>::value,
+                "weak_ptrs can only bind to methods without return values");
+
+  template <typename Functor, typename BoundWeakPtr, typename... RunArgs>
+  static inline void MakeItSo(Functor&& functor,
+                              BoundWeakPtr&& weak_ptr,
+                              RunArgs&&... args) {
+    if (!weak_ptr)
+      return;
+    using Traits = MakeFunctorTraits<Functor>;
+    Traits::Invoke(std::forward<Functor>(functor),
+                   std::forward<BoundWeakPtr>(weak_ptr),
+                   std::forward<RunArgs>(args)...);
+  }
+};
+
+// Invoker<>
+//
+// See description at the top of the file.
+template <typename StorageType, typename UnboundRunType>
+struct Invoker;
+
+template <typename StorageType, typename R, typename... UnboundArgs>
+struct Invoker<StorageType, R(UnboundArgs...)> {
+  static R RunOnce(BindStateBase* base,
+                   PassingType<UnboundArgs>... unbound_args) {
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    StorageType* storage = static_cast<StorageType*>(base);
+    static constexpr size_t num_bound_args =
+        std::tuple_size<decltype(storage->bound_args_)>::value;
+    return RunImpl(std::move(storage->functor_),
+                   std::move(storage->bound_args_),
+                   std::make_index_sequence<num_bound_args>(),
+                   std::forward<UnboundArgs>(unbound_args)...);
+  }
+
+  static R Run(BindStateBase* base, PassingType<UnboundArgs>... unbound_args) {
+    // Local references to make debugger stepping easier. If in a debugger,
+    // you really want to warp ahead and step through the
+    // InvokeHelper<>::MakeItSo() call below.
+    const StorageType* storage = static_cast<StorageType*>(base);
+    static constexpr size_t num_bound_args =
+        std::tuple_size<decltype(storage->bound_args_)>::value;
+    return RunImpl(storage->functor_, storage->bound_args_,
+                   std::make_index_sequence<num_bound_args>(),
+                   std::forward<UnboundArgs>(unbound_args)...);
+  }
+
+ private:
+  template <typename Functor, typename BoundArgsTuple, size_t... indices>
+  static inline R RunImpl(Functor&& functor,
+                          BoundArgsTuple&& bound,
+                          std::index_sequence<indices...>,
+                          UnboundArgs&&... unbound_args) {
+    static constexpr bool is_method = MakeFunctorTraits<Functor>::is_method;
+
+    using DecayedArgsTuple = std::decay_t<BoundArgsTuple>;
+    static constexpr bool is_weak_call =
+        IsWeakMethod<is_method,
+                     std::tuple_element_t<indices, DecayedArgsTuple>...>();
+
+    return InvokeHelper<is_weak_call, R>::MakeItSo(
+        std::forward<Functor>(functor),
+        Unwrap(std::get<indices>(std::forward<BoundArgsTuple>(bound)))...,
+        std::forward<UnboundArgs>(unbound_args)...);
+  }
+};
+
+// Extracts necessary type info from Functor and BoundArgs.
+// Used to implement MakeUnboundRunType, BindOnce and BindRepeating.
+template <typename Functor, typename... BoundArgs>
+struct BindTypeHelper {
+  static constexpr size_t num_bounds = sizeof...(BoundArgs);
+  using FunctorTraits = MakeFunctorTraits<Functor>;
+
+  // Example:
+  //   When Functor is `double (Foo::*)(int, const std::string&)`, and BoundArgs
+  //   is a template pack of `Foo*` and `int16_t`:
+  //    - RunType is `double(Foo*, int, const std::string&)`,
+  //    - ReturnType is `double`,
+  //    - RunParamsList is `TypeList<Foo*, int, const std::string&>`,
+  //    - BoundParamsList is `TypeList<Foo*, int>`,
+  //    - UnboundParamsList is `TypeList<const std::string&>`,
+  //    - BoundArgsList is `TypeList<Foo*, int16_t>`,
+  //    - UnboundRunType is `double(const std::string&)`.
+  using RunType = typename FunctorTraits::RunType;
+  using ReturnType = ExtractReturnType<RunType>;
+
+  using RunParamsList = ExtractArgs<RunType>;
+  using BoundParamsList = TakeTypeListItem<num_bounds, RunParamsList>;
+  using UnboundParamsList = DropTypeListItem<num_bounds, RunParamsList>;
+
+  using BoundArgsList = TypeList<BoundArgs...>;
+
+  using UnboundRunType = MakeFunctionType<ReturnType, UnboundParamsList>;
+};
+
+template <typename Functor>
+std::enable_if_t<FunctorTraits<Functor>::is_nullable, bool> IsNull(
+    const Functor& functor) {
+  return !functor;
+}
+
+template <typename Functor>
+std::enable_if_t<!FunctorTraits<Functor>::is_nullable, bool> IsNull(
+    const Functor&) {
+  return false;
+}
+
+// Used by ApplyCancellationTraits below.
+template <typename Functor, typename BoundArgsTuple, size_t... indices>
+bool ApplyCancellationTraitsImpl(const Functor& functor,
+                                 const BoundArgsTuple& bound_args,
+                                 std::index_sequence<indices...>) {
+  return CallbackCancellationTraits<Functor, BoundArgsTuple>::IsCancelled(
+      functor, std::get<indices>(bound_args)...);
+}
+
+// Relays |base| to corresponding CallbackCancellationTraits<>::Run(). Returns
+// true if the callback |base| represents is canceled.
+template <typename BindStateType>
+bool ApplyCancellationTraits(const BindStateBase* base) {
+  const BindStateType* storage = static_cast<const BindStateType*>(base);
+  static constexpr size_t num_bound_args =
+      std::tuple_size<decltype(storage->bound_args_)>::value;
+  return ApplyCancellationTraitsImpl(
+      storage->functor_, storage->bound_args_,
+      std::make_index_sequence<num_bound_args>());
+};
+
+// BindState<>
+//
+// This stores all the state passed into Bind().
+template <typename Functor, typename... BoundArgs>
+struct BindState final : BindStateBase {
+  using IsCancellable = std::integral_constant<
+      bool,
+      CallbackCancellationTraits<Functor,
+                                 std::tuple<BoundArgs...>>::is_cancellable>;
+
+  template <typename ForwardFunctor, typename... ForwardBoundArgs>
+  explicit BindState(BindStateBase::InvokeFuncStorage invoke_func,
+                     ForwardFunctor&& functor,
+                     ForwardBoundArgs&&... bound_args)
+      // IsCancellable is std::false_type if
+      // CallbackCancellationTraits<>::IsCancelled returns always false.
+      // Otherwise, it's std::true_type.
+      : BindState(IsCancellable{},
+                  invoke_func,
+                  std::forward<ForwardFunctor>(functor),
+                  std::forward<ForwardBoundArgs>(bound_args)...) {}
+
+  Functor functor_;
+  std::tuple<BoundArgs...> bound_args_;
+
+ private:
+  template <typename ForwardFunctor, typename... ForwardBoundArgs>
+  explicit BindState(std::true_type,
+                     BindStateBase::InvokeFuncStorage invoke_func,
+                     ForwardFunctor&& functor,
+                     ForwardBoundArgs&&... bound_args)
+      : BindStateBase(invoke_func,
+                      &Destroy,
+                      &ApplyCancellationTraits<BindState>),
+        functor_(std::forward<ForwardFunctor>(functor)),
+        bound_args_(std::forward<ForwardBoundArgs>(bound_args)...) {
+    DCHECK(!IsNull(functor_));
+  }
+
+  template <typename ForwardFunctor, typename... ForwardBoundArgs>
+  explicit BindState(std::false_type,
+                     BindStateBase::InvokeFuncStorage invoke_func,
+                     ForwardFunctor&& functor,
+                     ForwardBoundArgs&&... bound_args)
+      : BindStateBase(invoke_func, &Destroy),
+        functor_(std::forward<ForwardFunctor>(functor)),
+        bound_args_(std::forward<ForwardBoundArgs>(bound_args)...) {
+    DCHECK(!IsNull(functor_));
+  }
+
+  ~BindState() = default;
+
+  static void Destroy(const BindStateBase* self) {
+    delete static_cast<const BindState*>(self);
+  }
+};
+
+// Used to implement MakeBindStateType.
+template <bool is_method, typename Functor, typename... BoundArgs>
+struct MakeBindStateTypeImpl;
+
+template <typename Functor, typename... BoundArgs>
+struct MakeBindStateTypeImpl<false, Functor, BoundArgs...> {
+  static_assert(!HasRefCountedTypeAsRawPtr<std::decay_t<BoundArgs>...>::value,
+                "A parameter is a refcounted type and needs scoped_refptr.");
+  using Type = BindState<std::decay_t<Functor>, std::decay_t<BoundArgs>...>;
+};
+
+template <typename Functor>
+struct MakeBindStateTypeImpl<true, Functor> {
+  using Type = BindState<std::decay_t<Functor>>;
+};
+
+template <typename Functor, typename Receiver, typename... BoundArgs>
+struct MakeBindStateTypeImpl<true, Functor, Receiver, BoundArgs...> {
+ private:
+  using DecayedReceiver = std::decay_t<Receiver>;
+
+  static_assert(!std::is_array<std::remove_reference_t<Receiver>>::value,
+                "First bound argument to a method cannot be an array.");
+  static_assert(
+      !std::is_pointer<DecayedReceiver>::value ||
+          IsRefCountedType<std::remove_pointer_t<DecayedReceiver>>::value,
+      "Receivers may not be raw pointers. If using a raw pointer here is safe"
+      " and has no lifetime concerns, use base::Unretained() and document why"
+      " it's safe.");
+  static_assert(!HasRefCountedTypeAsRawPtr<std::decay_t<BoundArgs>...>::value,
+                "A parameter is a refcounted type and needs scoped_refptr.");
+
+ public:
+  using Type = BindState<
+      std::decay_t<Functor>,
+      std::conditional_t<std::is_pointer<DecayedReceiver>::value,
+                         scoped_refptr<std::remove_pointer_t<DecayedReceiver>>,
+                         DecayedReceiver>,
+      std::decay_t<BoundArgs>...>;
+};
+
+template <typename Functor, typename... BoundArgs>
+using MakeBindStateType =
+    typename MakeBindStateTypeImpl<MakeFunctorTraits<Functor>::is_method,
+                                   Functor,
+                                   BoundArgs...>::Type;
+
+}  // namespace internal
+
+// An injection point to control |this| pointer behavior on a method invocation.
+// If IsWeakReceiver<> is true_type for |T| and |T| is used for a receiver of a
+// method, base::Bind cancels the method invocation if the receiver is tested as
+// false.
+// E.g. Foo::bar() is not called:
+//   struct Foo : base::SupportsWeakPtr<Foo> {
+//     void bar() {}
+//   };
+//
+//   WeakPtr<Foo> oo = nullptr;
+//   base::Bind(&Foo::bar, oo).Run();
+template <typename T>
+struct IsWeakReceiver : std::false_type {};
+
+template <typename T>
+struct IsWeakReceiver<internal::ConstRefWrapper<T>> : IsWeakReceiver<T> {};
+
+template <typename T>
+struct IsWeakReceiver<WeakPtr<T>> : std::true_type {};
+
+// An injection point to control how bound objects passed to the target
+// function. BindUnwrapTraits<>::Unwrap() is called for each bound objects right
+// before the target function is invoked.
+template <typename>
+struct BindUnwrapTraits {
+  template <typename T>
+  static T&& Unwrap(T&& o) {
+    return std::forward<T>(o);
+  }
+};
+
+template <typename T>
+struct BindUnwrapTraits<internal::UnretainedWrapper<T>> {
+  static T* Unwrap(const internal::UnretainedWrapper<T>& o) { return o.get(); }
+};
+
+template <typename T>
+struct BindUnwrapTraits<internal::ConstRefWrapper<T>> {
+  static const T& Unwrap(const internal::ConstRefWrapper<T>& o) {
+    return o.get();
+  }
+};
+
+template <typename T>
+struct BindUnwrapTraits<internal::RetainedRefWrapper<T>> {
+  static T* Unwrap(const internal::RetainedRefWrapper<T>& o) { return o.get(); }
+};
+
+template <typename T>
+struct BindUnwrapTraits<internal::OwnedWrapper<T>> {
+  static T* Unwrap(const internal::OwnedWrapper<T>& o) { return o.get(); }
+};
+
+template <typename T>
+struct BindUnwrapTraits<internal::PassedWrapper<T>> {
+  static T Unwrap(const internal::PassedWrapper<T>& o) { return o.Take(); }
+};
+
+// CallbackCancellationTraits allows customization of Callback's cancellation
+// semantics. By default, callbacks are not cancellable. A specialization should
+// set is_cancellable = true and implement an IsCancelled() that returns if the
+// callback should be cancelled.
+template <typename Functor, typename BoundArgsTuple, typename SFINAE>
+struct CallbackCancellationTraits {
+  static constexpr bool is_cancellable = false;
+};
+
+// Specialization for method bound to weak pointer receiver.
+template <typename Functor, typename... BoundArgs>
+struct CallbackCancellationTraits<
+    Functor,
+    std::tuple<BoundArgs...>,
+    std::enable_if_t<
+        internal::IsWeakMethod<internal::FunctorTraits<Functor>::is_method,
+                               BoundArgs...>::value>> {
+  static constexpr bool is_cancellable = true;
+
+  template <typename Receiver, typename... Args>
+  static bool IsCancelled(const Functor&,
+                          const Receiver& receiver,
+                          const Args&...) {
+    return !receiver;
+  }
+};
+
+// Specialization for a nested bind.
+template <typename Signature, typename... BoundArgs>
+struct CallbackCancellationTraits<OnceCallback<Signature>,
+                                  std::tuple<BoundArgs...>> {
+  static constexpr bool is_cancellable = true;
+
+  template <typename Functor>
+  static bool IsCancelled(const Functor& functor, const BoundArgs&...) {
+    return functor.IsCancelled();
+  }
+};
+
+template <typename Signature, typename... BoundArgs>
+struct CallbackCancellationTraits<RepeatingCallback<Signature>,
+                                  std::tuple<BoundArgs...>> {
+  static constexpr bool is_cancellable = true;
+
+  template <typename Functor>
+  static bool IsCancelled(const Functor& functor, const BoundArgs&...) {
+    return functor.IsCancelled();
+  }
+};
+
+// Returns a RunType of bound functor.
+// E.g. MakeUnboundRunType<R(A, B, C), A, B> is evaluated to R(C).
+template <typename Functor, typename... BoundArgs>
+using MakeUnboundRunType =
+    typename internal::BindTypeHelper<Functor, BoundArgs...>::UnboundRunType;
+
+}  // namespace base
+
+#endif  // BASE_BIND_INTERNAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/callback.h b/native/zucchini/vendor/libchrome/base/callback.h
new file mode 100644
index 0000000..bcda5af
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/callback.h
@@ -0,0 +1,146 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// NOTE: Header files that do not require the full definition of Callback or
+// Closure should #include "base/callback_forward.h" instead of this file.
+
+#ifndef BASE_CALLBACK_H_
+#define BASE_CALLBACK_H_
+
+#include <stddef.h>
+
+#include "base/callback_forward.h"
+#include "base/callback_internal.h"
+
+// -----------------------------------------------------------------------------
+// Usage documentation
+// -----------------------------------------------------------------------------
+//
+// Overview:
+// A callback is similar in concept to a function pointer: it wraps a runnable
+// object such as a function, method, lambda, or even another callback, allowing
+// the runnable object to be invoked later via the callback object.
+//
+// Unlike function pointers, callbacks are created with base::BindOnce() or
+// base::BindRepeating() and support partial function application.
+//
+// A base::OnceCallback may be Run() at most once; a base::RepeatingCallback may
+// be Run() any number of times. |is_null()| is guaranteed to return true for a
+// moved-from callback.
+//
+//   // The lambda takes two arguments, but the first argument |x| is bound at
+//   // callback creation.
+//   base::OnceCallback<int(int)> cb = base::BindOnce([] (int x, int y) {
+//     return x + y;
+//   }, 1);
+//   // Run() only needs the remaining unbound argument |y|.
+//   printf("1 + 2 = %d\n", std::move(cb).Run(2));  // Prints 3
+//   printf("cb is null? %s\n",
+//          cb.is_null() ? "true" : "false");  // Prints true
+//   std::move(cb).Run(2);  // Crashes since |cb| has already run.
+//
+// Callbacks also support cancellation. A common use is binding the receiver
+// object as a WeakPtr<T>. If that weak pointer is invalidated, calling Run()
+// will be a no-op. Note that |is_cancelled()| and |is_null()| are distinct:
+// simply cancelling a callback will not also make it null.
+//
+// base::Callback is currently a type alias for base::RepeatingCallback. In the
+// future, we expect to flip this to default to base::OnceCallback.
+//
+// See //docs/callback.md for the full documentation.
+
+namespace base {
+
+template <typename R, typename... Args>
+class OnceCallback<R(Args...)> : public internal::CallbackBase {
+ public:
+  using RunType = R(Args...);
+  using PolymorphicInvoke = R (*)(internal::BindStateBase*,
+                                  internal::PassingType<Args>...);
+
+  constexpr OnceCallback() = default;
+  OnceCallback(std::nullptr_t) = delete;
+
+  explicit OnceCallback(internal::BindStateBase* bind_state)
+      : internal::CallbackBase(bind_state) {}
+
+  OnceCallback(const OnceCallback&) = delete;
+  OnceCallback& operator=(const OnceCallback&) = delete;
+
+  OnceCallback(OnceCallback&&) noexcept = default;
+  OnceCallback& operator=(OnceCallback&&) noexcept = default;
+
+  OnceCallback(RepeatingCallback<RunType> other)
+      : internal::CallbackBase(std::move(other)) {}
+
+  OnceCallback& operator=(RepeatingCallback<RunType> other) {
+    static_cast<internal::CallbackBase&>(*this) = std::move(other);
+    return *this;
+  }
+
+  bool Equals(const OnceCallback& other) const { return EqualsInternal(other); }
+
+  R Run(Args... args) const & {
+    static_assert(!sizeof(*this),
+                  "OnceCallback::Run() may only be invoked on a non-const "
+                  "rvalue, i.e. std::move(callback).Run().");
+    NOTREACHED();
+  }
+
+  R Run(Args... args) && {
+    // Move the callback instance into a local variable before the invocation,
+    // that ensures the internal state is cleared after the invocation.
+    // It's not safe to touch |this| after the invocation, since running the
+    // bound function may destroy |this|.
+    OnceCallback cb = std::move(*this);
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(cb.polymorphic_invoke());
+    return f(cb.bind_state_.get(), std::forward<Args>(args)...);
+  }
+};
+
+template <typename R, typename... Args>
+class RepeatingCallback<R(Args...)> : public internal::CallbackBaseCopyable {
+ public:
+  using RunType = R(Args...);
+  using PolymorphicInvoke = R (*)(internal::BindStateBase*,
+                                  internal::PassingType<Args>...);
+
+  constexpr RepeatingCallback() = default;
+  RepeatingCallback(std::nullptr_t) = delete;
+
+  explicit RepeatingCallback(internal::BindStateBase* bind_state)
+      : internal::CallbackBaseCopyable(bind_state) {}
+
+  // Copyable and movable.
+  RepeatingCallback(const RepeatingCallback&) = default;
+  RepeatingCallback& operator=(const RepeatingCallback&) = default;
+  RepeatingCallback(RepeatingCallback&&) noexcept = default;
+  RepeatingCallback& operator=(RepeatingCallback&&) noexcept = default;
+
+  bool Equals(const RepeatingCallback& other) const {
+    return EqualsInternal(other);
+  }
+
+  R Run(Args... args) const & {
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(this->polymorphic_invoke());
+    return f(this->bind_state_.get(), std::forward<Args>(args)...);
+  }
+
+  R Run(Args... args) && {
+    // Move the callback instance into a local variable before the invocation,
+    // that ensures the internal state is cleared after the invocation.
+    // It's not safe to touch |this| after the invocation, since running the
+    // bound function may destroy |this|.
+    RepeatingCallback cb = std::move(*this);
+    PolymorphicInvoke f =
+        reinterpret_cast<PolymorphicInvoke>(cb.polymorphic_invoke());
+    return f(cb.bind_state_.get(), std::forward<Args>(args)...);
+  }
+};
+
+}  // namespace base
+
+#endif  // BASE_CALLBACK_H_
diff --git a/native/zucchini/vendor/libchrome/base/callback_forward.h b/native/zucchini/vendor/libchrome/base/callback_forward.h
new file mode 100644
index 0000000..f1851c4
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/callback_forward.h
@@ -0,0 +1,27 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_CALLBACK_FORWARD_H_
+#define BASE_CALLBACK_FORWARD_H_
+
+namespace base {
+
+template <typename Signature>
+class OnceCallback;
+
+template <typename Signature>
+class RepeatingCallback;
+
+template <typename Signature>
+using Callback = RepeatingCallback<Signature>;
+
+// Syntactic sugar to make Callback<void()> easier to declare since it
+// will be used in a lot of APIs with delayed execution.
+using OnceClosure = OnceCallback<void()>;
+using RepeatingClosure = RepeatingCallback<void()>;
+using Closure = Callback<void()>;
+
+}  // namespace base
+
+#endif  // BASE_CALLBACK_FORWARD_H_
diff --git a/native/zucchini/vendor/libchrome/base/callback_helpers.h b/native/zucchini/vendor/libchrome/base/callback_helpers.h
new file mode 100644
index 0000000..0cdda6d
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/callback_helpers.h
@@ -0,0 +1,104 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This defines helpful methods for dealing with Callbacks.  Because Callbacks
+// are implemented using templates, with a class per callback signature, adding
+// methods to Callback<> itself is unattractive (lots of extra code gets
+// generated).  Instead, consider adding methods here.
+
+#ifndef BASE_CALLBACK_HELPERS_H_
+#define BASE_CALLBACK_HELPERS_H_
+
+#include <utility>
+
+#include "base/atomicops.h"
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+
+namespace base {
+
+// Prefer std::move() over ResetAndReturn().
+template <typename CallbackType>
+CallbackType ResetAndReturn(CallbackType* cb) {
+  CallbackType ret(std::move(*cb));
+  DCHECK(!*cb);
+  return ret;
+}
+
+namespace internal {
+
+template <typename... Args>
+class AdaptCallbackForRepeatingHelper final {
+ public:
+  explicit AdaptCallbackForRepeatingHelper(OnceCallback<void(Args...)> callback)
+      : callback_(std::move(callback)) {
+    DCHECK(callback_);
+  }
+
+  void Run(Args... args) {
+    if (subtle::NoBarrier_AtomicExchange(&has_run_, 1))
+      return;
+    DCHECK(callback_);
+    std::move(callback_).Run(std::forward<Args>(args)...);
+  }
+
+ private:
+  volatile subtle::Atomic32 has_run_ = 0;
+  base::OnceCallback<void(Args...)> callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(AdaptCallbackForRepeatingHelper);
+};
+
+}  // namespace internal
+
+// Wraps the given OnceCallback into a RepeatingCallback that relays its
+// invocation to the original OnceCallback on the first invocation. The
+// following invocations are just ignored.
+//
+// Note that this deliberately subverts the Once/Repeating paradigm of Callbacks
+// but helps ease the migration from old-style Callbacks. Avoid if possible; use
+// if necessary for migration. TODO(tzik): Remove it. https://crbug.com/730593
+template <typename... Args>
+RepeatingCallback<void(Args...)> AdaptCallbackForRepeating(
+    OnceCallback<void(Args...)> callback) {
+  using Helper = internal::AdaptCallbackForRepeatingHelper<Args...>;
+  return base::BindRepeating(&Helper::Run,
+                             std::make_unique<Helper>(std::move(callback)));
+}
+
+// ScopedClosureRunner is akin to std::unique_ptr<> for Closures. It ensures
+// that the Closure is executed no matter how the current scope exits.
+class BASE_EXPORT ScopedClosureRunner {
+ public:
+  ScopedClosureRunner();
+  explicit ScopedClosureRunner(OnceClosure closure);
+  ~ScopedClosureRunner();
+
+  ScopedClosureRunner(ScopedClosureRunner&& other);
+
+  // Releases the current closure if it's set and replaces it with the closure
+  // from |other|.
+  ScopedClosureRunner& operator=(ScopedClosureRunner&& other);
+
+  // Calls the current closure and resets it, so it wont be called again.
+  void RunAndReset();
+
+  // Replaces closure with the new one releasing the old one without calling it.
+  void ReplaceClosure(OnceClosure closure);
+
+  // Releases the Closure without calling.
+  OnceClosure Release() WARN_UNUSED_RESULT;
+
+ private:
+  OnceClosure closure_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedClosureRunner);
+};
+
+}  // namespace base
+
+#endif  // BASE_CALLBACK_HELPERS_H_
diff --git a/native/zucchini/vendor/libchrome/base/callback_internal.cc b/native/zucchini/vendor/libchrome/base/callback_internal.cc
new file mode 100644
index 0000000..dd000ca
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/callback_internal.cc
@@ -0,0 +1,84 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/callback_internal.h"
+
+#include "base/logging.h"
+
+namespace base {
+namespace internal {
+
+namespace {
+
+bool ReturnFalse(const BindStateBase*) {
+  return false;
+}
+
+}  // namespace
+
+void BindStateBaseRefCountTraits::Destruct(const BindStateBase* bind_state) {
+  bind_state->destructor_(bind_state);
+}
+
+BindStateBase::BindStateBase(InvokeFuncStorage polymorphic_invoke,
+                             void (*destructor)(const BindStateBase*))
+    : BindStateBase(polymorphic_invoke, destructor, &ReturnFalse) {
+}
+
+BindStateBase::BindStateBase(InvokeFuncStorage polymorphic_invoke,
+                             void (*destructor)(const BindStateBase*),
+                             bool (*is_cancelled)(const BindStateBase*))
+    : polymorphic_invoke_(polymorphic_invoke),
+      destructor_(destructor),
+      is_cancelled_(is_cancelled) {}
+
+CallbackBase& CallbackBase::operator=(CallbackBase&& c) noexcept = default;
+CallbackBase::CallbackBase(const CallbackBaseCopyable& c)
+    : bind_state_(c.bind_state_) {}
+
+CallbackBase& CallbackBase::operator=(const CallbackBaseCopyable& c) {
+  bind_state_ = c.bind_state_;
+  return *this;
+}
+
+CallbackBase::CallbackBase(CallbackBaseCopyable&& c) noexcept
+    : bind_state_(std::move(c.bind_state_)) {}
+
+CallbackBase& CallbackBase::operator=(CallbackBaseCopyable&& c) noexcept {
+  bind_state_ = std::move(c.bind_state_);
+  return *this;
+}
+
+void CallbackBase::Reset() {
+  // NULL the bind_state_ last, since it may be holding the last ref to whatever
+  // object owns us, and we may be deleted after that.
+  bind_state_ = nullptr;
+}
+
+bool CallbackBase::IsCancelled() const {
+  DCHECK(bind_state_);
+  return bind_state_->IsCancelled();
+}
+
+bool CallbackBase::EqualsInternal(const CallbackBase& other) const {
+  return bind_state_ == other.bind_state_;
+}
+
+CallbackBase::~CallbackBase() = default;
+
+CallbackBaseCopyable::CallbackBaseCopyable(const CallbackBaseCopyable& c) {
+  bind_state_ = c.bind_state_;
+}
+
+CallbackBaseCopyable& CallbackBaseCopyable::operator=(
+    const CallbackBaseCopyable& c) {
+  bind_state_ = c.bind_state_;
+  return *this;
+}
+
+CallbackBaseCopyable& CallbackBaseCopyable::operator=(
+    CallbackBaseCopyable&& c) noexcept = default;
+
+}  // namespace internal
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/callback_internal.h b/native/zucchini/vendor/libchrome/base/callback_internal.h
new file mode 100644
index 0000000..1215e3e
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/callback_internal.h
@@ -0,0 +1,165 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file contains utility functions and classes that help the
+// implementation, and management of the Callback objects.
+
+#ifndef BASE_CALLBACK_INTERNAL_H_
+#define BASE_CALLBACK_INTERNAL_H_
+
+#include "base/base_export.h"
+#include "base/callback_forward.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+
+namespace base {
+
+struct FakeBindState;
+
+namespace internal {
+
+class CallbackBase;
+class CallbackBaseCopyable;
+
+class BindStateBase;
+
+template <typename Functor, typename... BoundArgs>
+struct BindState;
+
+struct BindStateBaseRefCountTraits {
+  static void Destruct(const BindStateBase*);
+};
+
+template <typename T>
+using PassingType = std::conditional_t<std::is_scalar<T>::value, T, T&&>;
+
+// BindStateBase is used to provide an opaque handle that the Callback
+// class can use to represent a function object with bound arguments.  It
+// behaves as an existential type that is used by a corresponding
+// DoInvoke function to perform the function execution.  This allows
+// us to shield the Callback class from the types of the bound argument via
+// "type erasure."
+// At the base level, the only task is to add reference counting data. Don't use
+// RefCountedThreadSafe since it requires the destructor to be a virtual method.
+// Creating a vtable for every BindState template instantiation results in a lot
+// of bloat. Its only task is to call the destructor which can be done with a
+// function pointer.
+class BASE_EXPORT BindStateBase
+    : public RefCountedThreadSafe<BindStateBase, BindStateBaseRefCountTraits> {
+ public:
+  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
+
+  using InvokeFuncStorage = void(*)();
+
+ private:
+  BindStateBase(InvokeFuncStorage polymorphic_invoke,
+                void (*destructor)(const BindStateBase*));
+  BindStateBase(InvokeFuncStorage polymorphic_invoke,
+                void (*destructor)(const BindStateBase*),
+                bool (*is_cancelled)(const BindStateBase*));
+
+  ~BindStateBase() = default;
+
+  friend struct BindStateBaseRefCountTraits;
+  friend class RefCountedThreadSafe<BindStateBase, BindStateBaseRefCountTraits>;
+
+  friend class CallbackBase;
+  friend class CallbackBaseCopyable;
+
+  // Whitelist subclasses that access the destructor of BindStateBase.
+  template <typename Functor, typename... BoundArgs>
+  friend struct BindState;
+  friend struct ::base::FakeBindState;
+
+  bool IsCancelled() const {
+    return is_cancelled_(this);
+  }
+
+  // In C++, it is safe to cast function pointers to function pointers of
+  // another type. It is not okay to use void*. We create a InvokeFuncStorage
+  // that that can store our function pointer, and then cast it back to
+  // the original type on usage.
+  InvokeFuncStorage polymorphic_invoke_;
+
+  // Pointer to a function that will properly destroy |this|.
+  void (*destructor_)(const BindStateBase*);
+  bool (*is_cancelled_)(const BindStateBase*);
+
+  DISALLOW_COPY_AND_ASSIGN(BindStateBase);
+};
+
+// Holds the Callback methods that don't require specialization to reduce
+// template bloat.
+// CallbackBase<MoveOnly> is a direct base class of MoveOnly callbacks, and
+// CallbackBase<Copyable> uses CallbackBase<MoveOnly> for its implementation.
+class BASE_EXPORT CallbackBase {
+ public:
+  inline CallbackBase(CallbackBase&& c) noexcept;
+  CallbackBase& operator=(CallbackBase&& c) noexcept;
+
+  explicit CallbackBase(const CallbackBaseCopyable& c);
+  CallbackBase& operator=(const CallbackBaseCopyable& c);
+
+  explicit CallbackBase(CallbackBaseCopyable&& c) noexcept;
+  CallbackBase& operator=(CallbackBaseCopyable&& c) noexcept;
+
+  // Returns true if Callback is null (doesn't refer to anything).
+  bool is_null() const { return !bind_state_; }
+  explicit operator bool() const { return !is_null(); }
+
+  // Returns true if the callback invocation will be nop due to an cancellation.
+  // It's invalid to call this on uninitialized callback.
+  bool IsCancelled() const;
+
+  // Returns the Callback into an uninitialized state.
+  void Reset();
+
+ protected:
+  using InvokeFuncStorage = BindStateBase::InvokeFuncStorage;
+
+  // Returns true if this callback equals |other|. |other| may be null.
+  bool EqualsInternal(const CallbackBase& other) const;
+
+  constexpr inline CallbackBase();
+
+  // Allow initializing of |bind_state_| via the constructor to avoid default
+  // initialization of the scoped_refptr.
+  explicit inline CallbackBase(BindStateBase* bind_state);
+
+  InvokeFuncStorage polymorphic_invoke() const {
+    return bind_state_->polymorphic_invoke_;
+  }
+
+  // Force the destructor to be instantiated inside this translation unit so
+  // that our subclasses will not get inlined versions.  Avoids more template
+  // bloat.
+  ~CallbackBase();
+
+  scoped_refptr<BindStateBase> bind_state_;
+};
+
+constexpr CallbackBase::CallbackBase() = default;
+CallbackBase::CallbackBase(CallbackBase&&) noexcept = default;
+CallbackBase::CallbackBase(BindStateBase* bind_state)
+    : bind_state_(AdoptRef(bind_state)) {}
+
+// CallbackBase<Copyable> is a direct base class of Copyable Callbacks.
+class BASE_EXPORT CallbackBaseCopyable : public CallbackBase {
+ public:
+  CallbackBaseCopyable(const CallbackBaseCopyable& c);
+  CallbackBaseCopyable(CallbackBaseCopyable&& c) noexcept = default;
+  CallbackBaseCopyable& operator=(const CallbackBaseCopyable& c);
+  CallbackBaseCopyable& operator=(CallbackBaseCopyable&& c) noexcept;
+
+ protected:
+  constexpr CallbackBaseCopyable() = default;
+  explicit CallbackBaseCopyable(BindStateBase* bind_state)
+      : CallbackBase(bind_state) {}
+  ~CallbackBaseCopyable() = default;
+};
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_CALLBACK_INTERNAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/cfi_buildflags.h b/native/zucchini/vendor/libchrome/base/cfi_buildflags.h
new file mode 100644
index 0000000..be8270e
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/cfi_buildflags.h
@@ -0,0 +1,7 @@
+// Generated by build/write_buildflag_header.py
+// From "base_debugging_flags"
+#ifndef BASE_CFI_BUILDFLAGS_H_
+#define BASE_CFI_BUILDFLAGS_H_
+#include "build/buildflag.h"
+#define BUILDFLAG_INTERNAL_CFI_ICALL_CHECK() (0)
+#endif  // BASE_CFI_BUILDFLAGS_H_
diff --git a/native/zucchini/vendor/libchrome/base/command_line.h b/native/zucchini/vendor/libchrome/base/command_line.h
new file mode 100644
index 0000000..25fd7d9
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/command_line.h
@@ -0,0 +1,247 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This class works with command lines: building and parsing.
+// Arguments with prefixes ('--', '-', and on Windows, '/') are switches.
+// Switches will precede all other arguments without switch prefixes.
+// Switches can optionally have values, delimited by '=', e.g., "-switch=value".
+// An argument of "--" will terminate switch parsing during initialization,
+// interpreting subsequent tokens as non-switch arguments, regardless of prefix.
+
+// There is a singleton read-only CommandLine that represents the command line
+// that the current process was started with.  It must be initialized in main().
+
+#ifndef BASE_COMMAND_LINE_H_
+#define BASE_COMMAND_LINE_H_
+
+#include <stddef.h>
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_piece.h"
+#include "build/build_config.h"
+
+namespace base {
+
+class FilePath;
+
+class BASE_EXPORT CommandLine {
+ public:
+#if defined(OS_WIN)
+  // The native command line string type.
+  using StringType = string16;
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  using StringType = std::string;
+#endif
+
+  using CharType = StringType::value_type;
+  using StringVector = std::vector<StringType>;
+  using SwitchMap = std::map<std::string, StringType, std::less<>>;
+
+  // A constructor for CommandLines that only carry switches and arguments.
+  enum NoProgram { NO_PROGRAM };
+  explicit CommandLine(NoProgram no_program);
+
+  // Construct a new command line with |program| as argv[0].
+  explicit CommandLine(const FilePath& program);
+
+  // Construct a new command line from an argument list.
+  CommandLine(int argc, const CharType* const* argv);
+  explicit CommandLine(const StringVector& argv);
+
+  // Override copy and assign to ensure |switches_by_stringpiece_| is valid.
+  CommandLine(const CommandLine& other);
+  CommandLine& operator=(const CommandLine& other);
+
+  ~CommandLine();
+
+#if defined(OS_WIN)
+  // By default this class will treat command-line arguments beginning with
+  // slashes as switches on Windows, but not other platforms.
+  //
+  // If this behavior is inappropriate for your application, you can call this
+  // function BEFORE initializing the current process' global command line
+  // object and the behavior will be the same as Posix systems (only hyphens
+  // begin switches, everything else will be an arg).
+  static void set_slash_is_not_a_switch();
+
+  // Normally when the CommandLine singleton is initialized it gets the command
+  // line via the GetCommandLineW API and then uses the shell32 API
+  // 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.
+  static void InitUsingArgvForTesting(int argc, const char* const* argv);
+#endif
+
+  // Initialize the current process CommandLine singleton. On Windows, ignores
+  // its arguments (we instead parse GetCommandLineW() directly) because we
+  // 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.
+  static bool Init(int argc, const char* const* argv);
+
+  // Destroys the current process CommandLine singleton. This is necessary if
+  // you want to reset the base library to its initial state (for example, in an
+  // outer library that needs to be able to terminate, and be re-initialized).
+  // If Init is called only once, as in main(), Reset() is not necessary.
+  // Do not call this in tests. Use base::test::ScopedCommandLine instead.
+  static void Reset();
+
+  // Get the singleton CommandLine representing the current process's
+  // command line. Note: returned value is mutable, but not thread safe;
+  // only mutate if you know what you're doing!
+  static CommandLine* ForCurrentProcess();
+
+  // Returns true if the CommandLine has been initialized for the given process.
+  static bool InitializedForCurrentProcess();
+
+#if defined(OS_WIN)
+  static CommandLine FromString(const string16& command_line);
+#endif
+
+  // Initialize from an argv vector.
+  void InitFromArgv(int argc, const CharType* const* argv);
+  void InitFromArgv(const StringVector& argv);
+
+  // Constructs and returns the represented command line string.
+  // CAUTION! This should be avoided on POSIX because quoting behavior is
+  // unclear.
+  StringType GetCommandLineString() const {
+    return GetCommandLineStringInternal(false);
+  }
+
+#if defined(OS_WIN)
+  // Constructs and returns the represented command line string. Assumes the
+  // command line contains placeholders (eg, %1) and quotes any program or
+  // argument with a '%' in it. This should be avoided unless the placeholder is
+  // required by an external interface (eg, the Windows registry), because it is
+  // not generally safe to replace it with an arbitrary string. If possible,
+  // placeholders should be replaced *before* converting the command line to a
+  // string.
+  StringType GetCommandLineStringWithPlaceholders() const {
+    return GetCommandLineStringInternal(true);
+  }
+#endif
+
+  // Constructs and returns the represented arguments string.
+  // CAUTION! This should be avoided on POSIX because quoting behavior is
+  // unclear.
+  StringType GetArgumentsString() const {
+    return GetArgumentsStringInternal(false);
+  }
+
+#if defined(OS_WIN)
+  // Constructs and returns the represented arguments string. Assumes the
+  // command line contains placeholders (eg, %1) and quotes any argument with a
+  // '%' in it. This should be avoided unless the placeholder is required by an
+  // external interface (eg, the Windows registry), because it is not generally
+  // safe to replace it with an arbitrary string. If possible, placeholders
+  // should be replaced *before* converting the arguments to a string.
+  StringType GetArgumentsStringWithPlaceholders() const {
+    return GetArgumentsStringInternal(true);
+  }
+#endif
+
+  // Returns the original command line string as a vector of strings.
+  const StringVector& argv() const { return argv_; }
+
+  // Get and Set the program part of the command line string (the first item).
+  FilePath GetProgram() const;
+  void SetProgram(const FilePath& program);
+
+  // Returns true if this command line contains the given switch.
+  // Switch names must be lowercase.
+  // The second override provides an optimized version to avoid inlining codegen
+  // at every callsite to find the length of the constant and construct a
+  // StringPiece.
+  bool HasSwitch(const StringPiece& switch_string) const;
+  bool HasSwitch(const char switch_constant[]) const;
+
+  // Returns the value associated with the given switch. If the switch has no
+  // value or isn't present, this method returns the empty string.
+  // Switch names must be lowercase.
+  std::string GetSwitchValueASCII(const StringPiece& switch_string) const;
+  FilePath GetSwitchValuePath(const StringPiece& switch_string) const;
+  StringType GetSwitchValueNative(const StringPiece& switch_string) const;
+
+  // Get a copy of all switches, along with their values.
+  const SwitchMap& GetSwitches() const { return switches_; }
+
+  // Append a switch [with optional value] to the command line.
+  // Note: Switches will precede arguments regardless of appending order.
+  void AppendSwitch(const std::string& switch_string);
+  void AppendSwitchPath(const std::string& switch_string,
+                        const FilePath& path);
+  void AppendSwitchNative(const std::string& switch_string,
+                          const StringType& value);
+  void AppendSwitchASCII(const std::string& switch_string,
+                         const std::string& value);
+
+  // Copy a set of switches (and any values) from another command line.
+  // Commonly used when launching a subprocess.
+  void CopySwitchesFrom(const CommandLine& source,
+                        const char* const switches[],
+                        size_t count);
+
+  // Get the remaining arguments to the command.
+  StringVector GetArgs() const;
+
+  // Append an argument to the command line. Note that the argument is quoted
+  // properly such that it is interpreted as one argument to the target command.
+  // AppendArg is primarily for ASCII; non-ASCII input is interpreted as UTF-8.
+  // Note: Switches will precede arguments regardless of appending order.
+  void AppendArg(const std::string& value);
+  void AppendArgPath(const FilePath& value);
+  void AppendArgNative(const StringType& value);
+
+  // Append the switches and arguments from another command line to this one.
+  // If |include_program| is true, include |other|'s program as well.
+  void AppendArguments(const CommandLine& other, bool include_program);
+
+  // Insert a command before the current command.
+  // Common for debuggers, like "gdb --args".
+  void PrependWrapper(const StringType& wrapper);
+
+#if defined(OS_WIN)
+  // Initialize by parsing the given command line string.
+  // The program name is assumed to be the first item in the string.
+  void ParseFromString(const string16& command_line);
+#endif
+
+ private:
+  // Disallow default constructor; a program name must be explicitly specified.
+  CommandLine() = delete;
+  // Allow the copy constructor. A common pattern is to copy of the current
+  // process's command line and then add some flags to it. For example:
+  //   CommandLine cl(*CommandLine::ForCurrentProcess());
+  //   cl.AppendSwitch(...);
+
+  // Internal version of GetCommandLineString. If |quote_placeholders| is true,
+  // also quotes parts with '%' in them.
+  StringType GetCommandLineStringInternal(bool quote_placeholders) const;
+
+  // Internal version of GetArgumentsString. If |quote_placeholders| is true,
+  // also quotes parts with '%' in them.
+  StringType GetArgumentsStringInternal(bool quote_placeholders) const;
+
+  // The singleton CommandLine representing the current process's command line.
+  static CommandLine* current_process_commandline_;
+
+  // The argv array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* }
+  StringVector argv_;
+
+  // Parsed-out switch keys and values.
+  SwitchMap switches_;
+
+  // The index after the program and switches, any arguments start here.
+  size_t begin_args_;
+};
+
+}  // namespace base
+
+#endif  // BASE_COMMAND_LINE_H_
diff --git a/native/zucchini/vendor/libchrome/base/compiler_specific.h b/native/zucchini/vendor/libchrome/base/compiler_specific.h
new file mode 100644
index 0000000..a930f5d
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/compiler_specific.h
@@ -0,0 +1,236 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_COMPILER_SPECIFIC_H_
+#define BASE_COMPILER_SPECIFIC_H_
+
+#include "build/build_config.h"
+
+#if defined(ANDROID)
+// Prefer Android's libbase definitions to our own.
+#include <android-base/macros.h>
+#endif  // defined(ANDROID)
+
+#if defined(COMPILER_MSVC)
+
+// For _Printf_format_string_.
+#include <sal.h>
+
+// Macros for suppressing and disabling warnings on MSVC.
+//
+// Warning numbers are enumerated at:
+// http://msdn.microsoft.com/en-us/library/8x5x43k7(VS.80).aspx
+//
+// The warning pragma:
+// http://msdn.microsoft.com/en-us/library/2c8f766e(VS.80).aspx
+//
+// Using __pragma instead of #pragma inside macros:
+// http://msdn.microsoft.com/en-us/library/d9x1s805.aspx
+
+// MSVC_SUPPRESS_WARNING disables warning |n| for the remainder of the line and
+// for the next line of the source file.
+#define MSVC_SUPPRESS_WARNING(n) __pragma(warning(suppress:n))
+
+// MSVC_PUSH_DISABLE_WARNING pushes |n| onto a stack of warnings to be disabled.
+// The warning remains disabled until popped by MSVC_POP_WARNING.
+#define MSVC_PUSH_DISABLE_WARNING(n) __pragma(warning(push)) \
+                                     __pragma(warning(disable:n))
+
+// MSVC_PUSH_WARNING_LEVEL pushes |n| as the global warning level.  The level
+// remains in effect until popped by MSVC_POP_WARNING().  Use 0 to disable all
+// warnings.
+#define MSVC_PUSH_WARNING_LEVEL(n) __pragma(warning(push, n))
+
+// Pop effects of innermost MSVC_PUSH_* macro.
+#define MSVC_POP_WARNING() __pragma(warning(pop))
+
+#define MSVC_DISABLE_OPTIMIZE() __pragma(optimize("", off))
+#define MSVC_ENABLE_OPTIMIZE() __pragma(optimize("", on))
+
+#else  // Not MSVC
+
+#define _Printf_format_string_
+#define MSVC_SUPPRESS_WARNING(n)
+#define MSVC_PUSH_DISABLE_WARNING(n)
+#define MSVC_PUSH_WARNING_LEVEL(n)
+#define MSVC_POP_WARNING()
+#define MSVC_DISABLE_OPTIMIZE()
+#define MSVC_ENABLE_OPTIMIZE()
+
+#endif  // COMPILER_MSVC
+
+// Annotate a variable indicating it's ok if the variable is not used.
+// (Typically used to silence a compiler warning when the assignment
+// is important for some other reason.)
+// Use like:
+//   int x = ...;
+//   ALLOW_UNUSED_LOCAL(x);
+#define ALLOW_UNUSED_LOCAL(x) (void)x
+
+// Annotate a typedef or function indicating it's ok if it's not used.
+// Use like:
+//   typedef Foo Bar ALLOW_UNUSED_TYPE;
+#if defined(COMPILER_GCC) || defined(__clang__)
+#define ALLOW_UNUSED_TYPE __attribute__((unused))
+#else
+#define ALLOW_UNUSED_TYPE
+#endif
+
+// Annotate a function indicating it should not be inlined.
+// Use like:
+//   NOINLINE void DoStuff() { ... }
+#if defined(COMPILER_GCC)
+#define NOINLINE __attribute__((noinline))
+#elif defined(COMPILER_MSVC)
+#define NOINLINE __declspec(noinline)
+#else
+#define NOINLINE
+#endif
+
+#if COMPILER_GCC && defined(NDEBUG)
+#define ALWAYS_INLINE inline __attribute__((__always_inline__))
+#elif COMPILER_MSVC && defined(NDEBUG)
+#define ALWAYS_INLINE __forceinline
+#else
+#define ALWAYS_INLINE inline
+#endif
+
+// Specify memory alignment for structs, classes, etc.
+// Use like:
+//   class ALIGNAS(16) MyClass { ... }
+//   ALIGNAS(16) int array[4];
+//
+// In most places you can use the C++11 keyword "alignas", which is preferred.
+//
+// But compilers have trouble mixing __attribute__((...)) syntax with
+// alignas(...) syntax.
+//
+// Doesn't work in clang or gcc:
+//   struct alignas(16) __attribute__((packed)) S { char c; };
+// Works in clang but not gcc:
+//   struct __attribute__((packed)) alignas(16) S2 { char c; };
+// Works in clang and gcc:
+//   struct alignas(16) S3 { char c; } __attribute__((packed));
+//
+// There are also some attributes that must be specified *before* a class
+// definition: visibility (used for exporting functions/classes) is one of
+// these attributes. This means that it is not possible to use alignas() with a
+// class that is marked as exported.
+#if defined(COMPILER_MSVC)
+#define ALIGNAS(byte_alignment) __declspec(align(byte_alignment))
+#elif defined(COMPILER_GCC)
+#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))
+#endif
+
+// Annotate a function indicating the caller must examine the return value.
+// Use like:
+//   int foo() WARN_UNUSED_RESULT;
+// To explicitly ignore a result, see |ignore_result()| in base/macros.h.
+#undef WARN_UNUSED_RESULT
+#if defined(COMPILER_GCC) || defined(__clang__)
+#define WARN_UNUSED_RESULT __attribute__((warn_unused_result))
+#else
+#define WARN_UNUSED_RESULT
+#endif
+
+// Tell the compiler a function is using a printf-style format string.
+// |format_param| is the one-based index of the format string parameter;
+// |dots_param| is the one-based index of the "..." parameter.
+// For v*printf functions (which take a va_list), pass 0 for dots_param.
+// (This is undocumented but matches what the system C headers do.)
+#if defined(COMPILER_GCC) || defined(__clang__)
+#define PRINTF_FORMAT(format_param, dots_param) \
+    __attribute__((format(printf, format_param, dots_param)))
+#else
+#define PRINTF_FORMAT(format_param, dots_param)
+#endif
+
+// WPRINTF_FORMAT is the same, but for wide format strings.
+// This doesn't appear to yet be implemented in any compiler.
+// See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38308 .
+#define WPRINTF_FORMAT(format_param, dots_param)
+// If available, it would look like:
+//   __attribute__((format(wprintf, format_param, dots_param)))
+
+// Sanitizers annotations.
+#if defined(__has_attribute)
+#if __has_attribute(no_sanitize)
+#define NO_SANITIZE(what) __attribute__((no_sanitize(what)))
+#endif
+#endif
+#if !defined(NO_SANITIZE)
+#define NO_SANITIZE(what)
+#endif
+
+// MemorySanitizer annotations.
+#if defined(MEMORY_SANITIZER) && !defined(OS_NACL)
+#include <sanitizer/msan_interface.h>
+
+// Mark a memory region fully initialized.
+// Use this to annotate code that deliberately reads uninitialized data, for
+// example a GC scavenging root set pointers from the stack.
+#define MSAN_UNPOISON(p, size)  __msan_unpoison(p, size)
+
+// Check a memory region for initializedness, as if it was being used here.
+// If any bits are uninitialized, crash with an MSan report.
+// Use this to sanitize data which MSan won't be able to track, e.g. before
+// passing data to another process via shared memory.
+#define MSAN_CHECK_MEM_IS_INITIALIZED(p, size) \
+    __msan_check_mem_is_initialized(p, size)
+#else  // MEMORY_SANITIZER
+#define MSAN_UNPOISON(p, size)
+#define MSAN_CHECK_MEM_IS_INITIALIZED(p, size)
+#endif  // MEMORY_SANITIZER
+
+// DISABLE_CFI_PERF -- Disable Control Flow Integrity for perf reasons.
+#if !defined(DISABLE_CFI_PERF)
+#if defined(__clang__) && defined(OFFICIAL_BUILD)
+#define DISABLE_CFI_PERF __attribute__((no_sanitize("cfi")))
+#else
+#define DISABLE_CFI_PERF
+#endif
+#endif
+
+// Macro useful for writing cross-platform function pointers.
+#if !defined(CDECL)
+#if defined(OS_WIN)
+#define CDECL __cdecl
+#else  // defined(OS_WIN)
+#define CDECL
+#endif  // defined(OS_WIN)
+#endif  // !defined(CDECL)
+
+// Macro for hinting that an expression is likely to be false.
+#if !defined(UNLIKELY)
+#if defined(COMPILER_GCC) || defined(__clang__)
+#define UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+#define UNLIKELY(x) (x)
+#endif  // defined(COMPILER_GCC)
+#endif  // !defined(UNLIKELY)
+
+#if !defined(LIKELY)
+#if defined(COMPILER_GCC) || defined(__clang__)
+#define LIKELY(x) __builtin_expect(!!(x), 1)
+#else
+#define LIKELY(x) (x)
+#endif  // defined(COMPILER_GCC)
+#endif  // !defined(LIKELY)
+
+// Compiler feature-detection.
+// clang.llvm.org/docs/LanguageExtensions.html#has-feature-and-has-extension
+#if defined(__has_feature)
+#define HAS_FEATURE(FEATURE) __has_feature(FEATURE)
+#else
+#define HAS_FEATURE(FEATURE) 0
+#endif
+
+// Macro for telling -Wimplicit-fallthrough that a fallthrough is intentional.
+#if defined(__clang__)
+#define FALLTHROUGH [[clang::fallthrough]]
+#else
+#define FALLTHROUGH
+#endif
+
+#endif  // BASE_COMPILER_SPECIFIC_H_
diff --git a/native/zucchini/vendor/libchrome/base/containers/circular_deque.h b/native/zucchini/vendor/libchrome/base/containers/circular_deque.h
new file mode 100644
index 0000000..bf42a95
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/containers/circular_deque.h
@@ -0,0 +1,1111 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_CONTAINERS_CIRCULAR_DEQUE_H_
+#define BASE_CONTAINERS_CIRCULAR_DEQUE_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+#include "base/containers/vector_buffer.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/template_util.h"
+
+// base::circular_deque is similar to std::deque. Unlike std::deque, the
+// storage is provided in a flat circular buffer conceptually similar to a
+// vector. The beginning and end will wrap around as necessary so that
+// pushes and pops will be constant time as long as a capacity expansion is
+// not required.
+//
+// The API should be identical to std::deque with the following differences:
+//
+//  - ITERATORS ARE NOT STABLE. Mutating the container will invalidate all
+//    iterators.
+//
+//  - Insertions may resize the vector and so are not constant time (std::deque
+//    guarantees constant time for insertions at the ends).
+//
+//  - Container-wide comparisons are not implemented. If you want to compare
+//    two containers, use an algorithm so the expensive iteration is explicit.
+//
+// If you want a similar container with only a queue API, use base::queue in
+// base/containers/queue.h.
+//
+// Constructors:
+//   circular_deque();
+//   circular_deque(size_t count);
+//   circular_deque(size_t count, const T& value);
+//   circular_deque(InputIterator first, InputIterator last);
+//   circular_deque(const circular_deque&);
+//   circular_deque(circular_deque&&);
+//   circular_deque(std::initializer_list<value_type>);
+//
+// Assignment functions:
+//   circular_deque& operator=(const circular_deque&);
+//   circular_deque& operator=(circular_deque&&);
+//   circular_deque& operator=(std::initializer_list<T>);
+//   void assign(size_t count, const T& value);
+//   void assign(InputIterator first, InputIterator last);
+//   void assign(std::initializer_list<T> value);
+//
+// Random accessors:
+//   T& at(size_t);
+//   const T& at(size_t) const;
+//   T& operator[](size_t);
+//   const T& operator[](size_t) const;
+//
+// End accessors:
+//   T& front();
+//   const T& front() const;
+//   T& back();
+//   const T& back() const;
+//
+// Iterator functions:
+//   iterator               begin();
+//   const_iterator         begin() const;
+//   const_iterator         cbegin() const;
+//   iterator               end();
+//   const_iterator         end() const;
+//   const_iterator         cend() const;
+//   reverse_iterator       rbegin();
+//   const_reverse_iterator rbegin() const;
+//   const_reverse_iterator crbegin() const;
+//   reverse_iterator       rend();
+//   const_reverse_iterator rend() const;
+//   const_reverse_iterator crend() const;
+//
+// Memory management:
+//   void reserve(size_t);  // SEE IMPLEMENTATION FOR SOME GOTCHAS.
+//   size_t capacity() const;
+//   void shrink_to_fit();
+//
+// Size management:
+//   void clear();
+//   bool empty() const;
+//   size_t size() const;
+//   void resize(size_t);
+//   void resize(size_t count, const T& value);
+//
+// Positional insert and erase:
+//   void insert(const_iterator pos, size_type count, const T& value);
+//   void insert(const_iterator pos,
+//               InputIterator first, InputIterator last);
+//   iterator insert(const_iterator pos, const T& value);
+//   iterator insert(const_iterator pos, T&& value);
+//   iterator emplace(const_iterator pos, Args&&... args);
+//   iterator erase(const_iterator pos);
+//   iterator erase(const_iterator first, const_iterator last);
+//
+// End insert and erase:
+//   void push_front(const T&);
+//   void push_front(T&&);
+//   void push_back(const T&);
+//   void push_back(T&&);
+//   T& emplace_front(Args&&...);
+//   T& emplace_back(Args&&...);
+//   void pop_front();
+//   void pop_back();
+//
+// General:
+//   void swap(circular_deque&);
+
+namespace base {
+
+template <class T>
+class circular_deque;
+
+namespace internal {
+
+// Start allocating nonempty buffers with this many entries. This is the
+// external capacity so the internal buffer will be one larger (= 4) which is
+// more even for the allocator. See the descriptions of internal vs. external
+// capacity on the comment above the buffer_ variable below.
+constexpr size_t kCircularBufferInitialCapacity = 3;
+
+template <typename T>
+class circular_deque_const_iterator {
+ public:
+  using difference_type = std::ptrdiff_t;
+  using value_type = T;
+  using pointer = const T*;
+  using reference = const T&;
+  using iterator_category = std::random_access_iterator_tag;
+
+  circular_deque_const_iterator() : parent_deque_(nullptr), index_(0) {
+#if DCHECK_IS_ON()
+    created_generation_ = 0;
+#endif  // DCHECK_IS_ON()
+  }
+
+  // Dereferencing.
+  const T& operator*() const {
+    CheckUnstableUsage();
+    parent_deque_->CheckValidIndex(index_);
+    return parent_deque_->buffer_[index_];
+  }
+  const T* operator->() const {
+    CheckUnstableUsage();
+    parent_deque_->CheckValidIndex(index_);
+    return &parent_deque_->buffer_[index_];
+  }
+  const value_type& operator[](difference_type i) const { return *(*this + i); }
+
+  // Increment and decrement.
+  circular_deque_const_iterator& operator++() {
+    Increment();
+    return *this;
+  }
+  circular_deque_const_iterator operator++(int) {
+    circular_deque_const_iterator ret = *this;
+    Increment();
+    return ret;
+  }
+  circular_deque_const_iterator& operator--() {
+    Decrement();
+    return *this;
+  }
+  circular_deque_const_iterator operator--(int) {
+    circular_deque_const_iterator ret = *this;
+    Decrement();
+    return ret;
+  }
+
+  // Random access mutation.
+  friend circular_deque_const_iterator operator+(
+      const circular_deque_const_iterator& iter,
+      difference_type offset) {
+    circular_deque_const_iterator ret = iter;
+    ret.Add(offset);
+    return ret;
+  }
+  circular_deque_const_iterator& operator+=(difference_type offset) {
+    Add(offset);
+    return *this;
+  }
+  friend circular_deque_const_iterator operator-(
+      const circular_deque_const_iterator& iter,
+      difference_type offset) {
+    circular_deque_const_iterator ret = iter;
+    ret.Add(-offset);
+    return ret;
+  }
+  circular_deque_const_iterator& operator-=(difference_type offset) {
+    Add(-offset);
+    return *this;
+  }
+
+  friend std::ptrdiff_t operator-(const circular_deque_const_iterator& lhs,
+                                  const circular_deque_const_iterator& rhs) {
+    lhs.CheckComparable(rhs);
+    return lhs.OffsetFromBegin() - rhs.OffsetFromBegin();
+  }
+
+  // Comparisons.
+  friend bool operator==(const circular_deque_const_iterator& lhs,
+                         const circular_deque_const_iterator& rhs) {
+    lhs.CheckComparable(rhs);
+    return lhs.index_ == rhs.index_;
+  }
+  friend bool operator!=(const circular_deque_const_iterator& lhs,
+                         const circular_deque_const_iterator& rhs) {
+    return !(lhs == rhs);
+  }
+  friend bool operator<(const circular_deque_const_iterator& lhs,
+                        const circular_deque_const_iterator& rhs) {
+    lhs.CheckComparable(rhs);
+    return lhs.OffsetFromBegin() < rhs.OffsetFromBegin();
+  }
+  friend bool operator<=(const circular_deque_const_iterator& lhs,
+                         const circular_deque_const_iterator& rhs) {
+    return !(lhs > rhs);
+  }
+  friend bool operator>(const circular_deque_const_iterator& lhs,
+                        const circular_deque_const_iterator& rhs) {
+    lhs.CheckComparable(rhs);
+    return lhs.OffsetFromBegin() > rhs.OffsetFromBegin();
+  }
+  friend bool operator>=(const circular_deque_const_iterator& lhs,
+                         const circular_deque_const_iterator& rhs) {
+    return !(lhs < rhs);
+  }
+
+ protected:
+  friend class circular_deque<T>;
+
+  circular_deque_const_iterator(const circular_deque<T>* parent, size_t index)
+      : parent_deque_(parent), index_(index) {
+#if DCHECK_IS_ON()
+    created_generation_ = parent->generation_;
+#endif  // DCHECK_IS_ON()
+  }
+
+  // Returns the offset from the beginning index of the buffer to the current
+  // item.
+  size_t OffsetFromBegin() const {
+    if (index_ >= parent_deque_->begin_)
+      return index_ - parent_deque_->begin_;  // On the same side as begin.
+    return parent_deque_->buffer_.capacity() - parent_deque_->begin_ + index_;
+  }
+
+  // Most uses will be ++ and -- so use a simplified implementation.
+  void Increment() {
+    CheckUnstableUsage();
+    parent_deque_->CheckValidIndex(index_);
+    index_++;
+    if (index_ == parent_deque_->buffer_.capacity())
+      index_ = 0;
+  }
+  void Decrement() {
+    CheckUnstableUsage();
+    parent_deque_->CheckValidIndexOrEnd(index_);
+    if (index_ == 0)
+      index_ = parent_deque_->buffer_.capacity() - 1;
+    else
+      index_--;
+  }
+  void Add(difference_type delta) {
+    CheckUnstableUsage();
+#if DCHECK_IS_ON()
+    if (delta <= 0)
+      parent_deque_->CheckValidIndexOrEnd(index_);
+    else
+      parent_deque_->CheckValidIndex(index_);
+#endif
+    // It should be valid to add 0 to any iterator, even if the container is
+    // empty and the iterator points to end(). The modulo below will divide
+    // by 0 if the buffer capacity is empty, so it's important to check for
+    // this case explicitly.
+    if (delta == 0)
+      return;
+
+    difference_type new_offset = OffsetFromBegin() + delta;
+    DCHECK(new_offset >= 0 &&
+           new_offset <= static_cast<difference_type>(parent_deque_->size()));
+    index_ = (new_offset + parent_deque_->begin_) %
+             parent_deque_->buffer_.capacity();
+  }
+
+#if DCHECK_IS_ON()
+  void CheckUnstableUsage() const {
+    DCHECK(parent_deque_);
+    // Since circular_deque doesn't guarantee stability, any attempt to
+    // dereference this iterator after a mutation (i.e. the generation doesn't
+    // match the original) in the container is illegal.
+    DCHECK_EQ(created_generation_, parent_deque_->generation_)
+        << "circular_deque iterator dereferenced after mutation.";
+  }
+  void CheckComparable(const circular_deque_const_iterator& other) const {
+    DCHECK_EQ(parent_deque_, other.parent_deque_);
+    // Since circular_deque doesn't guarantee stability, two iterators that
+    // are compared must have been generated without mutating the container.
+    // If this fires, the container was mutated between generating the two
+    // iterators being compared.
+    DCHECK_EQ(created_generation_, other.created_generation_);
+  }
+#else
+  inline void CheckUnstableUsage() const {}
+  inline void CheckComparable(const circular_deque_const_iterator&) const {}
+#endif  // DCHECK_IS_ON()
+
+  const circular_deque<T>* parent_deque_;
+  size_t index_;
+
+#if DCHECK_IS_ON()
+  // The generation of the parent deque when this iterator was created. The
+  // container will update the generation for every modification so we can
+  // test if the container was modified by comparing them.
+  uint64_t created_generation_;
+#endif  // DCHECK_IS_ON()
+};
+
+template <typename T>
+class circular_deque_iterator : public circular_deque_const_iterator<T> {
+  using base = circular_deque_const_iterator<T>;
+
+ public:
+  friend class circular_deque<T>;
+
+  using difference_type = std::ptrdiff_t;
+  using value_type = T;
+  using pointer = T*;
+  using reference = T&;
+  using iterator_category = std::random_access_iterator_tag;
+
+  // Expose the base class' constructor.
+  circular_deque_iterator() : circular_deque_const_iterator<T>() {}
+
+  // Dereferencing.
+  T& operator*() const { return const_cast<T&>(base::operator*()); }
+  T* operator->() const { return const_cast<T*>(base::operator->()); }
+  T& operator[](difference_type i) {
+    return const_cast<T&>(base::operator[](i));
+  }
+
+  // Random access mutation.
+  friend circular_deque_iterator operator+(const circular_deque_iterator& iter,
+                                           difference_type offset) {
+    circular_deque_iterator ret = iter;
+    ret.Add(offset);
+    return ret;
+  }
+  circular_deque_iterator& operator+=(difference_type offset) {
+    base::Add(offset);
+    return *this;
+  }
+  friend circular_deque_iterator operator-(const circular_deque_iterator& iter,
+                                           difference_type offset) {
+    circular_deque_iterator ret = iter;
+    ret.Add(-offset);
+    return ret;
+  }
+  circular_deque_iterator& operator-=(difference_type offset) {
+    base::Add(-offset);
+    return *this;
+  }
+
+  // Increment and decrement.
+  circular_deque_iterator& operator++() {
+    base::Increment();
+    return *this;
+  }
+  circular_deque_iterator operator++(int) {
+    circular_deque_iterator ret = *this;
+    base::Increment();
+    return ret;
+  }
+  circular_deque_iterator& operator--() {
+    base::Decrement();
+    return *this;
+  }
+  circular_deque_iterator operator--(int) {
+    circular_deque_iterator ret = *this;
+    base::Decrement();
+    return ret;
+  }
+
+ private:
+  circular_deque_iterator(const circular_deque<T>* parent, size_t index)
+      : circular_deque_const_iterator<T>(parent, index) {}
+};
+
+}  // namespace internal
+
+template <typename T>
+class circular_deque {
+ private:
+  using VectorBuffer = internal::VectorBuffer<T>;
+
+ public:
+  using value_type = T;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using pointer = value_type*;
+  using const_pointer = const value_type*;
+
+  using iterator = internal::circular_deque_iterator<T>;
+  using const_iterator = internal::circular_deque_const_iterator<T>;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+  // ---------------------------------------------------------------------------
+  // Constructor
+
+  constexpr circular_deque() = default;
+
+  // Constructs with |count| copies of |value| or default constructed version.
+  circular_deque(size_type count) { resize(count); }
+  circular_deque(size_type count, const T& value) { resize(count, value); }
+
+  // Range constructor.
+  template <class InputIterator>
+  circular_deque(InputIterator first, InputIterator last) {
+    assign(first, last);
+  }
+
+  // Copy/move.
+  circular_deque(const circular_deque& other) : buffer_(other.size() + 1) {
+    assign(other.begin(), other.end());
+  }
+  circular_deque(circular_deque&& other) noexcept
+      : buffer_(std::move(other.buffer_)),
+        begin_(other.begin_),
+        end_(other.end_) {
+    other.begin_ = 0;
+    other.end_ = 0;
+  }
+
+  circular_deque(std::initializer_list<value_type> init) { assign(init); }
+
+  ~circular_deque() { DestructRange(begin_, end_); }
+
+  // ---------------------------------------------------------------------------
+  // Assignments.
+  //
+  // All of these may invalidate iterators and references.
+
+  circular_deque& operator=(const circular_deque& other) {
+    if (&other == this)
+      return *this;
+
+    reserve(other.size());
+    assign(other.begin(), other.end());
+    return *this;
+  }
+  circular_deque& operator=(circular_deque&& other) noexcept {
+    if (&other == this)
+      return *this;
+
+    // We're about to overwrite the buffer, so don't free it in clear to
+    // avoid doing it twice.
+    ClearRetainCapacity();
+    buffer_ = std::move(other.buffer_);
+    begin_ = other.begin_;
+    end_ = other.end_;
+
+    other.begin_ = 0;
+    other.end_ = 0;
+
+    IncrementGeneration();
+    return *this;
+  }
+  circular_deque& operator=(std::initializer_list<value_type> ilist) {
+    reserve(ilist.size());
+    assign(std::begin(ilist), std::end(ilist));
+    return *this;
+  }
+
+  void assign(size_type count, const value_type& value) {
+    ClearRetainCapacity();
+    reserve(count);
+    for (size_t i = 0; i < count; i++)
+      emplace_back(value);
+    IncrementGeneration();
+  }
+
+  // This variant should be enabled only when InputIterator is an iterator.
+  template <typename InputIterator>
+  typename std::enable_if<::base::internal::is_iterator<InputIterator>::value,
+                          void>::type
+  assign(InputIterator first, InputIterator last) {
+    // Possible future enhancement, dispatch on iterator tag type. For forward
+    // iterators we can use std::difference to preallocate the space required
+    // and only do one copy.
+    ClearRetainCapacity();
+    for (; first != last; ++first)
+      emplace_back(*first);
+    IncrementGeneration();
+  }
+
+  void assign(std::initializer_list<value_type> value) {
+    reserve(std::distance(value.begin(), value.end()));
+    assign(value.begin(), value.end());
+  }
+
+  // ---------------------------------------------------------------------------
+  // Accessors.
+  //
+  // Since this class assumes no exceptions, at() and operator[] are equivalent.
+
+  const value_type& at(size_type i) const {
+    DCHECK(i < size());
+    size_t right_size = buffer_.capacity() - begin_;
+    if (begin_ <= end_ || i < right_size)
+      return buffer_[begin_ + i];
+    return buffer_[i - right_size];
+  }
+  value_type& at(size_type i) {
+    return const_cast<value_type&>(
+        const_cast<const circular_deque*>(this)->at(i));
+  }
+
+  value_type& operator[](size_type i) { return at(i); }
+  const value_type& operator[](size_type i) const {
+    return const_cast<circular_deque*>(this)->at(i);
+  }
+
+  value_type& front() {
+    DCHECK(!empty());
+    return buffer_[begin_];
+  }
+  const value_type& front() const {
+    DCHECK(!empty());
+    return buffer_[begin_];
+  }
+
+  value_type& back() {
+    DCHECK(!empty());
+    return *(--end());
+  }
+  const value_type& back() const {
+    DCHECK(!empty());
+    return *(--end());
+  }
+
+  // ---------------------------------------------------------------------------
+  // Iterators.
+
+  iterator begin() { return iterator(this, begin_); }
+  const_iterator begin() const { return const_iterator(this, begin_); }
+  const_iterator cbegin() const { return const_iterator(this, begin_); }
+
+  iterator end() { return iterator(this, end_); }
+  const_iterator end() const { return const_iterator(this, end_); }
+  const_iterator cend() const { return const_iterator(this, end_); }
+
+  reverse_iterator rbegin() { return reverse_iterator(end()); }
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+  const_reverse_iterator crbegin() const { return rbegin(); }
+
+  reverse_iterator rend() { return reverse_iterator(begin()); }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+  const_reverse_iterator crend() const { return rend(); }
+
+  // ---------------------------------------------------------------------------
+  // Memory management.
+
+  // IMPORTANT NOTE ON reserve(...): This class implements auto-shrinking of
+  // the buffer when elements are deleted and there is "too much" wasted space.
+  // So if you call reserve() with a large size in anticipation of pushing many
+  // elements, but pop an element before the queue is full, the capacity you
+  // reserved may be lost.
+  //
+  // As a result, it's only worthwhile to call reserve() when you're adding
+  // many things at once with no intermediate operations.
+  void reserve(size_type new_capacity) {
+    if (new_capacity > capacity())
+      SetCapacityTo(new_capacity);
+  }
+
+  size_type capacity() const {
+    // One item is wasted to indicate end().
+    return buffer_.capacity() == 0 ? 0 : buffer_.capacity() - 1;
+  }
+
+  void shrink_to_fit() {
+    if (empty()) {
+      // Optimize empty case to really delete everything if there was
+      // something.
+      if (buffer_.capacity())
+        buffer_ = VectorBuffer();
+    } else {
+      SetCapacityTo(size());
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Size management.
+
+  // This will additionally reset the capacity() to 0.
+  void clear() {
+    // This can't resize(0) because that requires a default constructor to
+    // compile, which not all contained classes may implement.
+    ClearRetainCapacity();
+    buffer_ = VectorBuffer();
+  }
+
+  bool empty() const { return begin_ == end_; }
+
+  size_type size() const {
+    if (begin_ <= end_)
+      return end_ - begin_;
+    return buffer_.capacity() - begin_ + end_;
+  }
+
+  // When reducing size, the elements are deleted from the end. When expanding
+  // size, elements are added to the end with |value| or the default
+  // constructed version. Even when using resize(count) to shrink, a default
+  // constructor is required for the code to compile, even though it will not
+  // be called.
+  //
+  // There are two versions rather than using a default value to avoid
+  // creating a temporary when shrinking (when it's not needed). Plus if
+  // the default constructor is desired when expanding usually just calling it
+  // for each element is faster than making a default-constructed temporary and
+  // copying it.
+  void resize(size_type count) {
+    // SEE BELOW VERSION if you change this. The code is mostly the same.
+    if (count > size()) {
+      // This could be slighly more efficient but expanding a queue with
+      // identical elements is unusual and the extra computations of emplacing
+      // one-by-one will typically be small relative to calling the constructor
+      // for every item.
+      ExpandCapacityIfNecessary(count - size());
+      while (size() < count)
+        emplace_back();
+    } else if (count < size()) {
+      size_t new_end = (begin_ + count) % buffer_.capacity();
+      DestructRange(new_end, end_);
+      end_ = new_end;
+
+      ShrinkCapacityIfNecessary();
+    }
+    IncrementGeneration();
+  }
+  void resize(size_type count, const value_type& value) {
+    // SEE ABOVE VERSION if you change this. The code is mostly the same.
+    if (count > size()) {
+      ExpandCapacityIfNecessary(count - size());
+      while (size() < count)
+        emplace_back(value);
+    } else if (count < size()) {
+      size_t new_end = (begin_ + count) % buffer_.capacity();
+      DestructRange(new_end, end_);
+      end_ = new_end;
+
+      ShrinkCapacityIfNecessary();
+    }
+    IncrementGeneration();
+  }
+
+  // ---------------------------------------------------------------------------
+  // Insert and erase.
+  //
+  // Insertion and deletion in the middle is O(n) and invalidates all existing
+  // iterators.
+  //
+  // The implementation of insert isn't optimized as much as it could be. If
+  // the insertion requires that the buffer be grown, it will first be grown
+  // and everything moved, and then the items will be inserted, potentially
+  // moving some items twice. This simplifies the implemntation substantially
+  // and means less generated templatized code. Since this is an uncommon
+  // operation for deques, and already relatively slow, it doesn't seem worth
+  // the benefit to optimize this.
+
+  void insert(const_iterator pos, size_type count, const T& value) {
+    ValidateIterator(pos);
+
+    // Optimize insert at the beginning.
+    if (pos == begin()) {
+      ExpandCapacityIfNecessary(count);
+      for (size_t i = 0; i < count; i++)
+        push_front(value);
+      return;
+    }
+
+    iterator insert_cur(this, pos.index_);
+    iterator insert_end;
+    MakeRoomFor(count, &insert_cur, &insert_end);
+    while (insert_cur < insert_end) {
+      new (&buffer_[insert_cur.index_]) T(value);
+      ++insert_cur;
+    }
+
+    IncrementGeneration();
+  }
+
+  // This enable_if keeps this call from getting confused with the (pos, count,
+  // value) version when value is an integer.
+  template <class InputIterator>
+  typename std::enable_if<::base::internal::is_iterator<InputIterator>::value,
+                          void>::type
+  insert(const_iterator pos, InputIterator first, InputIterator last) {
+    ValidateIterator(pos);
+
+    size_t inserted_items = std::distance(first, last);
+    if (inserted_items == 0)
+      return;  // Can divide by 0 when doing modulo below, so return early.
+
+    // Make a hole to copy the items into.
+    iterator insert_cur;
+    iterator insert_end;
+    if (pos == begin()) {
+      // Optimize insert at the beginning, nothing needs to be shifted and the
+      // hole is the |inserted_items| block immediately before |begin_|.
+      ExpandCapacityIfNecessary(inserted_items);
+      insert_end = begin();
+      begin_ =
+          (begin_ + buffer_.capacity() - inserted_items) % buffer_.capacity();
+      insert_cur = begin();
+    } else {
+      insert_cur = iterator(this, pos.index_);
+      MakeRoomFor(inserted_items, &insert_cur, &insert_end);
+    }
+
+    // Copy the items.
+    while (insert_cur < insert_end) {
+      new (&buffer_[insert_cur.index_]) T(*first);
+      ++insert_cur;
+      ++first;
+    }
+
+    IncrementGeneration();
+  }
+
+  // These all return an iterator to the inserted item. Existing iterators will
+  // be invalidated.
+  iterator insert(const_iterator pos, const T& value) {
+    return emplace(pos, value);
+  }
+  iterator insert(const_iterator pos, T&& value) {
+    return emplace(pos, std::move(value));
+  }
+  template <class... Args>
+  iterator emplace(const_iterator pos, Args&&... args) {
+    ValidateIterator(pos);
+
+    // Optimize insert at beginning which doesn't require shifting.
+    if (pos == cbegin()) {
+      emplace_front(std::forward<Args>(args)...);
+      return begin();
+    }
+
+    // Do this before we make the new iterators we return.
+    IncrementGeneration();
+
+    iterator insert_begin(this, pos.index_);
+    iterator insert_end;
+    MakeRoomFor(1, &insert_begin, &insert_end);
+    new (&buffer_[insert_begin.index_]) T(std::forward<Args>(args)...);
+
+    return insert_begin;
+  }
+
+  // Calling erase() won't automatically resize the buffer smaller like resize
+  // or the pop functions. Erase is slow and relatively uncommon, and for
+  // normal deque usage a pop will normally be done on a regular basis that
+  // will prevent excessive buffer usage over long periods of time. It's not
+  // worth having the extra code for every template instantiation of erase()
+  // to resize capacity downward to a new buffer.
+  iterator erase(const_iterator pos) { return erase(pos, pos + 1); }
+  iterator erase(const_iterator first, const_iterator last) {
+    ValidateIterator(first);
+    ValidateIterator(last);
+
+    IncrementGeneration();
+
+    // First, call the destructor on the deleted items.
+    if (first.index_ == last.index_) {
+      // Nothing deleted. Need to return early to avoid falling through to
+      // moving items on top of themselves.
+      return iterator(this, first.index_);
+    } else if (first.index_ < last.index_) {
+      // Contiguous range.
+      buffer_.DestructRange(&buffer_[first.index_], &buffer_[last.index_]);
+    } else {
+      // Deleted range wraps around.
+      buffer_.DestructRange(&buffer_[first.index_],
+                            &buffer_[buffer_.capacity()]);
+      buffer_.DestructRange(&buffer_[0], &buffer_[last.index_]);
+    }
+
+    if (first.index_ == begin_) {
+      // This deletion is from the beginning. Nothing needs to be copied, only
+      // begin_ needs to be updated.
+      begin_ = last.index_;
+      return iterator(this, last.index_);
+    }
+
+    // In an erase operation, the shifted items all move logically to the left,
+    // so move them from left-to-right.
+    iterator move_src(this, last.index_);
+    iterator move_src_end = end();
+    iterator move_dest(this, first.index_);
+    for (; move_src < move_src_end; move_src++, move_dest++) {
+      buffer_.MoveRange(&buffer_[move_src.index_],
+                        &buffer_[move_src.index_ + 1],
+                        &buffer_[move_dest.index_]);
+    }
+
+    end_ = move_dest.index_;
+
+    // Since we did not reallocate and only changed things after the erase
+    // element(s), the input iterator's index points to the thing following the
+    // deletion.
+    return iterator(this, first.index_);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Begin/end operations.
+
+  void push_front(const T& value) { emplace_front(value); }
+  void push_front(T&& value) { emplace_front(std::move(value)); }
+
+  void push_back(const T& value) { emplace_back(value); }
+  void push_back(T&& value) { emplace_back(std::move(value)); }
+
+  template <class... Args>
+  reference emplace_front(Args&&... args) {
+    ExpandCapacityIfNecessary(1);
+    if (begin_ == 0)
+      begin_ = buffer_.capacity() - 1;
+    else
+      begin_--;
+    IncrementGeneration();
+    new (&buffer_[begin_]) T(std::forward<Args>(args)...);
+    return front();
+  }
+
+  template <class... Args>
+  reference emplace_back(Args&&... args) {
+    ExpandCapacityIfNecessary(1);
+    new (&buffer_[end_]) T(std::forward<Args>(args)...);
+    if (end_ == buffer_.capacity() - 1)
+      end_ = 0;
+    else
+      end_++;
+    IncrementGeneration();
+    return back();
+  }
+
+  void pop_front() {
+    DCHECK(size());
+    buffer_.DestructRange(&buffer_[begin_], &buffer_[begin_ + 1]);
+    begin_++;
+    if (begin_ == buffer_.capacity())
+      begin_ = 0;
+
+    ShrinkCapacityIfNecessary();
+
+    // Technically popping will not invalidate any iterators since the
+    // underlying buffer will be stable. But in the future we may want to add a
+    // feature that resizes the buffer smaller if there is too much wasted
+    // space. This ensures we can make such a change safely.
+    IncrementGeneration();
+  }
+  void pop_back() {
+    DCHECK(size());
+    if (end_ == 0)
+      end_ = buffer_.capacity() - 1;
+    else
+      end_--;
+    buffer_.DestructRange(&buffer_[end_], &buffer_[end_ + 1]);
+
+    ShrinkCapacityIfNecessary();
+
+    // See pop_front comment about why this is here.
+    IncrementGeneration();
+  }
+
+  // ---------------------------------------------------------------------------
+  // General operations.
+
+  void swap(circular_deque& other) {
+    std::swap(buffer_, other.buffer_);
+    std::swap(begin_, other.begin_);
+    std::swap(end_, other.end_);
+    IncrementGeneration();
+  }
+
+  friend void swap(circular_deque& lhs, circular_deque& rhs) { lhs.swap(rhs); }
+
+ private:
+  friend internal::circular_deque_iterator<T>;
+  friend internal::circular_deque_const_iterator<T>;
+
+  // Moves the items in the given circular buffer to the current one. The
+  // source is moved from so will become invalid. The destination buffer must
+  // have already been allocated with enough size.
+  static void MoveBuffer(VectorBuffer& from_buf,
+                         size_t from_begin,
+                         size_t from_end,
+                         VectorBuffer* to_buf,
+                         size_t* to_begin,
+                         size_t* to_end) {
+    size_t from_capacity = from_buf.capacity();
+
+    *to_begin = 0;
+    if (from_begin < from_end) {
+      // Contiguous.
+      from_buf.MoveRange(&from_buf[from_begin], &from_buf[from_end],
+                         to_buf->begin());
+      *to_end = from_end - from_begin;
+    } else if (from_begin > from_end) {
+      // Discontiguous, copy the right side to the beginning of the new buffer.
+      from_buf.MoveRange(&from_buf[from_begin], &from_buf[from_capacity],
+                         to_buf->begin());
+      size_t right_size = from_capacity - from_begin;
+      // Append the left side.
+      from_buf.MoveRange(&from_buf[0], &from_buf[from_end],
+                         &(*to_buf)[right_size]);
+      *to_end = right_size + from_end;
+    } else {
+      // No items.
+      *to_end = 0;
+    }
+  }
+
+  // Expands the buffer size. This assumes the size is larger than the
+  // number of elements in the vector (it won't call delete on anything).
+  void SetCapacityTo(size_t new_capacity) {
+    // Use the capacity + 1 as the internal buffer size to differentiate
+    // empty and full (see definition of buffer_ below).
+    VectorBuffer new_buffer(new_capacity + 1);
+    MoveBuffer(buffer_, begin_, end_, &new_buffer, &begin_, &end_);
+    buffer_ = std::move(new_buffer);
+  }
+  void ExpandCapacityIfNecessary(size_t additional_elts) {
+    size_t min_new_capacity = size() + additional_elts;
+    if (capacity() >= min_new_capacity)
+      return;  // Already enough room.
+
+    min_new_capacity =
+        std::max(min_new_capacity, internal::kCircularBufferInitialCapacity);
+
+    // std::vector always grows by at least 50%. WTF::Deque grows by at least
+    // 25%. We expect queue workloads to generally stay at a similar size and
+    // grow less than a vector might, so use 25%.
+    size_t new_capacity =
+        std::max(min_new_capacity, capacity() + capacity() / 4);
+    SetCapacityTo(new_capacity);
+  }
+
+  void ShrinkCapacityIfNecessary() {
+    // Don't auto-shrink below this size.
+    if (capacity() <= internal::kCircularBufferInitialCapacity)
+      return;
+
+    // Shrink when 100% of the size() is wasted.
+    size_t sz = size();
+    size_t empty_spaces = capacity() - sz;
+    if (empty_spaces < sz)
+      return;
+
+    // Leave 1/4 the size as free capacity, not going below the initial
+    // capacity.
+    size_t new_capacity =
+        std::max(internal::kCircularBufferInitialCapacity, sz + sz / 4);
+    if (new_capacity < capacity()) {
+      // Count extra item to convert to internal capacity.
+      SetCapacityTo(new_capacity);
+    }
+  }
+
+  // Backend for clear() but does not resize the internal buffer.
+  void ClearRetainCapacity() {
+    // This can't resize(0) because that requires a default constructor to
+    // compile, which not all contained classes may implement.
+    DestructRange(begin_, end_);
+    begin_ = 0;
+    end_ = 0;
+    IncrementGeneration();
+  }
+
+  // Calls destructors for the given begin->end indices. The indices may wrap
+  // around. The buffer is not resized, and the begin_ and end_ members are
+  // not changed.
+  void DestructRange(size_t begin, size_t end) {
+    if (end == begin) {
+      return;
+    } else if (end > begin) {
+      buffer_.DestructRange(&buffer_[begin], &buffer_[end]);
+    } else {
+      buffer_.DestructRange(&buffer_[begin], &buffer_[buffer_.capacity()]);
+      buffer_.DestructRange(&buffer_[0], &buffer_[end]);
+    }
+  }
+
+  // Makes room for |count| items starting at |*insert_begin|. Since iterators
+  // are not stable across buffer resizes, |*insert_begin| will be updated to
+  // point to the beginning of the newly opened position in the new array (it's
+  // in/out), and the end of the newly opened position (it's out-only).
+  void MakeRoomFor(size_t count, iterator* insert_begin, iterator* insert_end) {
+    if (count == 0) {
+      *insert_end = *insert_begin;
+      return;
+    }
+
+    // The offset from the beginning will be stable across reallocations.
+    size_t begin_offset = insert_begin->OffsetFromBegin();
+    ExpandCapacityIfNecessary(count);
+
+    insert_begin->index_ = (begin_ + begin_offset) % buffer_.capacity();
+    *insert_end =
+        iterator(this, (insert_begin->index_ + count) % buffer_.capacity());
+
+    // Update the new end and prepare the iterators for copying.
+    iterator src = end();
+    end_ = (end_ + count) % buffer_.capacity();
+    iterator dest = end();
+
+    // Move the elements. This will always involve shifting logically to the
+    // right, so move in a right-to-left order.
+    while (true) {
+      if (src == *insert_begin)
+        break;
+      --src;
+      --dest;
+      buffer_.MoveRange(&buffer_[src.index_], &buffer_[src.index_ + 1],
+                        &buffer_[dest.index_]);
+    }
+  }
+
+#if DCHECK_IS_ON()
+  // Asserts the given index is dereferencable. The index is an index into the
+  // buffer, not an index used by operator[] or at() which will be offsets from
+  // begin.
+  void CheckValidIndex(size_t i) const {
+    if (begin_ <= end_)
+      DCHECK(i >= begin_ && i < end_);
+    else
+      DCHECK((i >= begin_ && i < buffer_.capacity()) || i < end_);
+  }
+
+  // Asserts the given index is either dereferencable or points to end().
+  void CheckValidIndexOrEnd(size_t i) const {
+    if (i != end_)
+      CheckValidIndex(i);
+  }
+
+  void ValidateIterator(const const_iterator& i) const {
+    DCHECK(i.parent_deque_ == this);
+    i.CheckUnstableUsage();
+  }
+
+  // See generation_ below.
+  void IncrementGeneration() { generation_++; }
+#else
+  // No-op versions of these functions for release builds.
+  void CheckValidIndex(size_t) const {}
+  void CheckValidIndexOrEnd(size_t) const {}
+  void ValidateIterator(const const_iterator& i) const {}
+  void IncrementGeneration() {}
+#endif
+
+  // Danger, the buffer_.capacity() is the "internal capacity" which is
+  // capacity() + 1 since there is an extra item to indicate the end. Otherwise
+  // being completely empty and completely full are indistinguishable (begin ==
+  // end). We could add a separate flag to avoid it, but that adds significant
+  // extra complexity since every computation will have to check for it. Always
+  // keeping one extra unused element in the buffer makes iterator computations
+  // much simpler.
+  //
+  // Container internal code will want to use buffer_.capacity() for offset
+  // computations rather than capacity().
+  VectorBuffer buffer_;
+  size_type begin_ = 0;
+  size_type end_ = 0;
+
+#if DCHECK_IS_ON()
+  // Incremented every time a modification is made that could affect iterator
+  // invalidations.
+  uint64_t generation_ = 0;
+#endif
+};
+
+// Implementations of base::Erase[If] (see base/stl_util.h).
+template <class T, class Value>
+void Erase(circular_deque<T>& container, const Value& value) {
+  container.erase(std::remove(container.begin(), container.end(), value),
+                  container.end());
+}
+
+template <class T, class Predicate>
+void EraseIf(circular_deque<T>& container, Predicate pred) {
+  container.erase(std::remove_if(container.begin(), container.end(), pred),
+                  container.end());
+}
+
+}  // namespace base
+
+#endif  // BASE_CONTAINERS_CIRCULAR_DEQUE_H_
diff --git a/native/zucchini/vendor/libchrome/base/containers/queue.h b/native/zucchini/vendor/libchrome/base/containers/queue.h
new file mode 100644
index 0000000..b5bc5c3
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/containers/queue.h
@@ -0,0 +1,23 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_CONTAINERS_QUEUE_H_
+#define BASE_CONTAINERS_QUEUE_H_
+
+#include <queue>
+
+#include "base/containers/circular_deque.h"
+
+namespace base {
+
+// Provides a definition of base::queue that's like std::queue but uses a
+// base::circular_deque instead of std::deque. Since std::queue is just a
+// wrapper for an underlying type, we can just provide a typedef for it that
+// defaults to the base circular_deque.
+template <class T, class Container = circular_deque<T>>
+using queue = std::queue<T, Container>;
+
+}  // namespace base
+
+#endif  // BASE_CONTAINERS_QUEUE_H_
diff --git a/native/zucchini/vendor/libchrome/base/containers/span.h b/native/zucchini/vendor/libchrome/base/containers/span.h
new file mode 100644
index 0000000..f1e0000
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/containers/span.h
@@ -0,0 +1,453 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_CONTAINERS_SPAN_H_
+#define BASE_CONTAINERS_SPAN_H_
+
+#include <stddef.h>
+
+#include <algorithm>
+#include <array>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+#include "base/logging.h"
+#include "base/stl_util.h"
+
+namespace base {
+
+// [views.constants]
+constexpr size_t dynamic_extent = static_cast<size_t>(-1);
+
+template <typename T, size_t Extent = dynamic_extent>
+class span;
+
+namespace internal {
+
+template <typename T>
+struct IsSpanImpl : std::false_type {};
+
+template <typename T, size_t Extent>
+struct IsSpanImpl<span<T, Extent>> : std::true_type {};
+
+template <typename T>
+using IsSpan = IsSpanImpl<std::decay_t<T>>;
+
+template <typename T>
+struct IsStdArrayImpl : std::false_type {};
+
+template <typename T, size_t N>
+struct IsStdArrayImpl<std::array<T, N>> : std::true_type {};
+
+template <typename T>
+using IsStdArray = IsStdArrayImpl<std::decay_t<T>>;
+
+template <typename T>
+using IsCArray = std::is_array<std::remove_reference_t<T>>;
+
+template <typename From, typename To>
+using IsLegalDataConversion = std::is_convertible<From (*)[], To (*)[]>;
+
+template <typename Container, typename T>
+using ContainerHasConvertibleData = IsLegalDataConversion<
+    std::remove_pointer_t<decltype(base::data(std::declval<Container>()))>,
+    T>;
+
+template <typename Container>
+using ContainerHasIntegralSize =
+    std::is_integral<decltype(base::size(std::declval<Container>()))>;
+
+template <typename From, size_t FromExtent, typename To, size_t ToExtent>
+using EnableIfLegalSpanConversion =
+    std::enable_if_t<(ToExtent == dynamic_extent || ToExtent == FromExtent) &&
+                     IsLegalDataConversion<From, To>::value>;
+
+// SFINAE check if Array can be converted to a span<T>.
+template <typename Array, size_t N, typename T, size_t Extent>
+using EnableIfSpanCompatibleArray =
+    std::enable_if_t<(Extent == dynamic_extent || Extent == N) &&
+                     ContainerHasConvertibleData<Array, T>::value>;
+
+// SFINAE check if Container can be converted to a span<T>.
+template <typename Container, typename T>
+using EnableIfSpanCompatibleContainer =
+    std::enable_if_t<!internal::IsSpan<Container>::value &&
+                     !internal::IsStdArray<Container>::value &&
+                     !internal::IsCArray<Container>::value &&
+                     ContainerHasConvertibleData<Container, T>::value &&
+                     ContainerHasIntegralSize<Container>::value>;
+
+}  // namespace internal
+
+// A span is a value type that represents an array of elements of type T. Since
+// it only consists of a pointer to memory with an associated size, it is very
+// light-weight. It is cheap to construct, copy, move and use spans, so that
+// users are encouraged to use it as a pass-by-value parameter. A span does not
+// own the underlying memory, so care must be taken to ensure that a span does
+// not outlive the backing store.
+//
+// span is somewhat analogous to StringPiece, but with arbitrary element types,
+// allowing mutation if T is non-const.
+//
+// span is implicitly convertible from C++ arrays, as well as most [1]
+// container-like types that provide a data() and size() method (such as
+// std::vector<T>). A mutable span<T> can also be implicitly converted to an
+// immutable span<const T>.
+//
+// Consider using a span for functions that take a data pointer and size
+// parameter: it allows the function to still act on an array-like type, while
+// allowing the caller code to be a bit more concise.
+//
+// For read-only data access pass a span<const T>: the caller can supply either
+// a span<const T> or a span<T>, while the callee will have a read-only view.
+// For read-write access a mutable span<T> is required.
+//
+// Without span:
+//   Read-Only:
+//     // std::string HexEncode(const uint8_t* data, size_t size);
+//     std::vector<uint8_t> data_buffer = GenerateData();
+//     std::string r = HexEncode(data_buffer.data(), data_buffer.size());
+//
+//  Mutable:
+//     // ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt, Args...);
+//     char str_buffer[100];
+//     SafeSNPrintf(str_buffer, sizeof(str_buffer), "Pi ~= %lf", 3.14);
+//
+// With span:
+//   Read-Only:
+//     // std::string HexEncode(base::span<const uint8_t> data);
+//     std::vector<uint8_t> data_buffer = GenerateData();
+//     std::string r = HexEncode(data_buffer);
+//
+//  Mutable:
+//     // ssize_t SafeSNPrintf(base::span<char>, const char* fmt, Args...);
+//     char str_buffer[100];
+//     SafeSNPrintf(str_buffer, "Pi ~= %lf", 3.14);
+//
+// Spans with "const" and pointers
+// -------------------------------
+//
+// Const and pointers can get confusing. Here are vectors of pointers and their
+// corresponding spans:
+//
+//   const std::vector<int*>        =>  base::span<int* const>
+//   std::vector<const int*>        =>  base::span<const int*>
+//   const std::vector<const int*>  =>  base::span<const int* const>
+//
+// Differences from the working group proposal
+// -------------------------------------------
+//
+// https://wg21.link/P0122 is the latest working group proposal, Chromium
+// currently implements R7. Differences between the proposal and the
+// implementation are documented in subsections below.
+//
+// Differences from [span.objectrep]:
+// - as_bytes() and as_writable_bytes() return spans of uint8_t instead of
+//   std::byte
+//
+// Differences in constants and types:
+// - index_type is aliased to size_t
+//
+// Differences from [span.sub]:
+// - using size_t instead of ptrdiff_t for indexing
+//
+// Differences from [span.obs]:
+// - using size_t instead of ptrdiff_t to represent size()
+//
+// Differences from [span.elem]:
+// - using size_t instead of ptrdiff_t for indexing
+//
+// Furthermore, all constructors and methods are marked noexcept due to the lack
+// of exceptions in Chromium.
+//
+// Due to the lack of class template argument deduction guides in C++14
+// appropriate make_span() utility functions are provided.
+
+// [span], class template span
+template <typename T, size_t Extent>
+class span {
+ public:
+  using element_type = T;
+  using value_type = std::remove_cv_t<T>;
+  using index_type = size_t;
+  using difference_type = ptrdiff_t;
+  using pointer = T*;
+  using reference = T&;
+  using iterator = T*;
+  using const_iterator = const T*;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+  static constexpr index_type extent = Extent;
+
+  // [span.cons], span constructors, copy, assignment, and destructor
+  constexpr span() noexcept : data_(nullptr), size_(0) {
+    static_assert(Extent == dynamic_extent || Extent == 0, "Invalid Extent");
+  }
+
+  constexpr span(T* data, size_t size) noexcept : data_(data), size_(size) {
+    CHECK(Extent == dynamic_extent || Extent == size);
+  }
+
+  // Artificially templatized to break ambiguity for span(ptr, 0).
+  template <typename = void>
+  constexpr span(T* begin, T* end) noexcept : span(begin, end - begin) {
+    // Note: CHECK_LE is not constexpr, hence regular CHECK must be used.
+    CHECK(begin <= end);
+  }
+
+  template <
+      size_t N,
+      typename = internal::EnableIfSpanCompatibleArray<T (&)[N], N, T, Extent>>
+  constexpr span(T (&array)[N]) noexcept : span(base::data(array), N) {}
+
+  template <
+      size_t N,
+      typename = internal::
+          EnableIfSpanCompatibleArray<std::array<value_type, N>&, N, T, Extent>>
+  constexpr span(std::array<value_type, N>& array) noexcept
+      : span(base::data(array), N) {}
+
+  template <size_t N,
+            typename = internal::EnableIfSpanCompatibleArray<
+                const std::array<value_type, N>&,
+                N,
+                T,
+                Extent>>
+  constexpr span(const std::array<value_type, N>& array) noexcept
+      : span(base::data(array), N) {}
+
+  // Conversion from a container that has compatible base::data() and integral
+  // base::size().
+  template <typename Container,
+            typename = internal::EnableIfSpanCompatibleContainer<Container&, T>>
+  constexpr span(Container& container) noexcept
+      : span(base::data(container), base::size(container)) {}
+
+  template <
+      typename Container,
+      typename = internal::EnableIfSpanCompatibleContainer<const Container&, T>>
+  span(const Container& container) noexcept
+      : span(base::data(container), base::size(container)) {}
+
+  constexpr span(const span& other) noexcept = default;
+
+  // Conversions from spans of compatible types and extents: this allows a
+  // span<T> to be seamlessly used as a span<const T>, but not the other way
+  // around. If extent is not dynamic, OtherExtent has to be equal to Extent.
+  template <
+      typename U,
+      size_t OtherExtent,
+      typename =
+          internal::EnableIfLegalSpanConversion<U, OtherExtent, T, Extent>>
+  constexpr span(const span<U, OtherExtent>& other)
+      : span(other.data(), other.size()) {}
+
+  constexpr span& operator=(const span& other) noexcept = default;
+  ~span() noexcept = default;
+
+  // [span.sub], span subviews
+  template <size_t Count>
+  constexpr span<T, Count> first() const noexcept {
+    static_assert(Extent == dynamic_extent || Count <= Extent,
+                  "Count must not exceed Extent");
+    CHECK(Extent != dynamic_extent || Count <= size());
+    return {data(), Count};
+  }
+
+  template <size_t Count>
+  constexpr span<T, Count> last() const noexcept {
+    static_assert(Extent == dynamic_extent || Count <= Extent,
+                  "Count must not exceed Extent");
+    CHECK(Extent != dynamic_extent || Count <= size());
+    return {data() + (size() - Count), Count};
+  }
+
+  template <size_t Offset, size_t Count = dynamic_extent>
+  constexpr span<T,
+                 (Count != dynamic_extent
+                     ? Count
+                     : (Extent != dynamic_extent ? Extent - Offset
+                                                 : dynamic_extent))>
+  subspan() const noexcept {
+    static_assert(Extent == dynamic_extent || Offset <= Extent,
+                  "Offset must not exceed Extent");
+    static_assert(Extent == dynamic_extent || Count == dynamic_extent ||
+                      Count <= Extent - Offset,
+                  "Count must not exceed Extent - Offset");
+    CHECK(Extent != dynamic_extent || Offset <= size());
+    CHECK(Extent != dynamic_extent || Count == dynamic_extent ||
+          Count <= size() - Offset);
+    return {data() + Offset, Count != dynamic_extent ? Count : size() - Offset};
+  }
+
+  constexpr span<T, dynamic_extent> first(size_t count) const noexcept {
+    // Note: CHECK_LE is not constexpr, hence regular CHECK must be used.
+    CHECK(count <= size());
+    return {data(), count};
+  }
+
+  constexpr span<T, dynamic_extent> last(size_t count) const noexcept {
+    // Note: CHECK_LE is not constexpr, hence regular CHECK must be used.
+    CHECK(count <= size());
+    return {data() + (size() - count), count};
+  }
+
+  constexpr span<T, dynamic_extent> subspan(size_t offset,
+                                            size_t count = dynamic_extent) const
+      noexcept {
+    // Note: CHECK_LE is not constexpr, hence regular CHECK must be used.
+    CHECK(offset <= size());
+    CHECK(count == dynamic_extent || count <= size() - offset);
+    return {data() + offset, count != dynamic_extent ? count : size() - offset};
+  }
+
+  // [span.obs], span observers
+  constexpr size_t size() const noexcept { return size_; }
+  constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }
+  constexpr bool empty() const noexcept { return size() == 0; }
+
+  // [span.elem], span element access
+  constexpr T& operator[](size_t idx) const noexcept {
+    // Note: CHECK_LT is not constexpr, hence regular CHECK must be used.
+    CHECK(idx < size());
+    return *(data() + idx);
+  }
+
+  constexpr T& operator()(size_t idx) const noexcept {
+    // Note: CHECK_LT is not constexpr, hence regular CHECK must be used.
+    CHECK(idx < size());
+    return *(data() + idx);
+  }
+
+  constexpr T* data() const noexcept { return data_; }
+
+  // [span.iter], span iterator support
+  constexpr iterator begin() const noexcept { return data(); }
+  constexpr iterator end() const noexcept { return data() + size(); }
+
+  constexpr const_iterator cbegin() const noexcept { return begin(); }
+  constexpr const_iterator cend() const noexcept { return end(); }
+
+  constexpr reverse_iterator rbegin() const noexcept {
+    return reverse_iterator(end());
+  }
+  constexpr reverse_iterator rend() const noexcept {
+    return reverse_iterator(begin());
+  }
+
+  constexpr const_reverse_iterator crbegin() const noexcept {
+    return const_reverse_iterator(cend());
+  }
+  constexpr const_reverse_iterator crend() const noexcept {
+    return const_reverse_iterator(cbegin());
+  }
+
+ private:
+  T* data_;
+  size_t size_;
+};
+
+// span<T, Extent>::extent can not be declared inline prior to C++17, hence this
+// definition is required.
+template <class T, size_t Extent>
+constexpr size_t span<T, Extent>::extent;
+
+// [span.comparison], span comparison operators
+// Relational operators. Equality is a element-wise comparison.
+template <typename T, size_t X, typename U, size_t Y>
+constexpr bool operator==(span<T, X> lhs, span<U, Y> rhs) noexcept {
+  return std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend());
+}
+
+template <typename T, size_t X, typename U, size_t Y>
+constexpr bool operator!=(span<T, X> lhs, span<U, Y> rhs) noexcept {
+  return !(lhs == rhs);
+}
+
+template <typename T, size_t X, typename U, size_t Y>
+constexpr bool operator<(span<T, X> lhs, span<U, Y> rhs) noexcept {
+  return std::lexicographical_compare(lhs.cbegin(), lhs.cend(), rhs.cbegin(),
+                                      rhs.cend());
+}
+
+template <typename T, size_t X, typename U, size_t Y>
+constexpr bool operator<=(span<T, X> lhs, span<U, Y> rhs) noexcept {
+  return !(rhs < lhs);
+}
+
+template <typename T, size_t X, typename U, size_t Y>
+constexpr bool operator>(span<T, X> lhs, span<U, Y> rhs) noexcept {
+  return rhs < lhs;
+}
+
+template <typename T, size_t X, typename U, size_t Y>
+constexpr bool operator>=(span<T, X> lhs, span<U, Y> rhs) noexcept {
+  return !(lhs < rhs);
+}
+
+// [span.objectrep], views of object representation
+template <typename T, size_t X>
+span<const uint8_t, (X == dynamic_extent ? dynamic_extent : sizeof(T) * X)>
+as_bytes(span<T, X> s) noexcept {
+  return {reinterpret_cast<const uint8_t*>(s.data()), s.size_bytes()};
+}
+
+template <typename T,
+          size_t X,
+          typename = std::enable_if_t<!std::is_const<T>::value>>
+span<uint8_t, (X == dynamic_extent ? dynamic_extent : sizeof(T) * X)>
+as_writable_bytes(span<T, X> s) noexcept {
+  return {reinterpret_cast<uint8_t*>(s.data()), s.size_bytes()};
+}
+
+// Type-deducing helpers for constructing a span.
+template <typename T>
+constexpr span<T> make_span(T* data, size_t size) noexcept {
+  return {data, size};
+}
+
+template <typename T>
+constexpr span<T> make_span(T* begin, T* end) noexcept {
+  return {begin, end};
+}
+
+template <typename T, size_t N>
+constexpr span<T, N> make_span(T (&array)[N]) noexcept {
+  return array;
+}
+
+template <typename T, size_t N>
+constexpr span<T, N> make_span(std::array<T, N>& array) noexcept {
+  return array;
+}
+
+template <typename T, size_t N>
+constexpr span<const T, N> make_span(const std::array<T, N>& array) noexcept {
+  return array;
+}
+
+template <typename Container,
+          typename T = typename Container::value_type,
+          typename = internal::EnableIfSpanCompatibleContainer<Container&, T>>
+constexpr span<T> make_span(Container& container) noexcept {
+  return container;
+}
+
+template <
+    typename Container,
+    typename T = const typename Container::value_type,
+    typename = internal::EnableIfSpanCompatibleContainer<const Container&, T>>
+constexpr span<T> make_span(const Container& container) noexcept {
+  return container;
+}
+
+template <typename T, size_t X>
+constexpr span<T, X> make_span(const span<T, X>& span) noexcept {
+  return span;
+}
+
+}  // namespace base
+
+#endif  // BASE_CONTAINERS_SPAN_H_
diff --git a/native/zucchini/vendor/libchrome/base/containers/stack.h b/native/zucchini/vendor/libchrome/base/containers/stack.h
new file mode 100644
index 0000000..5cf06f8
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/containers/stack.h
@@ -0,0 +1,23 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_CONTAINERS_STACK_H_
+#define BASE_CONTAINERS_STACK_H_
+
+#include <stack>
+
+#include "base/containers/circular_deque.h"
+
+namespace base {
+
+// Provides a definition of base::stack that's like std::stack but uses a
+// base::circular_deque instead of std::deque. Since std::stack is just a
+// wrapper for an underlying type, we can just provide a typedef for it that
+// defaults to the base circular_deque.
+template <class T, class Container = circular_deque<T>>
+using stack = std::stack<T, Container>;
+
+}  // namespace base
+
+#endif  // BASE_CONTAINERS_STACK_H_
diff --git a/native/zucchini/vendor/libchrome/base/containers/vector_buffer.h b/native/zucchini/vendor/libchrome/base/containers/vector_buffer.h
new file mode 100644
index 0000000..a72c1ed
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/containers/vector_buffer.h
@@ -0,0 +1,163 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_CONTAINERS_VECTOR_BUFFERS_H_
+#define BASE_CONTAINERS_VECTOR_BUFFERS_H_
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <type_traits>
+#include <utility>
+
+#include "base/logging.h"
+#include "base/macros.h"
+
+namespace base {
+namespace internal {
+
+// Internal implementation detail of base/containers.
+//
+// Implements a vector-like buffer that holds a certain capacity of T. Unlike
+// std::vector, VectorBuffer never constructs or destructs its arguments, and
+// can't change sizes. But it does implement templates to assist in efficient
+// moving and destruction of those items manually.
+//
+// In particular, the destructor function does not iterate over the items if
+// there is no destructor. Moves should be implemented as a memcpy/memmove for
+// trivially copyable objects (POD) otherwise, it should be a std::move if
+// possible, and as a last resort it falls back to a copy. This behavior is
+// similar to std::vector.
+//
+// No special consideration is done for noexcept move constructors since
+// we compile without exceptions.
+//
+// The current API does not support moving overlapping ranges.
+template <typename T>
+class VectorBuffer {
+ public:
+  constexpr VectorBuffer() = default;
+
+#if defined(__clang__) && !defined(__native_client__)
+  // This constructor converts an uninitialized void* to a T* which triggers
+  // clang Control Flow Integrity. Since this is as-designed, disable.
+  __attribute__((no_sanitize("cfi-unrelated-cast", "vptr")))
+#endif
+  VectorBuffer(size_t count)
+      : buffer_(reinterpret_cast<T*>(malloc(sizeof(T) * count))),
+        capacity_(count) {
+  }
+  VectorBuffer(VectorBuffer&& other) noexcept
+      : buffer_(other.buffer_), capacity_(other.capacity_) {
+    other.buffer_ = nullptr;
+    other.capacity_ = 0;
+  }
+
+  ~VectorBuffer() { free(buffer_); }
+
+  VectorBuffer& operator=(VectorBuffer&& other) {
+    free(buffer_);
+    buffer_ = other.buffer_;
+    capacity_ = other.capacity_;
+
+    other.buffer_ = nullptr;
+    other.capacity_ = 0;
+    return *this;
+  }
+
+  size_t capacity() const { return capacity_; }
+
+  T& operator[](size_t i) { return buffer_[i]; }
+  const T& operator[](size_t i) const { return buffer_[i]; }
+  T* begin() { return buffer_; }
+  T* end() { return &buffer_[capacity_]; }
+
+  // DestructRange ------------------------------------------------------------
+
+  // Trivially destructible objects need not have their destructors called.
+  template <typename T2 = T,
+            typename std::enable_if<std::is_trivially_destructible<T2>::value,
+                                    int>::type = 0>
+  void DestructRange(T* begin, T* end) {}
+
+  // Non-trivially destructible objects must have their destructors called
+  // individually.
+  template <typename T2 = T,
+            typename std::enable_if<!std::is_trivially_destructible<T2>::value,
+                                    int>::type = 0>
+  void DestructRange(T* begin, T* end) {
+    while (begin != end) {
+      begin->~T();
+      begin++;
+    }
+  }
+
+  // MoveRange ----------------------------------------------------------------
+  //
+  // The destructor will be called (as necessary) for all moved types. The
+  // ranges must not overlap.
+  //
+  // The parameters and begin and end (one past the last) of the input buffer,
+  // and the address of the first element to copy to. There must be sufficient
+  // room in the destination for all items in the range [begin, end).
+
+  // Trivially copyable types can use memcpy. trivially copyable implies
+  // that there is a trivial destructor as we don't have to call it.
+  template <typename T2 = T,
+            typename std::enable_if<base::is_trivially_copyable<T2>::value,
+                                    int>::type = 0>
+  static void MoveRange(T* from_begin, T* from_end, T* to) {
+    DCHECK(!RangesOverlap(from_begin, from_end, to));
+    memcpy(to, from_begin, (from_end - from_begin) * sizeof(T));
+  }
+
+  // Not trivially copyable, but movable: call the move constructor and
+  // destruct the original.
+  template <typename T2 = T,
+            typename std::enable_if<std::is_move_constructible<T2>::value &&
+                                        !base::is_trivially_copyable<T2>::value,
+                                    int>::type = 0>
+  static void MoveRange(T* from_begin, T* from_end, T* to) {
+    DCHECK(!RangesOverlap(from_begin, from_end, to));
+    while (from_begin != from_end) {
+      new (to) T(std::move(*from_begin));
+      from_begin->~T();
+      from_begin++;
+      to++;
+    }
+  }
+
+  // Not movable, not trivially copyable: call the copy constructor and
+  // destruct the original.
+  template <typename T2 = T,
+            typename std::enable_if<!std::is_move_constructible<T2>::value &&
+                                        !base::is_trivially_copyable<T2>::value,
+                                    int>::type = 0>
+  static void MoveRange(T* from_begin, T* from_end, T* to) {
+    DCHECK(!RangesOverlap(from_begin, from_end, to));
+    while (from_begin != from_end) {
+      new (to) T(*from_begin);
+      from_begin->~T();
+      from_begin++;
+      to++;
+    }
+  }
+
+ private:
+  static bool RangesOverlap(const T* from_begin,
+                            const T* from_end,
+                            const T* to) {
+    return !(to >= from_end || to + (from_end - from_begin) <= from_begin);
+  }
+
+  T* buffer_ = nullptr;
+  size_t capacity_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(VectorBuffer);
+};
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_CONTAINERS_VECTOR_BUFFERS_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/activity_tracker.cc b/native/zucchini/vendor/libchrome/base/debug/activity_tracker.cc
new file mode 100644
index 0000000..24cfa5a
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/debug/activity_tracker.cc
@@ -0,0 +1,1828 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/debug/activity_tracker.h"
+
+#include <algorithm>
+#include <limits>
+#include <utility>
+
+#include "base/atomic_sequence_num.h"
+#include "base/debug/stack_trace.h"
+#include "base/files/file.h"
+#include "base/files/file_path.h"
+#include "base/files/memory_mapped_file.h"
+#include "base/logging.h"
+#include "base/memory/ptr_util.h"
+#include "base/metrics/field_trial.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/pending_task.h"
+#include "base/pickle.h"
+#include "base/process/process.h"
+#include "base/process/process_handle.h"
+#include "base/stl_util.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/threading/platform_thread.h"
+#include "build/build_config.h"
+
+namespace base {
+namespace debug {
+
+namespace {
+
+// The minimum depth a stack should support.
+const int kMinStackDepth = 2;
+
+// The amount of memory set aside for holding arbitrary user data (key/value
+// pairs) globally or associated with ActivityData entries.
+const size_t kUserDataSize = 1 << 10;     // 1 KiB
+const size_t kProcessDataSize = 4 << 10;  // 4 KiB
+const size_t kMaxUserDataNameLength =
+    static_cast<size_t>(std::numeric_limits<uint8_t>::max());
+
+// A constant used to indicate that module information is changing.
+const uint32_t kModuleInformationChanging = 0x80000000;
+
+// The key used to record process information.
+const char kProcessPhaseDataKey[] = "process-phase";
+
+// An atomically incrementing number, used to check for recreations of objects
+// in the same memory space.
+AtomicSequenceNumber g_next_id;
+
+// Gets the next non-zero identifier. It is only unique within a process.
+uint32_t GetNextDataId() {
+  uint32_t id;
+  while ((id = g_next_id.GetNext()) == 0)
+    ;
+  return id;
+}
+
+// Gets the current process-id, either from the GlobalActivityTracker if it
+// exists (where the PID can be defined for testing) or from the system if
+// there isn't such.
+int64_t GetProcessId() {
+  GlobalActivityTracker* global = GlobalActivityTracker::Get();
+  if (global)
+    return global->process_id();
+  return GetCurrentProcId();
+}
+
+// Finds and reuses a specific allocation or creates a new one.
+PersistentMemoryAllocator::Reference AllocateFrom(
+    PersistentMemoryAllocator* allocator,
+    uint32_t from_type,
+    size_t size,
+    uint32_t to_type) {
+  PersistentMemoryAllocator::Iterator iter(allocator);
+  PersistentMemoryAllocator::Reference ref;
+  while ((ref = iter.GetNextOfType(from_type)) != 0) {
+    DCHECK_LE(size, allocator->GetAllocSize(ref));
+    // This can fail if a another thread has just taken it. It is assumed that
+    // the memory is cleared during the "free" operation.
+    if (allocator->ChangeType(ref, to_type, from_type, /*clear=*/false))
+      return ref;
+  }
+
+  return allocator->Allocate(size, to_type);
+}
+
+// Determines the previous aligned index.
+size_t RoundDownToAlignment(size_t index, size_t alignment) {
+  return index & (0 - alignment);
+}
+
+// Determines the next aligned index.
+size_t RoundUpToAlignment(size_t index, size_t alignment) {
+  return (index + (alignment - 1)) & (0 - alignment);
+}
+
+// Converts "tick" timing into wall time.
+Time WallTimeFromTickTime(int64_t ticks_start, int64_t ticks, Time time_start) {
+  return time_start + TimeDelta::FromInternalValue(ticks - ticks_start);
+}
+
+}  // namespace
+
+union ThreadRef {
+  int64_t as_id;
+#if defined(OS_WIN)
+  // On Windows, the handle itself is often a pseudo-handle with a common
+  // value meaning "this thread" and so the thread-id is used. The former
+  // can be converted to a thread-id with a system call.
+  PlatformThreadId as_tid;
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  // On Posix and Fuchsia, the handle is always a unique identifier so no
+  // conversion needs to be done. However, its value is officially opaque so
+  // there is no one correct way to convert it to a numerical identifier.
+  PlatformThreadHandle::Handle as_handle;
+#endif
+};
+
+OwningProcess::OwningProcess() = default;
+OwningProcess::~OwningProcess() = default;
+
+void OwningProcess::Release_Initialize(int64_t pid) {
+  uint32_t old_id = data_id.load(std::memory_order_acquire);
+  DCHECK_EQ(0U, old_id);
+  process_id = pid != 0 ? pid : GetProcessId();
+  create_stamp = Time::Now().ToInternalValue();
+  data_id.store(GetNextDataId(), std::memory_order_release);
+}
+
+void OwningProcess::SetOwningProcessIdForTesting(int64_t pid, int64_t stamp) {
+  DCHECK_NE(0U, data_id);
+  process_id = pid;
+  create_stamp = stamp;
+}
+
+// static
+bool OwningProcess::GetOwningProcessId(const void* memory,
+                                       int64_t* out_id,
+                                       int64_t* out_stamp) {
+  const OwningProcess* info = reinterpret_cast<const OwningProcess*>(memory);
+  uint32_t id = info->data_id.load(std::memory_order_acquire);
+  if (id == 0)
+    return false;
+
+  *out_id = info->process_id;
+  *out_stamp = info->create_stamp;
+  return id == info->data_id.load(std::memory_order_seq_cst);
+}
+
+// It doesn't matter what is contained in this (though it will be all zeros)
+// as only the address of it is important.
+const ActivityData kNullActivityData = {};
+
+ActivityData ActivityData::ForThread(const PlatformThreadHandle& handle) {
+  ThreadRef thread_ref;
+  thread_ref.as_id = 0;  // Zero the union in case other is smaller.
+#if defined(OS_WIN)
+  thread_ref.as_tid = ::GetThreadId(handle.platform_handle());
+#elif defined(OS_POSIX)
+  thread_ref.as_handle = handle.platform_handle();
+#endif
+  return ForThread(thread_ref.as_id);
+}
+
+ActivityTrackerMemoryAllocator::ActivityTrackerMemoryAllocator(
+    PersistentMemoryAllocator* allocator,
+    uint32_t object_type,
+    uint32_t object_free_type,
+    size_t object_size,
+    size_t cache_size,
+    bool make_iterable)
+    : allocator_(allocator),
+      object_type_(object_type),
+      object_free_type_(object_free_type),
+      object_size_(object_size),
+      cache_size_(cache_size),
+      make_iterable_(make_iterable),
+      iterator_(allocator),
+      cache_values_(new Reference[cache_size]),
+      cache_used_(0) {
+  DCHECK(allocator);
+}
+
+ActivityTrackerMemoryAllocator::~ActivityTrackerMemoryAllocator() = default;
+
+ActivityTrackerMemoryAllocator::Reference
+ActivityTrackerMemoryAllocator::GetObjectReference() {
+  // First see if there is a cached value that can be returned. This is much
+  // faster than searching the memory system for free blocks.
+  while (cache_used_ > 0) {
+    Reference cached = cache_values_[--cache_used_];
+    // Change the type of the cached object to the proper type and return it.
+    // If the type-change fails that means another thread has taken this from
+    // under us (via the search below) so ignore it and keep trying. Don't
+    // clear the memory because that was done when the type was made "free".
+    if (allocator_->ChangeType(cached, object_type_, object_free_type_, false))
+      return cached;
+  }
+
+  // Fetch the next "free" object from persistent memory. Rather than restart
+  // the iterator at the head each time and likely waste time going again
+  // through objects that aren't relevant, the iterator continues from where
+  // it last left off and is only reset when the end is reached. If the
+  // returned reference matches |last|, then it has wrapped without finding
+  // anything.
+  const Reference last = iterator_.GetLast();
+  while (true) {
+    uint32_t type;
+    Reference found = iterator_.GetNext(&type);
+    if (found && type == object_free_type_) {
+      // Found a free object. Change it to the proper type and return it. If
+      // the type-change fails that means another thread has taken this from
+      // under us so ignore it and keep trying.
+      if (allocator_->ChangeType(found, object_type_, object_free_type_, false))
+        return found;
+    }
+    if (found == last) {
+      // Wrapped. No desired object was found.
+      break;
+    }
+    if (!found) {
+      // Reached end; start over at the beginning.
+      iterator_.Reset();
+    }
+  }
+
+  // No free block was found so instead allocate a new one.
+  Reference allocated = allocator_->Allocate(object_size_, object_type_);
+  if (allocated && make_iterable_)
+    allocator_->MakeIterable(allocated);
+  return allocated;
+}
+
+void ActivityTrackerMemoryAllocator::ReleaseObjectReference(Reference ref) {
+  // Mark object as free.
+  bool success = allocator_->ChangeType(ref, object_free_type_, object_type_,
+                                        /*clear=*/true);
+  DCHECK(success);
+
+  // Add this reference to our "free" cache if there is space. If not, the type
+  // has still been changed to indicate that it is free so this (or another)
+  // thread can find it, albeit more slowly, using the iteration method above.
+  if (cache_used_ < cache_size_)
+    cache_values_[cache_used_++] = ref;
+}
+
+// static
+void Activity::FillFrom(Activity* activity,
+                        const void* program_counter,
+                        const void* origin,
+                        Type type,
+                        const ActivityData& data) {
+  activity->time_internal = base::TimeTicks::Now().ToInternalValue();
+  activity->calling_address = reinterpret_cast<uintptr_t>(program_counter);
+  activity->origin_address = reinterpret_cast<uintptr_t>(origin);
+  activity->activity_type = type;
+  activity->data = data;
+
+#if (!defined(OS_NACL) && DCHECK_IS_ON()) || defined(ADDRESS_SANITIZER)
+  // Create a stacktrace from the current location and get the addresses for
+  // improved debuggability.
+  StackTrace stack_trace;
+  size_t stack_depth;
+  const void* const* stack_addrs = stack_trace.Addresses(&stack_depth);
+  // Copy the stack addresses, ignoring the first one (here).
+  size_t i;
+  for (i = 1; i < stack_depth && i < kActivityCallStackSize; ++i) {
+    activity->call_stack[i - 1] = reinterpret_cast<uintptr_t>(stack_addrs[i]);
+  }
+  activity->call_stack[i - 1] = 0;
+#else
+  activity->call_stack[0] = 0;
+#endif
+}
+
+ActivityUserData::TypedValue::TypedValue() = default;
+ActivityUserData::TypedValue::TypedValue(const TypedValue& other) = default;
+ActivityUserData::TypedValue::~TypedValue() = default;
+
+StringPiece ActivityUserData::TypedValue::Get() const {
+  DCHECK_EQ(RAW_VALUE, type_);
+  return long_value_;
+}
+
+StringPiece ActivityUserData::TypedValue::GetString() const {
+  DCHECK_EQ(STRING_VALUE, type_);
+  return long_value_;
+}
+
+bool ActivityUserData::TypedValue::GetBool() const {
+  DCHECK_EQ(BOOL_VALUE, type_);
+  return short_value_ != 0;
+}
+
+char ActivityUserData::TypedValue::GetChar() const {
+  DCHECK_EQ(CHAR_VALUE, type_);
+  return static_cast<char>(short_value_);
+}
+
+int64_t ActivityUserData::TypedValue::GetInt() const {
+  DCHECK_EQ(SIGNED_VALUE, type_);
+  return static_cast<int64_t>(short_value_);
+}
+
+uint64_t ActivityUserData::TypedValue::GetUint() const {
+  DCHECK_EQ(UNSIGNED_VALUE, type_);
+  return static_cast<uint64_t>(short_value_);
+}
+
+StringPiece ActivityUserData::TypedValue::GetReference() const {
+  DCHECK_EQ(RAW_VALUE_REFERENCE, type_);
+  return ref_value_;
+}
+
+StringPiece ActivityUserData::TypedValue::GetStringReference() const {
+  DCHECK_EQ(STRING_VALUE_REFERENCE, type_);
+  return ref_value_;
+}
+
+// These are required because std::atomic is (currently) not a POD type and
+// thus clang requires explicit out-of-line constructors and destructors even
+// when they do nothing.
+ActivityUserData::ValueInfo::ValueInfo() = default;
+ActivityUserData::ValueInfo::ValueInfo(ValueInfo&&) = default;
+ActivityUserData::ValueInfo::~ValueInfo() = default;
+ActivityUserData::MemoryHeader::MemoryHeader() = default;
+ActivityUserData::MemoryHeader::~MemoryHeader() = default;
+ActivityUserData::FieldHeader::FieldHeader() = default;
+ActivityUserData::FieldHeader::~FieldHeader() = default;
+
+ActivityUserData::ActivityUserData() : ActivityUserData(nullptr, 0, -1) {}
+
+ActivityUserData::ActivityUserData(void* memory, size_t size, int64_t pid)
+    : memory_(reinterpret_cast<char*>(memory)),
+      available_(RoundDownToAlignment(size, kMemoryAlignment)),
+      header_(reinterpret_cast<MemoryHeader*>(memory)),
+      orig_data_id(0),
+      orig_process_id(0),
+      orig_create_stamp(0) {
+  // It's possible that no user data is being stored.
+  if (!memory_)
+    return;
+
+  static_assert(0 == sizeof(MemoryHeader) % kMemoryAlignment, "invalid header");
+  DCHECK_LT(sizeof(MemoryHeader), available_);
+  if (header_->owner.data_id.load(std::memory_order_acquire) == 0)
+    header_->owner.Release_Initialize(pid);
+  memory_ += sizeof(MemoryHeader);
+  available_ -= sizeof(MemoryHeader);
+
+  // Make a copy of identifying information for later comparison.
+  *const_cast<uint32_t*>(&orig_data_id) =
+      header_->owner.data_id.load(std::memory_order_acquire);
+  *const_cast<int64_t*>(&orig_process_id) = header_->owner.process_id;
+  *const_cast<int64_t*>(&orig_create_stamp) = header_->owner.create_stamp;
+
+  // If there is already data present, load that. This allows the same class
+  // to be used for analysis through snapshots.
+  ImportExistingData();
+}
+
+ActivityUserData::~ActivityUserData() = default;
+
+bool ActivityUserData::CreateSnapshot(Snapshot* output_snapshot) const {
+  DCHECK(output_snapshot);
+  DCHECK(output_snapshot->empty());
+
+  // Find any new data that may have been added by an active instance of this
+  // class that is adding records.
+  ImportExistingData();
+
+  // Add all the values to the snapshot.
+  for (const auto& entry : values_) {
+    TypedValue value;
+    const size_t size = entry.second.size_ptr->load(std::memory_order_acquire);
+    value.type_ = entry.second.type;
+    DCHECK_GE(entry.second.extent, size);
+
+    switch (entry.second.type) {
+      case RAW_VALUE:
+      case STRING_VALUE:
+        value.long_value_ =
+            std::string(reinterpret_cast<char*>(entry.second.memory), size);
+        break;
+      case RAW_VALUE_REFERENCE:
+      case STRING_VALUE_REFERENCE: {
+        ReferenceRecord* ref =
+            reinterpret_cast<ReferenceRecord*>(entry.second.memory);
+        value.ref_value_ = StringPiece(
+            reinterpret_cast<char*>(static_cast<uintptr_t>(ref->address)),
+            static_cast<size_t>(ref->size));
+      } break;
+      case BOOL_VALUE:
+      case CHAR_VALUE:
+        value.short_value_ = *reinterpret_cast<char*>(entry.second.memory);
+        break;
+      case SIGNED_VALUE:
+      case UNSIGNED_VALUE:
+        value.short_value_ = *reinterpret_cast<uint64_t*>(entry.second.memory);
+        break;
+      case END_OF_VALUES:  // Included for completeness purposes.
+        NOTREACHED();
+    }
+    auto inserted = output_snapshot->insert(
+        std::make_pair(entry.second.name.as_string(), std::move(value)));
+    DCHECK(inserted.second);  // True if inserted, false if existed.
+  }
+
+  // Another import attempt will validate that the underlying memory has not
+  // been reused for another purpose. Entries added since the first import
+  // will be ignored here but will be returned if another snapshot is created.
+  ImportExistingData();
+  if (!memory_) {
+    output_snapshot->clear();
+    return false;
+  }
+
+  // Successful snapshot.
+  return true;
+}
+
+const void* ActivityUserData::GetBaseAddress() const {
+  // The |memory_| pointer advances as elements are written but the |header_|
+  // value is always at the start of the block so just return that.
+  return header_;
+}
+
+void ActivityUserData::SetOwningProcessIdForTesting(int64_t pid,
+                                                    int64_t stamp) {
+  if (!header_)
+    return;
+  header_->owner.SetOwningProcessIdForTesting(pid, stamp);
+}
+
+// static
+bool ActivityUserData::GetOwningProcessId(const void* memory,
+                                          int64_t* out_id,
+                                          int64_t* out_stamp) {
+  const MemoryHeader* header = reinterpret_cast<const MemoryHeader*>(memory);
+  return OwningProcess::GetOwningProcessId(&header->owner, out_id, out_stamp);
+}
+
+void ActivityUserData::Set(StringPiece name,
+                           ValueType type,
+                           const void* memory,
+                           size_t size) {
+  DCHECK_GE(std::numeric_limits<uint8_t>::max(), name.length());
+  size = std::min(std::numeric_limits<uint16_t>::max() - (kMemoryAlignment - 1),
+                  size);
+
+  // It's possible that no user data is being stored.
+  if (!memory_)
+    return;
+
+  // The storage of a name is limited so use that limit during lookup.
+  if (name.length() > kMaxUserDataNameLength)
+    name.set(name.data(), kMaxUserDataNameLength);
+
+  ValueInfo* info;
+  auto existing = values_.find(name);
+  if (existing != values_.end()) {
+    info = &existing->second;
+  } else {
+    // The name size is limited to what can be held in a single byte but
+    // because there are not alignment constraints on strings, it's set tight
+    // against the header. Its extent (the reserved space, even if it's not
+    // all used) is calculated so that, when pressed against the header, the
+    // following field will be aligned properly.
+    size_t name_size = name.length();
+    size_t name_extent =
+        RoundUpToAlignment(sizeof(FieldHeader) + name_size, kMemoryAlignment) -
+        sizeof(FieldHeader);
+    size_t value_extent = RoundUpToAlignment(size, kMemoryAlignment);
+
+    // The "base size" is the size of the header and (padded) string key. Stop
+    // now if there's not room enough for even this.
+    size_t base_size = sizeof(FieldHeader) + name_extent;
+    if (base_size > available_)
+      return;
+
+    // The "full size" is the size for storing the entire value.
+    size_t full_size = std::min(base_size + value_extent, available_);
+
+    // If the value is actually a single byte, see if it can be stuffed at the
+    // end of the name extent rather than wasting kMemoryAlignment bytes.
+    if (size == 1 && name_extent > name_size) {
+      full_size = base_size;
+      --name_extent;
+      --base_size;
+    }
+
+    // Truncate the stored size to the amount of available memory. Stop now if
+    // there's not any room for even part of the value.
+    if (size != 0) {
+      size = std::min(full_size - base_size, size);
+      if (size == 0)
+        return;
+    }
+
+    // Allocate a chunk of memory.
+    FieldHeader* header = reinterpret_cast<FieldHeader*>(memory_);
+    memory_ += full_size;
+    available_ -= full_size;
+
+    // Datafill the header and name records. Memory must be zeroed. The |type|
+    // is written last, atomically, to release all the other values.
+    DCHECK_EQ(END_OF_VALUES, header->type.load(std::memory_order_relaxed));
+    DCHECK_EQ(0, header->value_size.load(std::memory_order_relaxed));
+    header->name_size = static_cast<uint8_t>(name_size);
+    header->record_size = full_size;
+    char* name_memory = reinterpret_cast<char*>(header) + sizeof(FieldHeader);
+    void* value_memory =
+        reinterpret_cast<char*>(header) + sizeof(FieldHeader) + name_extent;
+    memcpy(name_memory, name.data(), name_size);
+    header->type.store(type, std::memory_order_release);
+
+    // Create an entry in |values_| so that this field can be found and changed
+    // later on without having to allocate new entries.
+    StringPiece persistent_name(name_memory, name_size);
+    auto inserted =
+        values_.insert(std::make_pair(persistent_name, ValueInfo()));
+    DCHECK(inserted.second);  // True if inserted, false if existed.
+    info = &inserted.first->second;
+    info->name = persistent_name;
+    info->memory = value_memory;
+    info->size_ptr = &header->value_size;
+    info->extent = full_size - sizeof(FieldHeader) - name_extent;
+    info->type = type;
+  }
+
+  // Copy the value data to storage. The |size| is written last, atomically, to
+  // release the copied data. Until then, a parallel reader will just ignore
+  // records with a zero size.
+  DCHECK_EQ(type, info->type);
+  size = std::min(size, info->extent);
+  info->size_ptr->store(0, std::memory_order_seq_cst);
+  memcpy(info->memory, memory, size);
+  info->size_ptr->store(size, std::memory_order_release);
+}
+
+void ActivityUserData::SetReference(StringPiece name,
+                                    ValueType type,
+                                    const void* memory,
+                                    size_t size) {
+  ReferenceRecord rec;
+  rec.address = reinterpret_cast<uintptr_t>(memory);
+  rec.size = size;
+  Set(name, type, &rec, sizeof(rec));
+}
+
+void ActivityUserData::ImportExistingData() const {
+  // It's possible that no user data is being stored.
+  if (!memory_)
+    return;
+
+  while (available_ > sizeof(FieldHeader)) {
+    FieldHeader* header = reinterpret_cast<FieldHeader*>(memory_);
+    ValueType type =
+        static_cast<ValueType>(header->type.load(std::memory_order_acquire));
+    if (type == END_OF_VALUES)
+      return;
+    if (header->record_size > available_)
+      return;
+
+    size_t value_offset = RoundUpToAlignment(
+        sizeof(FieldHeader) + header->name_size, kMemoryAlignment);
+    if (header->record_size == value_offset &&
+        header->value_size.load(std::memory_order_relaxed) == 1) {
+      value_offset -= 1;
+    }
+    if (value_offset + header->value_size > header->record_size)
+      return;
+
+    ValueInfo info;
+    info.name = StringPiece(memory_ + sizeof(FieldHeader), header->name_size);
+    info.type = type;
+    info.memory = memory_ + value_offset;
+    info.size_ptr = &header->value_size;
+    info.extent = header->record_size - value_offset;
+
+    StringPiece key(info.name);
+    values_.insert(std::make_pair(key, std::move(info)));
+
+    memory_ += header->record_size;
+    available_ -= header->record_size;
+  }
+
+  // Check if memory has been completely reused.
+  if (header_->owner.data_id.load(std::memory_order_acquire) != orig_data_id ||
+      header_->owner.process_id != orig_process_id ||
+      header_->owner.create_stamp != orig_create_stamp) {
+    memory_ = nullptr;
+    values_.clear();
+  }
+}
+
+// This information is kept for every thread that is tracked. It is filled
+// the very first time the thread is seen. All fields must be of exact sizes
+// so there is no issue moving between 32 and 64-bit builds.
+struct ThreadActivityTracker::Header {
+  // Defined in .h for analyzer access. Increment this if structure changes!
+  static constexpr uint32_t kPersistentTypeId =
+      GlobalActivityTracker::kTypeIdActivityTracker;
+
+  // Expected size for 32/64-bit check.
+  static constexpr size_t kExpectedInstanceSize =
+      OwningProcess::kExpectedInstanceSize + Activity::kExpectedInstanceSize +
+      72;
+
+  // This information uniquely identifies a process.
+  OwningProcess owner;
+
+  // The thread-id (thread_ref.as_id) to which this data belongs. This number
+  // is not guaranteed to mean anything but combined with the process-id from
+  // OwningProcess is unique among all active trackers.
+  ThreadRef thread_ref;
+
+  // The start-time and start-ticks when the data was created. Each activity
+  // record has a |time_internal| value that can be converted to a "wall time"
+  // with these two values.
+  int64_t start_time;
+  int64_t start_ticks;
+
+  // The number of Activity slots (spaces that can hold an Activity) that
+  // immediately follow this structure in memory.
+  uint32_t stack_slots;
+
+  // Some padding to keep everything 64-bit aligned.
+  uint32_t padding;
+
+  // The current depth of the stack. This may be greater than the number of
+  // slots. If the depth exceeds the number of slots, the newest entries
+  // won't be recorded.
+  std::atomic<uint32_t> current_depth;
+
+  // A memory location used to indicate if changes have been made to the data
+  // that would invalidate an in-progress read of its contents. The active
+  // tracker will increment the value whenever something gets popped from the
+  // stack. A monitoring tracker can check the value before and after access
+  // to know, if it's still the same, that the contents didn't change while
+  // being copied.
+  std::atomic<uint32_t> data_version;
+
+  // The last "exception" activity. This can't be stored on the stack because
+  // that could get popped as things unwind.
+  Activity last_exception;
+
+  // The name of the thread (up to a maximum length). Dynamic-length names
+  // are not practical since the memory has to come from the same persistent
+  // allocator that holds this structure and to which this object has no
+  // reference.
+  char thread_name[32];
+};
+
+ThreadActivityTracker::Snapshot::Snapshot() = default;
+ThreadActivityTracker::Snapshot::~Snapshot() = default;
+
+ThreadActivityTracker::ScopedActivity::ScopedActivity(
+    ThreadActivityTracker* tracker,
+    const void* program_counter,
+    const void* origin,
+    Activity::Type type,
+    const ActivityData& data)
+    : tracker_(tracker) {
+  if (tracker_)
+    activity_id_ = tracker_->PushActivity(program_counter, origin, type, data);
+}
+
+ThreadActivityTracker::ScopedActivity::~ScopedActivity() {
+  if (tracker_)
+    tracker_->PopActivity(activity_id_);
+}
+
+void ThreadActivityTracker::ScopedActivity::ChangeTypeAndData(
+    Activity::Type type,
+    const ActivityData& data) {
+  if (tracker_)
+    tracker_->ChangeActivity(activity_id_, type, data);
+}
+
+ThreadActivityTracker::ThreadActivityTracker(void* base, size_t size)
+    : header_(static_cast<Header*>(base)),
+      stack_(reinterpret_cast<Activity*>(reinterpret_cast<char*>(base) +
+                                         sizeof(Header))),
+#if DCHECK_IS_ON()
+      thread_id_(PlatformThreadRef()),
+#endif
+      stack_slots_(
+          static_cast<uint32_t>((size - sizeof(Header)) / sizeof(Activity))) {
+
+  // Verify the parameters but fail gracefully if they're not valid so that
+  // production code based on external inputs will not crash.  IsValid() will
+  // return false in this case.
+  if (!base ||
+      // Ensure there is enough space for the header and at least a few records.
+      size < sizeof(Header) + kMinStackDepth * sizeof(Activity) ||
+      // Ensure that the |stack_slots_| calculation didn't overflow.
+      (size - sizeof(Header)) / sizeof(Activity) >
+          std::numeric_limits<uint32_t>::max()) {
+    NOTREACHED();
+    return;
+  }
+
+  // Ensure that the thread reference doesn't exceed the size of the ID number.
+  // This won't compile at the global scope because Header is a private struct.
+  static_assert(
+      sizeof(header_->thread_ref) == sizeof(header_->thread_ref.as_id),
+      "PlatformThreadHandle::Handle is too big to hold in 64-bit ID");
+
+  // Ensure that the alignment of Activity.data is properly aligned to a
+  // 64-bit boundary so there are no interoperability-issues across cpu
+  // architectures.
+  static_assert(offsetof(Activity, data) % sizeof(uint64_t) == 0,
+                "ActivityData.data is not 64-bit aligned");
+
+  // Provided memory should either be completely initialized or all zeros.
+  if (header_->owner.data_id.load(std::memory_order_relaxed) == 0) {
+    // This is a new file. Double-check other fields and then initialize.
+    DCHECK_EQ(0, header_->owner.process_id);
+    DCHECK_EQ(0, header_->owner.create_stamp);
+    DCHECK_EQ(0, header_->thread_ref.as_id);
+    DCHECK_EQ(0, header_->start_time);
+    DCHECK_EQ(0, header_->start_ticks);
+    DCHECK_EQ(0U, header_->stack_slots);
+    DCHECK_EQ(0U, header_->current_depth.load(std::memory_order_relaxed));
+    DCHECK_EQ(0U, header_->data_version.load(std::memory_order_relaxed));
+    DCHECK_EQ(0, stack_[0].time_internal);
+    DCHECK_EQ(0U, stack_[0].origin_address);
+    DCHECK_EQ(0U, stack_[0].call_stack[0]);
+    DCHECK_EQ(0U, stack_[0].data.task.sequence_id);
+
+#if defined(OS_WIN)
+    header_->thread_ref.as_tid = PlatformThread::CurrentId();
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+    header_->thread_ref.as_handle =
+        PlatformThread::CurrentHandle().platform_handle();
+#endif
+
+    header_->start_time = base::Time::Now().ToInternalValue();
+    header_->start_ticks = base::TimeTicks::Now().ToInternalValue();
+    header_->stack_slots = stack_slots_;
+    strlcpy(header_->thread_name, PlatformThread::GetName(),
+            sizeof(header_->thread_name));
+
+    // This is done last so as to guarantee that everything above is "released"
+    // by the time this value gets written.
+    header_->owner.Release_Initialize();
+
+    valid_ = true;
+    DCHECK(IsValid());
+  } else {
+    // This is a file with existing data. Perform basic consistency checks.
+    valid_ = true;
+    valid_ = IsValid();
+  }
+}
+
+ThreadActivityTracker::~ThreadActivityTracker() = default;
+
+ThreadActivityTracker::ActivityId ThreadActivityTracker::PushActivity(
+    const void* program_counter,
+    const void* origin,
+    Activity::Type type,
+    const ActivityData& data) {
+  // A thread-checker creates a lock to check the thread-id which means
+  // re-entry into this code if lock acquisitions are being tracked.
+  DCHECK(type == Activity::ACT_LOCK_ACQUIRE || CalledOnValidThread());
+
+  // Get the current depth of the stack. No access to other memory guarded
+  // by this variable is done here so a "relaxed" load is acceptable.
+  uint32_t depth = header_->current_depth.load(std::memory_order_relaxed);
+
+  // Handle the case where the stack depth has exceeded the storage capacity.
+  // Extra entries will be lost leaving only the base of the stack.
+  if (depth >= stack_slots_) {
+    // Since no other threads modify the data, no compare/exchange is needed.
+    // Since no other memory is being modified, a "relaxed" store is acceptable.
+    header_->current_depth.store(depth + 1, std::memory_order_relaxed);
+    return depth;
+  }
+
+  // Get a pointer to the next activity and load it. No atomicity is required
+  // here because the memory is known only to this thread. It will be made
+  // known to other threads once the depth is incremented.
+  Activity::FillFrom(&stack_[depth], program_counter, origin, type, data);
+
+  // Save the incremented depth. Because this guards |activity| memory filled
+  // above that may be read by another thread once the recorded depth changes,
+  // a "release" store is required.
+  header_->current_depth.store(depth + 1, std::memory_order_release);
+
+  // The current depth is used as the activity ID because it simply identifies
+  // an entry. Once an entry is pop'd, it's okay to reuse the ID.
+  return depth;
+}
+
+void ThreadActivityTracker::ChangeActivity(ActivityId id,
+                                           Activity::Type type,
+                                           const ActivityData& data) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(type != Activity::ACT_NULL || &data != &kNullActivityData);
+  DCHECK_LT(id, header_->current_depth.load(std::memory_order_acquire));
+
+  // Update the information if it is being recorded (i.e. within slot limit).
+  if (id < stack_slots_) {
+    Activity* activity = &stack_[id];
+
+    if (type != Activity::ACT_NULL) {
+      DCHECK_EQ(activity->activity_type & Activity::ACT_CATEGORY_MASK,
+                type & Activity::ACT_CATEGORY_MASK);
+      activity->activity_type = type;
+    }
+
+    if (&data != &kNullActivityData)
+      activity->data = data;
+  }
+}
+
+void ThreadActivityTracker::PopActivity(ActivityId id) {
+  // Do an atomic decrement of the depth. No changes to stack entries guarded
+  // by this variable are done here so a "relaxed" operation is acceptable.
+  // |depth| will receive the value BEFORE it was modified which means the
+  // return value must also be decremented. The slot will be "free" after
+  // this call but since only a single thread can access this object, the
+  // data will remain valid until this method returns or calls outside.
+  uint32_t depth =
+      header_->current_depth.fetch_sub(1, std::memory_order_relaxed) - 1;
+
+  // Validate that everything is running correctly.
+  DCHECK_EQ(id, depth);
+
+  // A thread-checker creates a lock to check the thread-id which means
+  // re-entry into this code if lock acquisitions are being tracked.
+  DCHECK(stack_[depth].activity_type == Activity::ACT_LOCK_ACQUIRE ||
+         CalledOnValidThread());
+
+  // The stack has shrunk meaning that some other thread trying to copy the
+  // contents for reporting purposes could get bad data. Increment the data
+  // version so that it con tell that things have changed. This needs to
+  // happen after the atomic |depth| operation above so a "release" store
+  // is required.
+  header_->data_version.fetch_add(1, std::memory_order_release);
+}
+
+std::unique_ptr<ActivityUserData> ThreadActivityTracker::GetUserData(
+    ActivityId id,
+    ActivityTrackerMemoryAllocator* allocator) {
+  // Don't allow user data for lock acquisition as recursion may occur.
+  if (stack_[id].activity_type == Activity::ACT_LOCK_ACQUIRE) {
+    NOTREACHED();
+    return std::make_unique<ActivityUserData>();
+  }
+
+  // User-data is only stored for activities actually held in the stack.
+  if (id >= stack_slots_)
+    return std::make_unique<ActivityUserData>();
+
+  // Create and return a real UserData object.
+  return CreateUserDataForActivity(&stack_[id], allocator);
+}
+
+bool ThreadActivityTracker::HasUserData(ActivityId id) {
+  // User-data is only stored for activities actually held in the stack.
+  return (id < stack_slots_ && stack_[id].user_data_ref);
+}
+
+void ThreadActivityTracker::ReleaseUserData(
+    ActivityId id,
+    ActivityTrackerMemoryAllocator* allocator) {
+  // User-data is only stored for activities actually held in the stack.
+  if (id < stack_slots_ && stack_[id].user_data_ref) {
+    allocator->ReleaseObjectReference(stack_[id].user_data_ref);
+    stack_[id].user_data_ref = 0;
+  }
+}
+
+void ThreadActivityTracker::RecordExceptionActivity(const void* program_counter,
+                                                    const void* origin,
+                                                    Activity::Type type,
+                                                    const ActivityData& data) {
+  // A thread-checker creates a lock to check the thread-id which means
+  // re-entry into this code if lock acquisitions are being tracked.
+  DCHECK(CalledOnValidThread());
+
+  // Fill the reusable exception activity.
+  Activity::FillFrom(&header_->last_exception, program_counter, origin, type,
+                     data);
+
+  // The data has changed meaning that some other thread trying to copy the
+  // contents for reporting purposes could get bad data.
+  header_->data_version.fetch_add(1, std::memory_order_relaxed);
+}
+
+bool ThreadActivityTracker::IsValid() const {
+  if (header_->owner.data_id.load(std::memory_order_acquire) == 0 ||
+      header_->owner.process_id == 0 || header_->thread_ref.as_id == 0 ||
+      header_->start_time == 0 || header_->start_ticks == 0 ||
+      header_->stack_slots != stack_slots_ ||
+      header_->thread_name[sizeof(header_->thread_name) - 1] != '\0') {
+    return false;
+  }
+
+  return valid_;
+}
+
+bool ThreadActivityTracker::CreateSnapshot(Snapshot* output_snapshot) const {
+  DCHECK(output_snapshot);
+
+  // There is no "called on valid thread" check for this method as it can be
+  // called from other threads or even other processes. It is also the reason
+  // why atomic operations must be used in certain places above.
+
+  // It's possible for the data to change while reading it in such a way that it
+  // invalidates the read. Make several attempts but don't try forever.
+  const int kMaxAttempts = 10;
+  uint32_t depth;
+
+  // Stop here if the data isn't valid.
+  if (!IsValid())
+    return false;
+
+  // Allocate the maximum size for the stack so it doesn't have to be done
+  // during the time-sensitive snapshot operation. It is shrunk once the
+  // actual size is known.
+  output_snapshot->activity_stack.reserve(stack_slots_);
+
+  for (int attempt = 0; attempt < kMaxAttempts; ++attempt) {
+    // Remember the data IDs to ensure nothing is replaced during the snapshot
+    // operation. Use "acquire" so that all the non-atomic fields of the
+    // structure are valid (at least at the current moment in time).
+    const uint32_t starting_id =
+        header_->owner.data_id.load(std::memory_order_acquire);
+    const int64_t starting_create_stamp = header_->owner.create_stamp;
+    const int64_t starting_process_id = header_->owner.process_id;
+    const int64_t starting_thread_id = header_->thread_ref.as_id;
+
+    // Note the current |data_version| so it's possible to detect at the end
+    // that nothing has changed since copying the data began. A "cst" operation
+    // is required to ensure it occurs before everything else. Using "cst"
+    // memory ordering is relatively expensive but this is only done during
+    // analysis so doesn't directly affect the worker threads.
+    const uint32_t pre_version =
+        header_->data_version.load(std::memory_order_seq_cst);
+
+    // Fetching the current depth also "acquires" the contents of the stack.
+    depth = header_->current_depth.load(std::memory_order_acquire);
+    uint32_t count = std::min(depth, stack_slots_);
+    output_snapshot->activity_stack.resize(count);
+    if (count > 0) {
+      // Copy the existing contents. Memcpy is used for speed.
+      memcpy(&output_snapshot->activity_stack[0], stack_,
+             count * sizeof(Activity));
+    }
+
+    // Capture the last exception.
+    memcpy(&output_snapshot->last_exception, &header_->last_exception,
+           sizeof(Activity));
+
+    // TODO(bcwhite): Snapshot other things here.
+
+    // Retry if something changed during the copy. A "cst" operation ensures
+    // it must happen after all the above operations.
+    if (header_->data_version.load(std::memory_order_seq_cst) != pre_version)
+      continue;
+
+    // Stack copied. Record it's full depth.
+    output_snapshot->activity_stack_depth = depth;
+
+    // Get the general thread information.
+    output_snapshot->thread_name =
+        std::string(header_->thread_name, sizeof(header_->thread_name) - 1);
+    output_snapshot->create_stamp = header_->owner.create_stamp;
+    output_snapshot->thread_id = header_->thread_ref.as_id;
+    output_snapshot->process_id = header_->owner.process_id;
+
+    // All characters of the thread-name buffer were copied so as to not break
+    // if the trailing NUL were missing. Now limit the length if the actual
+    // name is shorter.
+    output_snapshot->thread_name.resize(
+        strlen(output_snapshot->thread_name.c_str()));
+
+    // If the data ID has changed then the tracker has exited and the memory
+    // reused by a new one. Try again.
+    if (header_->owner.data_id.load(std::memory_order_seq_cst) != starting_id ||
+        output_snapshot->create_stamp != starting_create_stamp ||
+        output_snapshot->process_id != starting_process_id ||
+        output_snapshot->thread_id != starting_thread_id) {
+      continue;
+    }
+
+    // Only successful if the data is still valid once everything is done since
+    // it's possible for the thread to end somewhere in the middle and all its
+    // values become garbage.
+    if (!IsValid())
+      return false;
+
+    // Change all the timestamps in the activities from "ticks" to "wall" time.
+    const Time start_time = Time::FromInternalValue(header_->start_time);
+    const int64_t start_ticks = header_->start_ticks;
+    for (Activity& activity : output_snapshot->activity_stack) {
+      activity.time_internal =
+          WallTimeFromTickTime(start_ticks, activity.time_internal, start_time)
+              .ToInternalValue();
+    }
+    output_snapshot->last_exception.time_internal =
+        WallTimeFromTickTime(start_ticks,
+                             output_snapshot->last_exception.time_internal,
+                             start_time)
+            .ToInternalValue();
+
+    // Success!
+    return true;
+  }
+
+  // Too many attempts.
+  return false;
+}
+
+const void* ThreadActivityTracker::GetBaseAddress() {
+  return header_;
+}
+
+uint32_t ThreadActivityTracker::GetDataVersionForTesting() {
+  return header_->data_version.load(std::memory_order_relaxed);
+}
+
+void ThreadActivityTracker::SetOwningProcessIdForTesting(int64_t pid,
+                                                         int64_t stamp) {
+  header_->owner.SetOwningProcessIdForTesting(pid, stamp);
+}
+
+// static
+bool ThreadActivityTracker::GetOwningProcessId(const void* memory,
+                                               int64_t* out_id,
+                                               int64_t* out_stamp) {
+  const Header* header = reinterpret_cast<const Header*>(memory);
+  return OwningProcess::GetOwningProcessId(&header->owner, out_id, out_stamp);
+}
+
+// static
+size_t ThreadActivityTracker::SizeForStackDepth(int stack_depth) {
+  return static_cast<size_t>(stack_depth) * sizeof(Activity) + sizeof(Header);
+}
+
+bool ThreadActivityTracker::CalledOnValidThread() {
+#if DCHECK_IS_ON()
+  return thread_id_ == PlatformThreadRef();
+#else
+  return true;
+#endif
+}
+
+std::unique_ptr<ActivityUserData>
+ThreadActivityTracker::CreateUserDataForActivity(
+    Activity* activity,
+    ActivityTrackerMemoryAllocator* allocator) {
+  DCHECK_EQ(0U, activity->user_data_ref);
+
+  PersistentMemoryAllocator::Reference ref = allocator->GetObjectReference();
+  void* memory = allocator->GetAsArray<char>(ref, kUserDataSize);
+  if (memory) {
+    std::unique_ptr<ActivityUserData> user_data =
+        std::make_unique<ActivityUserData>(memory, kUserDataSize);
+    activity->user_data_ref = ref;
+    activity->user_data_id = user_data->id();
+    return user_data;
+  }
+
+  // Return a dummy object that will still accept (but ignore) Set() calls.
+  return std::make_unique<ActivityUserData>();
+}
+
+// The instantiation of the GlobalActivityTracker object.
+// The object held here will obviously not be destructed at process exit
+// but that's best since PersistentMemoryAllocator objects (that underlie
+// GlobalActivityTracker objects) are explicitly forbidden from doing anything
+// essential at exit anyway due to the fact that they depend on data managed
+// elsewhere and which could be destructed first. An AtomicWord is used instead
+// of std::atomic because the latter can create global ctors and dtors.
+subtle::AtomicWord GlobalActivityTracker::g_tracker_ = 0;
+
+GlobalActivityTracker::ModuleInfo::ModuleInfo() = default;
+GlobalActivityTracker::ModuleInfo::ModuleInfo(ModuleInfo&& rhs) = default;
+GlobalActivityTracker::ModuleInfo::ModuleInfo(const ModuleInfo& rhs) = default;
+GlobalActivityTracker::ModuleInfo::~ModuleInfo() = default;
+
+GlobalActivityTracker::ModuleInfo& GlobalActivityTracker::ModuleInfo::operator=(
+    ModuleInfo&& rhs) = default;
+GlobalActivityTracker::ModuleInfo& GlobalActivityTracker::ModuleInfo::operator=(
+    const ModuleInfo& rhs) = default;
+
+GlobalActivityTracker::ModuleInfoRecord::ModuleInfoRecord() = default;
+GlobalActivityTracker::ModuleInfoRecord::~ModuleInfoRecord() = default;
+
+bool GlobalActivityTracker::ModuleInfoRecord::DecodeTo(
+    GlobalActivityTracker::ModuleInfo* info,
+    size_t record_size) const {
+  // Get the current "changes" indicator, acquiring all the other values.
+  uint32_t current_changes = changes.load(std::memory_order_acquire);
+
+  // Copy out the dynamic information.
+  info->is_loaded = loaded != 0;
+  info->address = static_cast<uintptr_t>(address);
+  info->load_time = load_time;
+
+  // Check to make sure no information changed while being read. A "seq-cst"
+  // operation is expensive but is only done during analysis and it's the only
+  // way to ensure this occurs after all the accesses above. If changes did
+  // occur then return a "not loaded" result so that |size| and |address|
+  // aren't expected to be accurate.
+  if ((current_changes & kModuleInformationChanging) != 0 ||
+      changes.load(std::memory_order_seq_cst) != current_changes) {
+    info->is_loaded = false;
+  }
+
+  // Copy out the static information. These never change so don't have to be
+  // protected by the atomic |current_changes| operations.
+  info->size = static_cast<size_t>(size);
+  info->timestamp = timestamp;
+  info->age = age;
+  memcpy(info->identifier, identifier, sizeof(info->identifier));
+
+  if (offsetof(ModuleInfoRecord, pickle) + pickle_size > record_size)
+    return false;
+  Pickle pickler(pickle, pickle_size);
+  PickleIterator iter(pickler);
+  return iter.ReadString(&info->file) && iter.ReadString(&info->debug_file);
+}
+
+GlobalActivityTracker::ModuleInfoRecord*
+GlobalActivityTracker::ModuleInfoRecord::CreateFrom(
+    const GlobalActivityTracker::ModuleInfo& info,
+    PersistentMemoryAllocator* allocator) {
+  Pickle pickler;
+  pickler.WriteString(info.file);
+  pickler.WriteString(info.debug_file);
+  size_t required_size = offsetof(ModuleInfoRecord, pickle) + pickler.size();
+  ModuleInfoRecord* record = allocator->New<ModuleInfoRecord>(required_size);
+  if (!record)
+    return nullptr;
+
+  // These fields never changes and are done before the record is made
+  // iterable so no thread protection is necessary.
+  record->size = info.size;
+  record->timestamp = info.timestamp;
+  record->age = info.age;
+  memcpy(record->identifier, info.identifier, sizeof(identifier));
+  memcpy(record->pickle, pickler.data(), pickler.size());
+  record->pickle_size = pickler.size();
+  record->changes.store(0, std::memory_order_relaxed);
+
+  // Initialize the owner info.
+  record->owner.Release_Initialize();
+
+  // Now set those fields that can change.
+  bool success = record->UpdateFrom(info);
+  DCHECK(success);
+  return record;
+}
+
+bool GlobalActivityTracker::ModuleInfoRecord::UpdateFrom(
+    const GlobalActivityTracker::ModuleInfo& info) {
+  // Updates can occur after the record is made visible so make changes atomic.
+  // A "strong" exchange ensures no false failures.
+  uint32_t old_changes = changes.load(std::memory_order_relaxed);
+  uint32_t new_changes = old_changes | kModuleInformationChanging;
+  if ((old_changes & kModuleInformationChanging) != 0 ||
+      !changes.compare_exchange_strong(old_changes, new_changes,
+                                       std::memory_order_acquire,
+                                       std::memory_order_acquire)) {
+    NOTREACHED() << "Multiple sources are updating module information.";
+    return false;
+  }
+
+  loaded = info.is_loaded ? 1 : 0;
+  address = info.address;
+  load_time = Time::Now().ToInternalValue();
+
+  bool success = changes.compare_exchange_strong(new_changes, old_changes + 1,
+                                                 std::memory_order_release,
+                                                 std::memory_order_relaxed);
+  DCHECK(success);
+  return true;
+}
+
+GlobalActivityTracker::ScopedThreadActivity::ScopedThreadActivity(
+    const void* program_counter,
+    const void* origin,
+    Activity::Type type,
+    const ActivityData& data,
+    bool lock_allowed)
+    : ThreadActivityTracker::ScopedActivity(GetOrCreateTracker(lock_allowed),
+                                            program_counter,
+                                            origin,
+                                            type,
+                                            data) {}
+
+GlobalActivityTracker::ScopedThreadActivity::~ScopedThreadActivity() {
+  if (tracker_ && tracker_->HasUserData(activity_id_)) {
+    GlobalActivityTracker* global = GlobalActivityTracker::Get();
+    AutoLock lock(global->user_data_allocator_lock_);
+    tracker_->ReleaseUserData(activity_id_, &global->user_data_allocator_);
+  }
+}
+
+ActivityUserData& GlobalActivityTracker::ScopedThreadActivity::user_data() {
+  if (!user_data_) {
+    if (tracker_) {
+      GlobalActivityTracker* global = GlobalActivityTracker::Get();
+      AutoLock lock(global->user_data_allocator_lock_);
+      user_data_ =
+          tracker_->GetUserData(activity_id_, &global->user_data_allocator_);
+    } else {
+      user_data_ = std::make_unique<ActivityUserData>();
+    }
+  }
+  return *user_data_;
+}
+
+GlobalActivityTracker::ThreadSafeUserData::ThreadSafeUserData(void* memory,
+                                                              size_t size,
+                                                              int64_t pid)
+    : ActivityUserData(memory, size, pid) {}
+
+GlobalActivityTracker::ThreadSafeUserData::~ThreadSafeUserData() = default;
+
+void GlobalActivityTracker::ThreadSafeUserData::Set(StringPiece name,
+                                                    ValueType type,
+                                                    const void* memory,
+                                                    size_t size) {
+  AutoLock lock(data_lock_);
+  ActivityUserData::Set(name, type, memory, size);
+}
+
+GlobalActivityTracker::ManagedActivityTracker::ManagedActivityTracker(
+    PersistentMemoryAllocator::Reference mem_reference,
+    void* base,
+    size_t size)
+    : ThreadActivityTracker(base, size),
+      mem_reference_(mem_reference),
+      mem_base_(base) {}
+
+GlobalActivityTracker::ManagedActivityTracker::~ManagedActivityTracker() {
+  // The global |g_tracker_| must point to the owner of this class since all
+  // objects of this type must be destructed before |g_tracker_| can be changed
+  // (something that only occurs in tests).
+  DCHECK(g_tracker_);
+  GlobalActivityTracker::Get()->ReturnTrackerMemory(this);
+}
+
+void GlobalActivityTracker::CreateWithAllocator(
+    std::unique_ptr<PersistentMemoryAllocator> allocator,
+    int stack_depth,
+    int64_t process_id) {
+  // There's no need to do anything with the result. It is self-managing.
+  GlobalActivityTracker* global_tracker =
+      new GlobalActivityTracker(std::move(allocator), stack_depth, process_id);
+  // Create a tracker for this thread since it is known.
+  global_tracker->CreateTrackerForCurrentThread();
+}
+
+#if !defined(OS_NACL)
+// static
+bool GlobalActivityTracker::CreateWithFile(const FilePath& file_path,
+                                           size_t size,
+                                           uint64_t id,
+                                           StringPiece name,
+                                           int stack_depth) {
+  DCHECK(!file_path.empty());
+  DCHECK_GE(static_cast<uint64_t>(std::numeric_limits<int64_t>::max()), size);
+
+  // Create and map the file into memory and make it globally available.
+  std::unique_ptr<MemoryMappedFile> mapped_file(new MemoryMappedFile());
+  bool success = mapped_file->Initialize(
+      File(file_path, File::FLAG_CREATE_ALWAYS | File::FLAG_READ |
+                          File::FLAG_WRITE | File::FLAG_SHARE_DELETE),
+      {0, size}, MemoryMappedFile::READ_WRITE_EXTEND);
+  if (!success)
+    return false;
+  if (!FilePersistentMemoryAllocator::IsFileAcceptable(*mapped_file, false))
+    return false;
+  CreateWithAllocator(std::make_unique<FilePersistentMemoryAllocator>(
+                          std::move(mapped_file), size, id, name, false),
+                      stack_depth, 0);
+  return true;
+}
+#endif  // !defined(OS_NACL)
+
+// static
+bool GlobalActivityTracker::CreateWithLocalMemory(size_t size,
+                                                  uint64_t id,
+                                                  StringPiece name,
+                                                  int stack_depth,
+                                                  int64_t process_id) {
+  CreateWithAllocator(
+      std::make_unique<LocalPersistentMemoryAllocator>(size, id, name),
+      stack_depth, process_id);
+  return true;
+}
+
+// static
+bool GlobalActivityTracker::CreateWithSharedMemory(
+    std::unique_ptr<SharedMemory> shm,
+    uint64_t id,
+    StringPiece name,
+    int stack_depth) {
+  if (shm->mapped_size() == 0 ||
+      !SharedPersistentMemoryAllocator::IsSharedMemoryAcceptable(*shm)) {
+    return false;
+  }
+  CreateWithAllocator(std::make_unique<SharedPersistentMemoryAllocator>(
+                          std::move(shm), id, name, false),
+                      stack_depth, 0);
+  return true;
+}
+
+// static
+bool GlobalActivityTracker::CreateWithSharedMemoryHandle(
+    const SharedMemoryHandle& handle,
+    size_t size,
+    uint64_t id,
+    StringPiece name,
+    int stack_depth) {
+  std::unique_ptr<SharedMemory> shm(
+      new SharedMemory(handle, /*readonly=*/false));
+  if (!shm->Map(size))
+    return false;
+  return CreateWithSharedMemory(std::move(shm), id, name, stack_depth);
+}
+
+// static
+void GlobalActivityTracker::SetForTesting(
+    std::unique_ptr<GlobalActivityTracker> tracker) {
+  CHECK(!subtle::NoBarrier_Load(&g_tracker_));
+  subtle::Release_Store(&g_tracker_,
+                        reinterpret_cast<uintptr_t>(tracker.release()));
+}
+
+// static
+std::unique_ptr<GlobalActivityTracker>
+GlobalActivityTracker::ReleaseForTesting() {
+  GlobalActivityTracker* tracker = Get();
+  if (!tracker)
+    return nullptr;
+
+  // Thread trackers assume that the global tracker is present for some
+  // operations so ensure that there aren't any.
+  tracker->ReleaseTrackerForCurrentThreadForTesting();
+  DCHECK_EQ(0, tracker->thread_tracker_count_.load(std::memory_order_relaxed));
+
+  subtle::Release_Store(&g_tracker_, 0);
+  return WrapUnique(tracker);
+}
+
+ThreadActivityTracker* GlobalActivityTracker::CreateTrackerForCurrentThread() {
+  DCHECK(!this_thread_tracker_.Get());
+
+  PersistentMemoryAllocator::Reference mem_reference;
+
+  {
+    base::AutoLock autolock(thread_tracker_allocator_lock_);
+    mem_reference = thread_tracker_allocator_.GetObjectReference();
+  }
+
+  if (!mem_reference) {
+    // Failure. This shouldn't happen. But be graceful if it does, probably
+    // because the underlying allocator wasn't given enough memory to satisfy
+    // to all possible requests.
+    NOTREACHED();
+    // Report the thread-count at which the allocator was full so that the
+    // failure can be seen and underlying memory resized appropriately.
+    UMA_HISTOGRAM_COUNTS_1000(
+        "ActivityTracker.ThreadTrackers.MemLimitTrackerCount",
+        thread_tracker_count_.load(std::memory_order_relaxed));
+    // Return null, just as if tracking wasn't enabled.
+    return nullptr;
+  }
+
+  // Convert the memory block found above into an actual memory address.
+  // Doing the conversion as a Header object enacts the 32/64-bit size
+  // consistency checks which would not otherwise be done. Unfortunately,
+  // some older compilers and MSVC don't have standard-conforming definitions
+  // of std::atomic which cause it not to be plain-old-data. Don't check on
+  // those platforms assuming that the checks on other platforms will be
+  // sufficient.
+  // TODO(bcwhite): Review this after major compiler releases.
+  DCHECK(mem_reference);
+  void* mem_base;
+  mem_base =
+      allocator_->GetAsObject<ThreadActivityTracker::Header>(mem_reference);
+
+  DCHECK(mem_base);
+  DCHECK_LE(stack_memory_size_, allocator_->GetAllocSize(mem_reference));
+
+  // Create a tracker with the acquired memory and set it as the tracker
+  // for this particular thread in thread-local-storage.
+  ManagedActivityTracker* tracker =
+      new ManagedActivityTracker(mem_reference, mem_base, stack_memory_size_);
+  DCHECK(tracker->IsValid());
+  this_thread_tracker_.Set(tracker);
+  int old_count = thread_tracker_count_.fetch_add(1, std::memory_order_relaxed);
+
+  UMA_HISTOGRAM_EXACT_LINEAR("ActivityTracker.ThreadTrackers.Count",
+                             old_count + 1, static_cast<int>(kMaxThreadCount));
+  return tracker;
+}
+
+void GlobalActivityTracker::ReleaseTrackerForCurrentThreadForTesting() {
+  ThreadActivityTracker* tracker =
+      reinterpret_cast<ThreadActivityTracker*>(this_thread_tracker_.Get());
+  if (tracker) {
+    this_thread_tracker_.Set(nullptr);
+    delete tracker;
+  }
+}
+
+void GlobalActivityTracker::SetBackgroundTaskRunner(
+    const scoped_refptr<TaskRunner>& runner) {
+  AutoLock lock(global_tracker_lock_);
+  background_task_runner_ = runner;
+}
+
+void GlobalActivityTracker::SetProcessExitCallback(
+    ProcessExitCallback callback) {
+  AutoLock lock(global_tracker_lock_);
+  process_exit_callback_ = callback;
+}
+
+void GlobalActivityTracker::RecordProcessLaunch(
+    ProcessId process_id,
+    const FilePath::StringType& cmd) {
+  const int64_t pid = process_id;
+  DCHECK_NE(GetProcessId(), pid);
+  DCHECK_NE(0, pid);
+
+  base::AutoLock lock(global_tracker_lock_);
+  if (base::ContainsKey(known_processes_, pid)) {
+    // TODO(bcwhite): Measure this in UMA.
+    NOTREACHED() << "Process #" << process_id
+                 << " was previously recorded as \"launched\""
+                 << " with no corresponding exit.\n"
+                 << known_processes_[pid];
+    known_processes_.erase(pid);
+  }
+
+#if defined(OS_WIN)
+  known_processes_.insert(std::make_pair(pid, UTF16ToUTF8(cmd)));
+#else
+  known_processes_.insert(std::make_pair(pid, cmd));
+#endif
+}
+
+void GlobalActivityTracker::RecordProcessLaunch(
+    ProcessId process_id,
+    const FilePath::StringType& exe,
+    const FilePath::StringType& args) {
+  if (exe.find(FILE_PATH_LITERAL(" "))) {
+    RecordProcessLaunch(process_id,
+                        FilePath::StringType(FILE_PATH_LITERAL("\"")) + exe +
+                            FILE_PATH_LITERAL("\" ") + args);
+  } else {
+    RecordProcessLaunch(process_id, exe + FILE_PATH_LITERAL(' ') + args);
+  }
+}
+
+void GlobalActivityTracker::RecordProcessExit(ProcessId process_id,
+                                              int exit_code) {
+  const int64_t pid = process_id;
+  DCHECK_NE(GetProcessId(), pid);
+  DCHECK_NE(0, pid);
+
+  scoped_refptr<TaskRunner> task_runner;
+  std::string command_line;
+  {
+    base::AutoLock lock(global_tracker_lock_);
+    task_runner = background_task_runner_;
+    auto found = known_processes_.find(pid);
+    if (found != known_processes_.end()) {
+      command_line = std::move(found->second);
+      known_processes_.erase(found);
+    } else {
+      DLOG(ERROR) << "Recording exit of unknown process #" << process_id;
+    }
+  }
+
+  // Use the current time to differentiate the process that just exited
+  // from any that might be created in the future with the same ID.
+  int64_t now_stamp = Time::Now().ToInternalValue();
+
+  // The persistent allocator is thread-safe so run the iteration and
+  // adjustments on a worker thread if one was provided.
+  if (task_runner && !task_runner->RunsTasksInCurrentSequence()) {
+    task_runner->PostTask(
+        FROM_HERE,
+        BindOnce(&GlobalActivityTracker::CleanupAfterProcess, Unretained(this),
+                 pid, now_stamp, exit_code, std::move(command_line)));
+    return;
+  }
+
+  CleanupAfterProcess(pid, now_stamp, exit_code, std::move(command_line));
+}
+
+void GlobalActivityTracker::SetProcessPhase(ProcessPhase phase) {
+  process_data().SetInt(kProcessPhaseDataKey, phase);
+}
+
+void GlobalActivityTracker::CleanupAfterProcess(int64_t process_id,
+                                                int64_t exit_stamp,
+                                                int exit_code,
+                                                std::string&& command_line) {
+  // The process may not have exited cleanly so its necessary to go through
+  // all the data structures it may have allocated in the persistent memory
+  // segment and mark them as "released". This will allow them to be reused
+  // later on.
+
+  PersistentMemoryAllocator::Iterator iter(allocator_.get());
+  PersistentMemoryAllocator::Reference ref;
+
+  ProcessExitCallback process_exit_callback;
+  {
+    AutoLock lock(global_tracker_lock_);
+    process_exit_callback = process_exit_callback_;
+  }
+  if (process_exit_callback) {
+    // Find the processes user-data record so the process phase can be passed
+    // to the callback.
+    ActivityUserData::Snapshot process_data_snapshot;
+    while ((ref = iter.GetNextOfType(kTypeIdProcessDataRecord)) != 0) {
+      const void* memory = allocator_->GetAsArray<char>(
+          ref, kTypeIdProcessDataRecord, PersistentMemoryAllocator::kSizeAny);
+      if (!memory)
+        continue;
+      int64_t found_id;
+      int64_t create_stamp;
+      if (ActivityUserData::GetOwningProcessId(memory, &found_id,
+                                               &create_stamp)) {
+        if (found_id == process_id && create_stamp < exit_stamp) {
+          const ActivityUserData process_data(const_cast<void*>(memory),
+                                              allocator_->GetAllocSize(ref));
+          process_data.CreateSnapshot(&process_data_snapshot);
+          break;  // No need to look for any others.
+        }
+      }
+    }
+    iter.Reset();  // So it starts anew when used below.
+
+    // Record the process's phase at exit so callback doesn't need to go
+    // searching based on a private key value.
+    ProcessPhase exit_phase = PROCESS_PHASE_UNKNOWN;
+    auto phase = process_data_snapshot.find(kProcessPhaseDataKey);
+    if (phase != process_data_snapshot.end())
+      exit_phase = static_cast<ProcessPhase>(phase->second.GetInt());
+
+    // Perform the callback.
+    process_exit_callback.Run(process_id, exit_stamp, exit_code, exit_phase,
+                              std::move(command_line),
+                              std::move(process_data_snapshot));
+  }
+
+  // Find all allocations associated with the exited process and free them.
+  uint32_t type;
+  while ((ref = iter.GetNext(&type)) != 0) {
+    switch (type) {
+      case kTypeIdActivityTracker:
+      case kTypeIdUserDataRecord:
+      case kTypeIdProcessDataRecord:
+      case ModuleInfoRecord::kPersistentTypeId: {
+        const void* memory = allocator_->GetAsArray<char>(
+            ref, type, PersistentMemoryAllocator::kSizeAny);
+        if (!memory)
+          continue;
+        int64_t found_id;
+        int64_t create_stamp;
+
+        // By convention, the OwningProcess structure is always the first
+        // field of the structure so there's no need to handle all the
+        // cases separately.
+        if (OwningProcess::GetOwningProcessId(memory, &found_id,
+                                              &create_stamp)) {
+          // Only change the type to be "free" if the process ID matches and
+          // the creation time is before the exit time (so PID re-use doesn't
+          // cause the erasure of something that is in-use). Memory is cleared
+          // here, rather than when it's needed, so as to limit the impact at
+          // that critical time.
+          if (found_id == process_id && create_stamp < exit_stamp)
+            allocator_->ChangeType(ref, ~type, type, /*clear=*/true);
+        }
+      } break;
+    }
+  }
+}
+
+void GlobalActivityTracker::RecordLogMessage(StringPiece message) {
+  // Allocate at least one extra byte so the string is NUL terminated. All
+  // memory returned by the allocator is guaranteed to be zeroed.
+  PersistentMemoryAllocator::Reference ref =
+      allocator_->Allocate(message.size() + 1, kTypeIdGlobalLogMessage);
+  char* memory = allocator_->GetAsArray<char>(ref, kTypeIdGlobalLogMessage,
+                                              message.size() + 1);
+  if (memory) {
+    memcpy(memory, message.data(), message.size());
+    allocator_->MakeIterable(ref);
+  }
+}
+
+void GlobalActivityTracker::RecordModuleInfo(const ModuleInfo& info) {
+  AutoLock lock(modules_lock_);
+  auto found = modules_.find(info.file);
+  if (found != modules_.end()) {
+    ModuleInfoRecord* record = found->second;
+    DCHECK(record);
+
+    // Update the basic state of module information that has been already
+    // recorded. It is assumed that the string information (identifier,
+    // version, etc.) remain unchanged which means that there's no need
+    // to create a new record to accommodate a possibly longer length.
+    record->UpdateFrom(info);
+    return;
+  }
+
+  ModuleInfoRecord* record =
+      ModuleInfoRecord::CreateFrom(info, allocator_.get());
+  if (!record)
+    return;
+  allocator_->MakeIterable(record);
+  modules_.emplace(info.file, record);
+}
+
+void GlobalActivityTracker::RecordFieldTrial(const std::string& trial_name,
+                                             StringPiece group_name) {
+  const std::string key = std::string("FieldTrial.") + trial_name;
+  process_data_.SetString(key, group_name);
+}
+
+void GlobalActivityTracker::RecordException(const void* pc,
+                                            const void* origin,
+                                            uint32_t code) {
+  RecordExceptionImpl(pc, origin, code);
+}
+
+void GlobalActivityTracker::MarkDeleted() {
+  allocator_->SetMemoryState(PersistentMemoryAllocator::MEMORY_DELETED);
+}
+
+GlobalActivityTracker::GlobalActivityTracker(
+    std::unique_ptr<PersistentMemoryAllocator> allocator,
+    int stack_depth,
+    int64_t process_id)
+    : allocator_(std::move(allocator)),
+      stack_memory_size_(ThreadActivityTracker::SizeForStackDepth(stack_depth)),
+      process_id_(process_id == 0 ? GetCurrentProcId() : process_id),
+      this_thread_tracker_(&OnTLSDestroy),
+      thread_tracker_count_(0),
+      thread_tracker_allocator_(allocator_.get(),
+                                kTypeIdActivityTracker,
+                                kTypeIdActivityTrackerFree,
+                                stack_memory_size_,
+                                kCachedThreadMemories,
+                                /*make_iterable=*/true),
+      user_data_allocator_(allocator_.get(),
+                           kTypeIdUserDataRecord,
+                           kTypeIdUserDataRecordFree,
+                           kUserDataSize,
+                           kCachedUserDataMemories,
+                           /*make_iterable=*/true),
+      process_data_(allocator_->GetAsArray<char>(
+                        AllocateFrom(allocator_.get(),
+                                     kTypeIdProcessDataRecordFree,
+                                     kProcessDataSize,
+                                     kTypeIdProcessDataRecord),
+                        kTypeIdProcessDataRecord,
+                        kProcessDataSize),
+                    kProcessDataSize,
+                    process_id_) {
+  DCHECK_NE(0, process_id_);
+
+  // Ensure that there is no other global object and then make this one such.
+  DCHECK(!g_tracker_);
+  subtle::Release_Store(&g_tracker_, reinterpret_cast<uintptr_t>(this));
+
+  // The data records must be iterable in order to be found by an analyzer.
+  allocator_->MakeIterable(allocator_->GetAsReference(
+      process_data_.GetBaseAddress(), kTypeIdProcessDataRecord));
+
+  // Note that this process has launched.
+  SetProcessPhase(PROCESS_LAUNCHED);
+
+  // Fetch and record all activated field trials.
+  FieldTrial::ActiveGroups active_groups;
+  FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
+  for (auto& group : active_groups)
+    RecordFieldTrial(group.trial_name, group.group_name);
+}
+
+GlobalActivityTracker::~GlobalActivityTracker() {
+  DCHECK(Get() == nullptr || Get() == this);
+  DCHECK_EQ(0, thread_tracker_count_.load(std::memory_order_relaxed));
+  subtle::Release_Store(&g_tracker_, 0);
+}
+
+void GlobalActivityTracker::ReturnTrackerMemory(
+    ManagedActivityTracker* tracker) {
+  PersistentMemoryAllocator::Reference mem_reference = tracker->mem_reference_;
+  void* mem_base = tracker->mem_base_;
+  DCHECK(mem_reference);
+  DCHECK(mem_base);
+
+  // Remove the destructed tracker from the set of known ones.
+  DCHECK_LE(1, thread_tracker_count_.load(std::memory_order_relaxed));
+  thread_tracker_count_.fetch_sub(1, std::memory_order_relaxed);
+
+  // Release this memory for re-use at a later time.
+  base::AutoLock autolock(thread_tracker_allocator_lock_);
+  thread_tracker_allocator_.ReleaseObjectReference(mem_reference);
+}
+
+void GlobalActivityTracker::RecordExceptionImpl(const void* pc,
+                                                const void* origin,
+                                                uint32_t code) {
+  // Get an existing tracker for this thread. It's not possible to create
+  // one at this point because such would involve memory allocations and
+  // other potentially complex operations that can cause failures if done
+  // within an exception handler. In most cases various operations will
+  // have already created the tracker so this shouldn't generally be a
+  // problem.
+  ThreadActivityTracker* tracker = GetTrackerForCurrentThread();
+  if (!tracker)
+    return;
+
+  tracker->RecordExceptionActivity(pc, origin, Activity::ACT_EXCEPTION,
+                                   ActivityData::ForException(code));
+}
+
+// static
+void GlobalActivityTracker::OnTLSDestroy(void* value) {
+  delete reinterpret_cast<ManagedActivityTracker*>(value);
+}
+
+ScopedActivity::ScopedActivity(const void* program_counter,
+                               uint8_t action,
+                               uint32_t id,
+                               int32_t info)
+    : GlobalActivityTracker::ScopedThreadActivity(
+          program_counter,
+          nullptr,
+          static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
+          ActivityData::ForGeneric(id, info),
+          /*lock_allowed=*/true),
+      id_(id) {
+  // The action must not affect the category bits of the activity type.
+  DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
+}
+
+void ScopedActivity::ChangeAction(uint8_t action) {
+  DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
+  ChangeTypeAndData(static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
+                    kNullActivityData);
+}
+
+void ScopedActivity::ChangeInfo(int32_t info) {
+  ChangeTypeAndData(Activity::ACT_NULL, ActivityData::ForGeneric(id_, info));
+}
+
+void ScopedActivity::ChangeActionAndInfo(uint8_t action, int32_t info) {
+  DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
+  ChangeTypeAndData(static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
+                    ActivityData::ForGeneric(id_, info));
+}
+
+ScopedTaskRunActivity::ScopedTaskRunActivity(
+    const void* program_counter,
+    const base::PendingTask& task)
+    : GlobalActivityTracker::ScopedThreadActivity(
+          program_counter,
+          task.posted_from.program_counter(),
+          Activity::ACT_TASK_RUN,
+          ActivityData::ForTask(task.sequence_num),
+          /*lock_allowed=*/true) {}
+
+ScopedLockAcquireActivity::ScopedLockAcquireActivity(
+    const void* program_counter,
+    const base::internal::LockImpl* lock)
+    : GlobalActivityTracker::ScopedThreadActivity(
+          program_counter,
+          nullptr,
+          Activity::ACT_LOCK_ACQUIRE,
+          ActivityData::ForLock(lock),
+          /*lock_allowed=*/false) {}
+
+ScopedEventWaitActivity::ScopedEventWaitActivity(
+    const void* program_counter,
+    const base::WaitableEvent* event)
+    : GlobalActivityTracker::ScopedThreadActivity(
+          program_counter,
+          nullptr,
+          Activity::ACT_EVENT_WAIT,
+          ActivityData::ForEvent(event),
+          /*lock_allowed=*/true) {}
+
+ScopedThreadJoinActivity::ScopedThreadJoinActivity(
+    const void* program_counter,
+    const base::PlatformThreadHandle* thread)
+    : GlobalActivityTracker::ScopedThreadActivity(
+          program_counter,
+          nullptr,
+          Activity::ACT_THREAD_JOIN,
+          ActivityData::ForThread(*thread),
+          /*lock_allowed=*/true) {}
+
+#if !defined(OS_NACL) && !defined(OS_IOS)
+ScopedProcessWaitActivity::ScopedProcessWaitActivity(
+    const void* program_counter,
+    const base::Process* process)
+    : GlobalActivityTracker::ScopedThreadActivity(
+          program_counter,
+          nullptr,
+          Activity::ACT_PROCESS_WAIT,
+          ActivityData::ForProcess(process->Pid()),
+          /*lock_allowed=*/true) {}
+#endif
+
+}  // namespace debug
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/debug/activity_tracker.h b/native/zucchini/vendor/libchrome/base/debug/activity_tracker.h
new file mode 100644
index 0000000..5647d86
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/debug/activity_tracker.h
@@ -0,0 +1,1367 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Activity tracking provides a low-overhead method of collecting information
+// about the state of the application for analysis both while it is running
+// and after it has terminated unexpectedly. Its primary purpose is to help
+// locate reasons the browser becomes unresponsive by providing insight into
+// what all the various threads and processes are (or were) doing.
+
+#ifndef BASE_DEBUG_ACTIVITY_TRACKER_H_
+#define BASE_DEBUG_ACTIVITY_TRACKER_H_
+
+// std::atomic is undesired due to performance issues when used as global
+// variables. There are no such instances here. This module uses the
+// PersistentMemoryAllocator which also uses std::atomic and is written
+// by the same author.
+#include <atomic>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/atomicops.h"
+#include "base/base_export.h"
+#include "base/callback.h"
+#include "base/compiler_specific.h"
+#include "base/gtest_prod_util.h"
+#include "base/location.h"
+#include "base/memory/shared_memory.h"
+#include "base/metrics/persistent_memory_allocator.h"
+#include "base/process/process_handle.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/task_runner.h"
+#include "base/threading/platform_thread.h"
+#include "base/threading/thread_local_storage.h"
+
+namespace base {
+
+struct PendingTask;
+
+class FilePath;
+class Lock;
+class PlatformThreadHandle;
+class Process;
+class WaitableEvent;
+
+namespace debug {
+
+class ThreadActivityTracker;
+
+
+enum : int {
+  // The maximum number of call-stack addresses stored per activity. This
+  // cannot be changed without also changing the version number of the
+  // structure. See kTypeIdActivityTracker in GlobalActivityTracker.
+  kActivityCallStackSize = 10,
+};
+
+// A class for keeping all information needed to verify that a structure is
+// associated with a given process.
+struct OwningProcess {
+  OwningProcess();
+  ~OwningProcess();
+
+  // Initializes structure with the current process id and the current time.
+  // These can uniquely identify a process. A unique non-zero data_id will be
+  // set making it possible to tell using atomic reads if the data has changed.
+  void Release_Initialize(int64_t pid = 0);
+
+  // Explicitly sets the process ID.
+  void SetOwningProcessIdForTesting(int64_t pid, int64_t stamp);
+
+  // Gets the associated process ID, in native form, and the creation timestamp
+  // from memory without loading the entire structure for analysis. This will
+  // return false if no valid process ID is available.
+  static bool GetOwningProcessId(const void* memory,
+                                 int64_t* out_id,
+                                 int64_t* out_stamp);
+
+  // SHA1(base::debug::OwningProcess): Increment this if structure changes!
+  static constexpr uint32_t kPersistentTypeId = 0xB1179672 + 1;
+
+  // Expected size for 32/64-bit check by PersistentMemoryAllocator.
+  static constexpr size_t kExpectedInstanceSize = 24;
+
+  std::atomic<uint32_t> data_id;
+  uint32_t padding;
+  int64_t process_id;
+  int64_t create_stamp;
+};
+
+// The data associated with an activity is dependent upon the activity type.
+// This union defines all of the various fields. All fields must be explicitly
+// sized types to ensure no interoperability problems between 32-bit and
+// 64-bit systems.
+union ActivityData {
+  // Expected size for 32/64-bit check.
+  // TODO(bcwhite): VC2015 doesn't allow statics in unions. Fix when it does.
+  // static constexpr size_t kExpectedInstanceSize = 8;
+
+  // Generic activities don't have any defined structure.
+  struct {
+    uint32_t id;   // An arbitrary identifier used for association.
+    int32_t info;  // An arbitrary value used for information purposes.
+  } generic;
+  struct {
+    uint64_t sequence_id;  // The sequence identifier of the posted task.
+  } task;
+  struct {
+    uint64_t lock_address;  // The memory address of the lock object.
+  } lock;
+  struct {
+    uint64_t event_address;  // The memory address of the event object.
+  } event;
+  struct {
+    int64_t thread_id;  // A unique identifier for a thread within a process.
+  } thread;
+  struct {
+    int64_t process_id;  // A unique identifier for a process.
+  } process;
+  struct {
+    uint32_t code;  // An "exception code" number.
+  } exception;
+
+  // These methods create an ActivityData object from the appropriate
+  // parameters. Objects of this type should always be created this way to
+  // ensure that no fields remain unpopulated should the set of recorded
+  // fields change. They're defined inline where practical because they
+  // reduce to loading a small local structure with a few values, roughly
+  // the same as loading all those values into parameters.
+
+  static ActivityData ForGeneric(uint32_t id, int32_t info) {
+    ActivityData data;
+    data.generic.id = id;
+    data.generic.info = info;
+    return data;
+  }
+
+  static ActivityData ForTask(uint64_t sequence) {
+    ActivityData data;
+    data.task.sequence_id = sequence;
+    return data;
+  }
+
+  static ActivityData ForLock(const void* lock) {
+    ActivityData data;
+    data.lock.lock_address = reinterpret_cast<uintptr_t>(lock);
+    return data;
+  }
+
+  static ActivityData ForEvent(const void* event) {
+    ActivityData data;
+    data.event.event_address = reinterpret_cast<uintptr_t>(event);
+    return data;
+  }
+
+  static ActivityData ForThread(const PlatformThreadHandle& handle);
+  static ActivityData ForThread(const int64_t id) {
+    ActivityData data;
+    data.thread.thread_id = id;
+    return data;
+  }
+
+  static ActivityData ForProcess(const int64_t id) {
+    ActivityData data;
+    data.process.process_id = id;
+    return data;
+  }
+
+  static ActivityData ForException(const uint32_t code) {
+    ActivityData data;
+    data.exception.code = code;
+    return data;
+  }
+};
+
+// A "null" activity-data that can be passed to indicate "do not change".
+extern const ActivityData kNullActivityData;
+
+
+// A helper class that is used for managing memory allocations within a
+// persistent memory allocator. Instances of this class are NOT thread-safe.
+// Use from a single thread or protect access with a lock.
+class BASE_EXPORT ActivityTrackerMemoryAllocator {
+ public:
+  using Reference = PersistentMemoryAllocator::Reference;
+
+  // Creates a instance for allocating objects of a fixed |object_type|, a
+  // corresponding |object_free| type, and the |object_size|. An internal
+  // cache of the last |cache_size| released references will be kept for
+  // quick future fetches. If |make_iterable| then allocated objects will
+  // be marked "iterable" in the allocator.
+  ActivityTrackerMemoryAllocator(PersistentMemoryAllocator* allocator,
+                                 uint32_t object_type,
+                                 uint32_t object_free_type,
+                                 size_t object_size,
+                                 size_t cache_size,
+                                 bool make_iterable);
+  ~ActivityTrackerMemoryAllocator();
+
+  // Gets a reference to an object of the configured type. This can return
+  // a null reference if it was not possible to allocate the memory.
+  Reference GetObjectReference();
+
+  // Returns an object to the "free" pool.
+  void ReleaseObjectReference(Reference ref);
+
+  // Helper function to access an object allocated using this instance.
+  template <typename T>
+  T* GetAsObject(Reference ref) {
+    return allocator_->GetAsObject<T>(ref);
+  }
+
+  // Similar to GetAsObject() but converts references to arrays of objects.
+  template <typename T>
+  T* GetAsArray(Reference ref, size_t count) {
+    return allocator_->GetAsArray<T>(ref, object_type_, count);
+  }
+
+  // The current "used size" of the internal cache, visible for testing.
+  size_t cache_used() const { return cache_used_; }
+
+ private:
+  PersistentMemoryAllocator* const allocator_;
+  const uint32_t object_type_;
+  const uint32_t object_free_type_;
+  const size_t object_size_;
+  const size_t cache_size_;
+  const bool make_iterable_;
+
+  // An iterator for going through persistent memory looking for free'd objects.
+  PersistentMemoryAllocator::Iterator iterator_;
+
+  // The cache of released object memories.
+  std::unique_ptr<Reference[]> cache_values_;
+  size_t cache_used_;
+
+  DISALLOW_COPY_AND_ASSIGN(ActivityTrackerMemoryAllocator);
+};
+
+
+// This structure is the full contents recorded for every activity pushed
+// onto the stack. The |activity_type| indicates what is actually stored in
+// the |data| field. All fields must be explicitly sized types to ensure no
+// interoperability problems between 32-bit and 64-bit systems.
+struct Activity {
+  // SHA1(base::debug::Activity): Increment this if structure changes!
+  static constexpr uint32_t kPersistentTypeId = 0x99425159 + 1;
+  // Expected size for 32/64-bit check. Update this if structure changes!
+  static constexpr size_t kExpectedInstanceSize =
+      48 + 8 * kActivityCallStackSize;
+
+  // The type of an activity on the stack. Activities are broken into
+  // categories with the category ID taking the top 4 bits and the lower
+  // bits representing an action within that category. This combination
+  // makes it easy to "switch" based on the type during analysis.
+  enum Type : uint8_t {
+    // This "null" constant is used to indicate "do not change" in calls.
+    ACT_NULL = 0,
+
+    // Task activities involve callbacks posted to a thread or thread-pool
+    // using the PostTask() method or any of its friends.
+    ACT_TASK = 1 << 4,
+    ACT_TASK_RUN = ACT_TASK,
+
+    // Lock activities involve the acquisition of "mutex" locks.
+    ACT_LOCK = 2 << 4,
+    ACT_LOCK_ACQUIRE = ACT_LOCK,
+    ACT_LOCK_RELEASE,
+
+    // Event activities involve operations on a WaitableEvent.
+    ACT_EVENT = 3 << 4,
+    ACT_EVENT_WAIT = ACT_EVENT,
+    ACT_EVENT_SIGNAL,
+
+    // Thread activities involve the life management of threads.
+    ACT_THREAD = 4 << 4,
+    ACT_THREAD_START = ACT_THREAD,
+    ACT_THREAD_JOIN,
+
+    // Process activities involve the life management of processes.
+    ACT_PROCESS = 5 << 4,
+    ACT_PROCESS_START = ACT_PROCESS,
+    ACT_PROCESS_WAIT,
+
+    // Exception activities indicate the occurence of something unexpected.
+    ACT_EXCEPTION = 14 << 4,
+
+    // Generic activities are user defined and can be anything.
+    ACT_GENERIC = 15 << 4,
+
+    // These constants can be used to separate the category and action from
+    // a combined activity type.
+    ACT_CATEGORY_MASK = 0xF << 4,
+    ACT_ACTION_MASK = 0xF
+  };
+
+  // Internal representation of time. During collection, this is in "ticks"
+  // but when returned in a snapshot, it is "wall time".
+  int64_t time_internal;
+
+  // The address that pushed the activity onto the stack as a raw number.
+  uint64_t calling_address;
+
+  // The address that is the origin of the activity if it not obvious from
+  // the call stack. This is useful for things like tasks that are posted
+  // from a completely different thread though most activities will leave
+  // it null.
+  uint64_t origin_address;
+
+  // Array of program-counters that make up the top of the call stack.
+  // Despite the fixed size, this list is always null-terminated. Entries
+  // after the terminator have no meaning and may or may not also be null.
+  // The list will be completely empty if call-stack collection is not
+  // enabled.
+  uint64_t call_stack[kActivityCallStackSize];
+
+  // Reference to arbitrary user data within the persistent memory segment
+  // and a unique identifier for it.
+  uint32_t user_data_ref;
+  uint32_t user_data_id;
+
+  // The (enumerated) type of the activity. This defines what fields of the
+  // |data| record are valid.
+  uint8_t activity_type;
+
+  // Padding to ensure that the next member begins on a 64-bit boundary
+  // even on 32-bit builds which ensures inter-operability between CPU
+  // architectures. New fields can be taken from this space.
+  uint8_t padding[7];
+
+  // Information specific to the |activity_type|.
+  ActivityData data;
+
+  static void FillFrom(Activity* activity,
+                       const void* program_counter,
+                       const void* origin,
+                       Type type,
+                       const ActivityData& data);
+};
+
+// This class manages arbitrary user data that can be associated with activities
+// done by a thread by supporting key/value pairs of any type. This can provide
+// additional information during debugging. It is also used to store arbitrary
+// global data. All updates must be done from the same thread though other
+// threads can read it concurrently if they create new objects using the same
+// memory.
+class BASE_EXPORT ActivityUserData {
+ public:
+  // List of known value type. REFERENCE types must immediately follow the non-
+  // external types.
+  enum ValueType : uint8_t {
+    END_OF_VALUES = 0,
+    RAW_VALUE,
+    RAW_VALUE_REFERENCE,
+    STRING_VALUE,
+    STRING_VALUE_REFERENCE,
+    CHAR_VALUE,
+    BOOL_VALUE,
+    SIGNED_VALUE,
+    UNSIGNED_VALUE,
+  };
+
+  class BASE_EXPORT TypedValue {
+   public:
+    TypedValue();
+    TypedValue(const TypedValue& other);
+    ~TypedValue();
+
+    ValueType type() const { return type_; }
+
+    // These methods return the extracted value in the correct format.
+    StringPiece Get() const;
+    StringPiece GetString() const;
+    bool GetBool() const;
+    char GetChar() const;
+    int64_t GetInt() const;
+    uint64_t GetUint() const;
+
+    // These methods return references to process memory as originally provided
+    // to corresponding Set calls. USE WITH CAUTION! There is no guarantee that
+    // the referenced memory is assessible or useful.  It's possible that:
+    //  - the memory was free'd and reallocated for a different purpose
+    //  - the memory has been released back to the OS
+    //  - the memory belongs to a different process's address space
+    // Dereferencing the returned StringPiece when the memory is not accessible
+    // will cause the program to SEGV!
+    StringPiece GetReference() const;
+    StringPiece GetStringReference() const;
+
+   private:
+    friend class ActivityUserData;
+
+    ValueType type_ = END_OF_VALUES;
+    uint64_t short_value_;    // Used to hold copy of numbers, etc.
+    std::string long_value_;  // Used to hold copy of raw/string data.
+    StringPiece ref_value_;   // Used to hold reference to external data.
+  };
+
+  using Snapshot = std::map<std::string, TypedValue>;
+
+  // Initialize the object either as a "sink" that just accepts and discards
+  // data or an active one that writes to a given (zeroed) memory block.
+  ActivityUserData();
+  ActivityUserData(void* memory, size_t size, int64_t pid = 0);
+  virtual ~ActivityUserData();
+
+  // Gets the unique ID number for this user data. If this changes then the
+  // contents have been overwritten by another thread. The return value is
+  // always non-zero unless it's actually just a data "sink".
+  uint32_t id() const {
+    return header_ ? header_->owner.data_id.load(std::memory_order_relaxed) : 0;
+  }
+
+  // Writes a |value| (as part of a key/value pair) that will be included with
+  // the activity in any reports. The same |name| can be written multiple times
+  // with each successive call overwriting the previously stored |value|. For
+  // raw and string values, the maximum size of successive writes is limited by
+  // the first call. The length of "name" is limited to 255 characters.
+  //
+  // This information is stored on a "best effort" basis. It may be dropped if
+  // the memory buffer is full or the associated activity is beyond the maximum
+  // recording depth.
+  void Set(StringPiece name, const void* memory, size_t size) {
+    Set(name, RAW_VALUE, memory, size);
+  }
+  void SetString(StringPiece name, StringPiece value) {
+    Set(name, STRING_VALUE, value.data(), value.length());
+  }
+  void SetString(StringPiece name, StringPiece16 value) {
+    SetString(name, UTF16ToUTF8(value));
+  }
+  void SetBool(StringPiece name, bool value) {
+    char cvalue = value ? 1 : 0;
+    Set(name, BOOL_VALUE, &cvalue, sizeof(cvalue));
+  }
+  void SetChar(StringPiece name, char value) {
+    Set(name, CHAR_VALUE, &value, sizeof(value));
+  }
+  void SetInt(StringPiece name, int64_t value) {
+    Set(name, SIGNED_VALUE, &value, sizeof(value));
+  }
+  void SetUint(StringPiece name, uint64_t value) {
+    Set(name, UNSIGNED_VALUE, &value, sizeof(value));
+  }
+
+  // These function as above but don't actually copy the data into the
+  // persistent memory. They store unaltered pointers along with a size. These
+  // can be used in conjuction with a memory dump to find certain large pieces
+  // of information.
+  void SetReference(StringPiece name, const void* memory, size_t size) {
+    SetReference(name, RAW_VALUE_REFERENCE, memory, size);
+  }
+  void SetStringReference(StringPiece name, StringPiece value) {
+    SetReference(name, STRING_VALUE_REFERENCE, value.data(), value.length());
+  }
+
+  // Creates a snapshot of the key/value pairs contained within. The returned
+  // data will be fixed, independent of whatever changes afterward. There is
+  // some protection against concurrent modification. This will return false
+  // if the data is invalid or if a complete overwrite of the contents is
+  // detected.
+  bool CreateSnapshot(Snapshot* output_snapshot) const;
+
+  // Gets the base memory address used for storing data.
+  const void* GetBaseAddress() const;
+
+  // Explicitly sets the process ID.
+  void SetOwningProcessIdForTesting(int64_t pid, int64_t stamp);
+
+  // Gets the associated process ID, in native form, and the creation timestamp
+  // from tracker memory without loading the entire structure for analysis. This
+  // will return false if no valid process ID is available.
+  static bool GetOwningProcessId(const void* memory,
+                                 int64_t* out_id,
+                                 int64_t* out_stamp);
+
+ protected:
+  virtual void Set(StringPiece name,
+                   ValueType type,
+                   const void* memory,
+                   size_t size);
+
+ private:
+  FRIEND_TEST_ALL_PREFIXES(ActivityTrackerTest, UserDataTest);
+
+  enum : size_t { kMemoryAlignment = sizeof(uint64_t) };
+
+  // A structure that defines the structure header in memory.
+  struct MemoryHeader {
+    MemoryHeader();
+    ~MemoryHeader();
+
+    OwningProcess owner;  // Information about the creating process.
+  };
+
+  // Header to a key/value record held in persistent memory.
+  struct FieldHeader {
+    FieldHeader();
+    ~FieldHeader();
+
+    std::atomic<uint8_t> type;         // Encoded ValueType
+    uint8_t name_size;                 // Length of "name" key.
+    std::atomic<uint16_t> value_size;  // Actual size of of the stored value.
+    uint16_t record_size;              // Total storage of name, value, header.
+  };
+
+  // A structure used to reference data held outside of persistent memory.
+  struct ReferenceRecord {
+    uint64_t address;
+    uint64_t size;
+  };
+
+  // This record is used to hold known value is a map so that they can be
+  // found and overwritten later.
+  struct ValueInfo {
+    ValueInfo();
+    ValueInfo(ValueInfo&&);
+    ~ValueInfo();
+
+    StringPiece name;                 // The "key" of the record.
+    ValueType type;                   // The type of the value.
+    void* memory;                     // Where the "value" is held.
+    std::atomic<uint16_t>* size_ptr;  // Address of the actual size of value.
+    size_t extent;                    // The total storage of the value,
+  };                                  // typically rounded up for alignment.
+
+  void SetReference(StringPiece name,
+                    ValueType type,
+                    const void* memory,
+                    size_t size);
+
+  // Loads any data already in the memory segment. This allows for accessing
+  // records created previously. If this detects that the underlying data has
+  // gone away (cleared by another thread/process), it will invalidate all the
+  // data in this object and turn it into simple "sink" with no values to
+  // return.
+  void ImportExistingData() const;
+
+  // A map of all the values within the memory block, keyed by name for quick
+  // updates of the values. This is "mutable" because it changes on "const"
+  // objects even when the actual data values can't change.
+  mutable std::map<StringPiece, ValueInfo> values_;
+
+  // Information about the memory block in which new data can be stored. These
+  // are "mutable" because they change even on "const" objects that are just
+  // skipping already set values.
+  mutable char* memory_;
+  mutable size_t available_;
+
+  // A pointer to the memory header for this instance.
+  MemoryHeader* const header_;
+
+  // These hold values used when initially creating the object. They are
+  // compared against current header values to check for outside changes.
+  const uint32_t orig_data_id;
+  const int64_t orig_process_id;
+  const int64_t orig_create_stamp;
+
+  DISALLOW_COPY_AND_ASSIGN(ActivityUserData);
+};
+
+// This class manages tracking a stack of activities for a single thread in
+// a persistent manner, implementing a bounded-size stack in a fixed-size
+// memory allocation. In order to support an operational mode where another
+// thread is analyzing this data in real-time, atomic operations are used
+// where necessary to guarantee a consistent view from the outside.
+//
+// This class is not generally used directly but instead managed by the
+// GlobalActivityTracker instance and updated using Scoped*Activity local
+// objects.
+class BASE_EXPORT ThreadActivityTracker {
+ public:
+  using ActivityId = uint32_t;
+
+  // This structure contains all the common information about the thread so
+  // it doesn't have to be repeated in every entry on the stack. It is defined
+  // and used completely within the .cc file.
+  struct Header;
+
+  // This structure holds a copy of all the internal data at the moment the
+  // "snapshot" operation is done. It is disconnected from the live tracker
+  // so that continued operation of the thread will not cause changes here.
+  struct BASE_EXPORT Snapshot {
+    // Explicit constructor/destructor are needed because of complex types
+    // with non-trivial default constructors and destructors.
+    Snapshot();
+    ~Snapshot();
+
+    // The name of the thread as set when it was created. The name may be
+    // truncated due to internal length limitations.
+    std::string thread_name;
+
+    // The timestamp at which this process was created.
+    int64_t create_stamp;
+
+    // The process and thread IDs. These values have no meaning other than
+    // they uniquely identify a running process and a running thread within
+    // that process.  Thread-IDs can be re-used across different processes
+    // and both can be re-used after the process/thread exits.
+    int64_t process_id = 0;
+    int64_t thread_id = 0;
+
+    // The current stack of activities that are underway for this thread. It
+    // is limited in its maximum size with later entries being left off.
+    std::vector<Activity> activity_stack;
+
+    // The current total depth of the activity stack, including those later
+    // entries not recorded in the |activity_stack| vector.
+    uint32_t activity_stack_depth = 0;
+
+    // The last recorded "exception" activity.
+    Activity last_exception;
+  };
+
+  // This is the base class for having the compiler manage an activity on the
+  // tracker's stack. It does nothing but call methods on the passed |tracker|
+  // if it is not null, making it safe (and cheap) to create these objects
+  // even if activity tracking is not enabled.
+  class BASE_EXPORT ScopedActivity {
+   public:
+    ScopedActivity(ThreadActivityTracker* tracker,
+                   const void* program_counter,
+                   const void* origin,
+                   Activity::Type type,
+                   const ActivityData& data);
+    ~ScopedActivity();
+
+    // Changes some basic metadata about the activity.
+    void ChangeTypeAndData(Activity::Type type, const ActivityData& data);
+
+   protected:
+    // The thread tracker to which this object reports. It can be null if
+    // activity tracking is not (yet) enabled.
+    ThreadActivityTracker* const tracker_;
+
+    // An identifier that indicates a specific activity on the stack.
+    ActivityId activity_id_;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(ScopedActivity);
+  };
+
+  // A ThreadActivityTracker runs on top of memory that is managed externally.
+  // It must be large enough for the internal header and a few Activity
+  // blocks. See SizeForStackDepth().
+  ThreadActivityTracker(void* base, size_t size);
+  virtual ~ThreadActivityTracker();
+
+  // Indicates that an activity has started from a given |origin| address in
+  // the code, though it can be null if the creator's address is not known.
+  // The |type| and |data| describe the activity. |program_counter| should be
+  // the result of GetProgramCounter() where push is called. Returned is an
+  // ID that can be used to adjust the pushed activity.
+  ActivityId PushActivity(const void* program_counter,
+                          const void* origin,
+                          Activity::Type type,
+                          const ActivityData& data);
+
+  // An inlined version of the above that gets the program counter where it
+  // is called.
+  ALWAYS_INLINE
+  ActivityId PushActivity(const void* origin,
+                          Activity::Type type,
+                          const ActivityData& data) {
+    return PushActivity(GetProgramCounter(), origin, type, data);
+  }
+
+  // Changes the activity |type| and |data| of the top-most entry on the stack.
+  // This is useful if the information has changed and it is desireable to
+  // track that change without creating a new stack entry. If the type is
+  // ACT_NULL or the data is kNullActivityData then that value will remain
+  // unchanged. The type, if changed, must remain in the same category.
+  // Changing both is not atomic so a snapshot operation could occur between
+  // the update of |type| and |data| or between update of |data| fields.
+  void ChangeActivity(ActivityId id,
+                      Activity::Type type,
+                      const ActivityData& data);
+
+  // Indicates that an activity has completed.
+  void PopActivity(ActivityId id);
+
+  // Sets the user-data information for an activity.
+  std::unique_ptr<ActivityUserData> GetUserData(
+      ActivityId id,
+      ActivityTrackerMemoryAllocator* allocator);
+
+  // Returns if there is true use-data associated with a given ActivityId since
+  // it's possible than any returned object is just a sink.
+  bool HasUserData(ActivityId id);
+
+  // Release the user-data information for an activity.
+  void ReleaseUserData(ActivityId id,
+                       ActivityTrackerMemoryAllocator* allocator);
+
+  // Save an exception. |origin| is the location of the exception.
+  void RecordExceptionActivity(const void* program_counter,
+                               const void* origin,
+                               Activity::Type type,
+                               const ActivityData& data);
+
+  // Returns whether the current data is valid or not. It is not valid if
+  // corruption has been detected in the header or other data structures.
+  bool IsValid() const;
+
+  // Gets a copy of the tracker contents for analysis. Returns false if a
+  // snapshot was not possible, perhaps because the data is not valid; the
+  // contents of |output_snapshot| are undefined in that case. The current
+  // implementation does not support concurrent snapshot operations.
+  bool CreateSnapshot(Snapshot* output_snapshot) const;
+
+  // Gets the base memory address used for storing data.
+  const void* GetBaseAddress();
+
+  // Access the "data version" value so tests can determine if an activity
+  // was pushed and popped in a single call.
+  uint32_t GetDataVersionForTesting();
+
+  // Explicitly sets the process ID.
+  void SetOwningProcessIdForTesting(int64_t pid, int64_t stamp);
+
+  // Gets the associated process ID, in native form, and the creation timestamp
+  // from tracker memory without loading the entire structure for analysis. This
+  // will return false if no valid process ID is available.
+  static bool GetOwningProcessId(const void* memory,
+                                 int64_t* out_id,
+                                 int64_t* out_stamp);
+
+  // Calculates the memory size required for a given stack depth, including
+  // the internal header structure for the stack.
+  static size_t SizeForStackDepth(int stack_depth);
+
+ private:
+  friend class ActivityTrackerTest;
+
+  bool CalledOnValidThread();
+
+  std::unique_ptr<ActivityUserData> CreateUserDataForActivity(
+      Activity* activity,
+      ActivityTrackerMemoryAllocator* allocator);
+
+  Header* const header_;        // Pointer to the Header structure.
+  Activity* const stack_;       // The stack of activities.
+
+#if DCHECK_IS_ON()
+  // The ActivityTracker is thread bound, and will be invoked across all the
+  // sequences that run on the thread. A ThreadChecker does not work here, as it
+  // asserts on running in the same sequence each time.
+  const PlatformThreadRef thread_id_;  // The thread this instance is bound to.
+#endif
+  const uint32_t stack_slots_;  // The total number of stack slots.
+
+  bool valid_ = false;          // Tracks whether the data is valid or not.
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadActivityTracker);
+};
+
+
+// The global tracker manages all the individual thread trackers. Memory for
+// the thread trackers is taken from a PersistentMemoryAllocator which allows
+// for the data to be analyzed by a parallel process or even post-mortem.
+class BASE_EXPORT GlobalActivityTracker {
+ public:
+  // Type identifiers used when storing in persistent memory so they can be
+  // identified during extraction; the first 4 bytes of the SHA1 of the name
+  // is used as a unique integer. A "version number" is added to the base
+  // so that, if the structure of that object changes, stored older versions
+  // will be safely ignored. These are public so that an external process
+  // can recognize records of this type within an allocator.
+  enum : uint32_t {
+    kTypeIdActivityTracker = 0x5D7381AF + 4,   // SHA1(ActivityTracker) v4
+    kTypeIdUserDataRecord = 0x615EDDD7 + 3,    // SHA1(UserDataRecord) v3
+    kTypeIdGlobalLogMessage = 0x4CF434F9 + 1,  // SHA1(GlobalLogMessage) v1
+    kTypeIdProcessDataRecord = kTypeIdUserDataRecord + 0x100,
+
+    kTypeIdActivityTrackerFree = ~kTypeIdActivityTracker,
+    kTypeIdUserDataRecordFree = ~kTypeIdUserDataRecord,
+    kTypeIdProcessDataRecordFree = ~kTypeIdProcessDataRecord,
+  };
+
+  // An enumeration of common process life stages. All entries are given an
+  // explicit number so they are known and remain constant; this allows for
+  // cross-version analysis either locally or on a server.
+  enum ProcessPhase : int {
+    // The phases are generic and may have meaning to the tracker.
+    PROCESS_PHASE_UNKNOWN = 0,
+    PROCESS_LAUNCHED = 1,
+    PROCESS_LAUNCH_FAILED = 2,
+    PROCESS_EXITED_CLEANLY = 10,
+    PROCESS_EXITED_WITH_CODE = 11,
+
+    // Add here whatever is useful for analysis.
+    PROCESS_SHUTDOWN_STARTED = 100,
+    PROCESS_MAIN_LOOP_STARTED = 101,
+  };
+
+  // A callback made when a process exits to allow immediate analysis of its
+  // data. Note that the system may reuse the |process_id| so when fetching
+  // records it's important to ensure that what is returned was created before
+  // the |exit_stamp|. Movement of |process_data| information is allowed.
+  using ProcessExitCallback =
+      Callback<void(int64_t process_id,
+                    int64_t exit_stamp,
+                    int exit_code,
+                    ProcessPhase exit_phase,
+                    std::string&& command_line,
+                    ActivityUserData::Snapshot&& process_data)>;
+
+  // This structure contains information about a loaded module, as shown to
+  // users of the tracker.
+  struct BASE_EXPORT ModuleInfo {
+    ModuleInfo();
+    ModuleInfo(ModuleInfo&& rhs);
+    ModuleInfo(const ModuleInfo& rhs);
+    ~ModuleInfo();
+
+    ModuleInfo& operator=(ModuleInfo&& rhs);
+    ModuleInfo& operator=(const ModuleInfo& rhs);
+
+    // Information about where and when the module was loaded/unloaded.
+    bool is_loaded = false;  // Was the last operation a load or unload?
+    uintptr_t address = 0;   // Address of the last load operation.
+    int64_t load_time = 0;   // Time of last change; set automatically.
+
+    // Information about the module itself. These never change no matter how
+    // many times a module may be loaded and unloaded.
+    size_t size = 0;         // The size of the loaded module.
+    uint32_t timestamp = 0;  // Opaque "timestamp" for the module.
+    uint32_t age = 0;        // Opaque "age" for the module.
+    uint8_t identifier[16];  // Opaque identifier (GUID, etc.) for the module.
+    std::string file;        // The full path to the file. (UTF-8)
+    std::string debug_file;  // The full path to the debug file.
+  };
+
+  // This is a thin wrapper around the thread-tracker's ScopedActivity that
+  // allows thread-safe access to data values. It is safe to use even if
+  // activity tracking is not enabled.
+  class BASE_EXPORT ScopedThreadActivity
+      : public ThreadActivityTracker::ScopedActivity {
+   public:
+    ScopedThreadActivity(const void* program_counter,
+                         const void* origin,
+                         Activity::Type type,
+                         const ActivityData& data,
+                         bool lock_allowed);
+    ~ScopedThreadActivity();
+
+    // Returns an object for manipulating user data.
+    ActivityUserData& user_data();
+
+   private:
+    // Gets (or creates) a tracker for the current thread. If locking is not
+    // allowed (because a lock is being tracked which would cause recursion)
+    // then the attempt to create one if none found will be skipped. Once
+    // the tracker for this thread has been created for other reasons, locks
+    // will be tracked. The thread-tracker uses locks.
+    static ThreadActivityTracker* GetOrCreateTracker(bool lock_allowed) {
+      GlobalActivityTracker* global_tracker = Get();
+      if (!global_tracker)
+        return nullptr;
+
+      // It is not safe to use TLS once TLS has been destroyed. This can happen
+      // if code that runs late during thread destruction tries to use a
+      // base::Lock. See https://crbug.com/864589.
+      if (base::ThreadLocalStorage::HasBeenDestroyed())
+        return nullptr;
+
+      if (lock_allowed)
+        return global_tracker->GetOrCreateTrackerForCurrentThread();
+      else
+        return global_tracker->GetTrackerForCurrentThread();
+    }
+
+    // An object that manages additional user data, created only upon request.
+    std::unique_ptr<ActivityUserData> user_data_;
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedThreadActivity);
+  };
+
+  ~GlobalActivityTracker();
+
+  // Creates a global tracker using a given persistent-memory |allocator| and
+  // providing the given |stack_depth| to each thread tracker it manages. The
+  // created object is activated so tracking will begin immediately upon return.
+  // The |process_id| can be zero to get it from the OS but is taken for testing
+  // purposes.
+  static void CreateWithAllocator(
+      std::unique_ptr<PersistentMemoryAllocator> allocator,
+      int stack_depth,
+      int64_t process_id);
+
+#if !defined(OS_NACL)
+  // Like above but internally creates an allocator around a disk file with
+  // the specified |size| at the given |file_path|. Any existing file will be
+  // overwritten. The |id| and |name| are arbitrary and stored in the allocator
+  // for reference by whatever process reads it. Returns true if successful.
+  static bool CreateWithFile(const FilePath& file_path,
+                             size_t size,
+                             uint64_t id,
+                             StringPiece name,
+                             int stack_depth);
+#endif  // !defined(OS_NACL)
+
+  // Like above but internally creates an allocator using local heap memory of
+  // the specified size. This is used primarily for unit tests. The |process_id|
+  // can be zero to get it from the OS but is taken for testing purposes.
+  static bool CreateWithLocalMemory(size_t size,
+                                    uint64_t id,
+                                    StringPiece name,
+                                    int stack_depth,
+                                    int64_t process_id);
+
+  // Like above but internally creates an allocator using a shared-memory
+  // segment. The segment must already be mapped into the local memory space.
+  static bool CreateWithSharedMemory(std::unique_ptr<SharedMemory> shm,
+                                     uint64_t id,
+                                     StringPiece name,
+                                     int stack_depth);
+
+  // Like above but takes a handle to an existing shared memory segment and
+  // maps it before creating the tracker.
+  static bool CreateWithSharedMemoryHandle(const SharedMemoryHandle& handle,
+                                           size_t size,
+                                           uint64_t id,
+                                           StringPiece name,
+                                           int stack_depth);
+
+  // Gets the global activity-tracker or null if none exists.
+  static GlobalActivityTracker* Get() {
+    return reinterpret_cast<GlobalActivityTracker*>(
+        subtle::Acquire_Load(&g_tracker_));
+  }
+
+  // Sets the global activity-tracker for testing purposes.
+  static void SetForTesting(std::unique_ptr<GlobalActivityTracker> tracker);
+
+  // This access to the persistent allocator is only for testing; it extracts
+  // the global tracker completely. All tracked threads must exit before
+  // calling this. Tracking for the current thread will be automatically
+  // stopped.
+  static std::unique_ptr<GlobalActivityTracker> ReleaseForTesting();
+
+  // Convenience method for determining if a global tracker is active.
+  static bool IsEnabled() { return Get() != nullptr; }
+
+  // Gets the persistent-memory-allocator in which data is stored. Callers
+  // can store additional records here to pass more information to the
+  // analysis process.
+  PersistentMemoryAllocator* allocator() { return allocator_.get(); }
+
+  // Gets the thread's activity-tracker if it exists. This is inline for
+  // performance reasons and it uses thread-local-storage (TLS) so that there
+  // is no significant lookup time required to find the one for the calling
+  // thread. Ownership remains with the global tracker.
+  ThreadActivityTracker* GetTrackerForCurrentThread() {
+    return reinterpret_cast<ThreadActivityTracker*>(this_thread_tracker_.Get());
+  }
+
+  // Gets the thread's activity-tracker or creates one if none exists. This
+  // is inline for performance reasons. Ownership remains with the global
+  // tracker.
+  ThreadActivityTracker* GetOrCreateTrackerForCurrentThread() {
+    ThreadActivityTracker* tracker = GetTrackerForCurrentThread();
+    if (tracker)
+      return tracker;
+    return CreateTrackerForCurrentThread();
+  }
+
+  // Creates an activity-tracker for the current thread.
+  ThreadActivityTracker* CreateTrackerForCurrentThread();
+
+  // Releases the activity-tracker for the current thread (for testing only).
+  void ReleaseTrackerForCurrentThreadForTesting();
+
+  // Sets a task-runner that can be used for background work.
+  void SetBackgroundTaskRunner(const scoped_refptr<TaskRunner>& runner);
+
+  // Sets an optional callback to be called when a process exits.
+  void SetProcessExitCallback(ProcessExitCallback callback);
+
+  // Manages process lifetimes. These are called by the process that launched
+  // and reaped the subprocess, not the subprocess itself. If it is expensive
+  // to generate the parameters, Get() the global tracker and call these
+  // conditionally rather than using the static versions.
+  void RecordProcessLaunch(ProcessId process_id,
+                           const FilePath::StringType& cmd);
+  void RecordProcessLaunch(ProcessId process_id,
+                           const FilePath::StringType& exe,
+                           const FilePath::StringType& args);
+  void RecordProcessExit(ProcessId process_id, int exit_code);
+  static void RecordProcessLaunchIfEnabled(ProcessId process_id,
+                                           const FilePath::StringType& cmd) {
+    GlobalActivityTracker* tracker = Get();
+    if (tracker)
+      tracker->RecordProcessLaunch(process_id, cmd);
+  }
+  static void RecordProcessLaunchIfEnabled(ProcessId process_id,
+                                           const FilePath::StringType& exe,
+                                           const FilePath::StringType& args) {
+    GlobalActivityTracker* tracker = Get();
+    if (tracker)
+      tracker->RecordProcessLaunch(process_id, exe, args);
+  }
+  static void RecordProcessExitIfEnabled(ProcessId process_id, int exit_code) {
+    GlobalActivityTracker* tracker = Get();
+    if (tracker)
+      tracker->RecordProcessExit(process_id, exit_code);
+  }
+
+  // Sets the "phase" of the current process, useful for knowing what it was
+  // doing when it last reported.
+  void SetProcessPhase(ProcessPhase phase);
+  static void SetProcessPhaseIfEnabled(ProcessPhase phase) {
+    GlobalActivityTracker* tracker = Get();
+    if (tracker)
+      tracker->SetProcessPhase(phase);
+  }
+
+  // Records a log message. The current implementation does NOT recycle these
+  // only store critical messages such as FATAL ones.
+  void RecordLogMessage(StringPiece message);
+  static void RecordLogMessageIfEnabled(StringPiece message) {
+    GlobalActivityTracker* tracker = Get();
+    if (tracker)
+      tracker->RecordLogMessage(message);
+  }
+
+  // Records a module load/unload event. This is safe to call multiple times
+  // even with the same information.
+  void RecordModuleInfo(const ModuleInfo& info);
+  static void RecordModuleInfoIfEnabled(const ModuleInfo& info) {
+    GlobalActivityTracker* tracker = Get();
+    if (tracker)
+      tracker->RecordModuleInfo(info);
+  }
+
+  // Record field trial information. This call is thread-safe. In addition to
+  // this, construction of a GlobalActivityTracker will cause all existing
+  // active field trials to be fetched and recorded.
+  void RecordFieldTrial(const std::string& trial_name, StringPiece group_name);
+  static void RecordFieldTrialIfEnabled(const std::string& trial_name,
+                                        StringPiece group_name) {
+    GlobalActivityTracker* tracker = Get();
+    if (tracker)
+      tracker->RecordFieldTrial(trial_name, group_name);
+  }
+
+  // Record exception information for the current thread.
+  ALWAYS_INLINE
+  void RecordException(const void* origin, uint32_t code) {
+    return RecordExceptionImpl(GetProgramCounter(), origin, code);
+  }
+  void RecordException(const void* pc, const void* origin, uint32_t code);
+
+  // Marks the tracked data as deleted.
+  void MarkDeleted();
+
+  // Gets the process ID used for tracking. This is typically the same as what
+  // the OS thinks is the current process but can be overridden for testing.
+  int64_t process_id() { return process_id_; }
+
+  // Accesses the process data record for storing arbitrary key/value pairs.
+  // Updates to this are thread-safe.
+  ActivityUserData& process_data() { return process_data_; }
+
+ private:
+  friend class GlobalActivityAnalyzer;
+  friend class ScopedThreadActivity;
+  friend class ActivityTrackerTest;
+
+  enum : int {
+    // The maximum number of threads that can be tracked within a process. If
+    // more than this number run concurrently, tracking of new ones may cease.
+    kMaxThreadCount = 100,
+    kCachedThreadMemories = 10,
+    kCachedUserDataMemories = 10,
+  };
+
+  // A wrapper around ActivityUserData that is thread-safe and thus can be used
+  // in the global scope without the requirement of being called from only one
+  // thread.
+  class ThreadSafeUserData : public ActivityUserData {
+   public:
+    ThreadSafeUserData(void* memory, size_t size, int64_t pid = 0);
+    ~ThreadSafeUserData() override;
+
+   private:
+    void Set(StringPiece name,
+             ValueType type,
+             const void* memory,
+             size_t size) override;
+
+    Lock data_lock_;
+
+    DISALLOW_COPY_AND_ASSIGN(ThreadSafeUserData);
+  };
+
+  // State of a module as stored in persistent memory. This supports a single
+  // loading of a module only. If modules are loaded multiple times at
+  // different addresses, only the last will be recorded and an unload will
+  // not revert to the information of any other addresses.
+  struct BASE_EXPORT ModuleInfoRecord {
+    // SHA1(ModuleInfoRecord): Increment this if structure changes!
+    static constexpr uint32_t kPersistentTypeId = 0x05DB5F41 + 1;
+
+    // Expected size for 32/64-bit check by PersistentMemoryAllocator.
+    static constexpr size_t kExpectedInstanceSize =
+        OwningProcess::kExpectedInstanceSize + 56;
+
+    // The atomic unfortunately makes this a "complex" class on some compilers
+    // and thus requires an out-of-line constructor & destructor even though
+    // they do nothing.
+    ModuleInfoRecord();
+    ~ModuleInfoRecord();
+
+    OwningProcess owner;            // The process that created this record.
+    uint64_t address;               // The base address of the module.
+    uint64_t load_time;             // Time of last load/unload.
+    uint64_t size;                  // The size of the module in bytes.
+    uint32_t timestamp;             // Opaque timestamp of the module.
+    uint32_t age;                   // Opaque "age" associated with the module.
+    uint8_t identifier[16];         // Opaque identifier for the module.
+    std::atomic<uint32_t> changes;  // Number load/unload actions.
+    uint16_t pickle_size;           // The size of the following pickle.
+    uint8_t loaded;                 // Flag if module is loaded or not.
+    char pickle[1];                 // Other strings; may allocate larger.
+
+    // Decodes/encodes storage structure from more generic info structure.
+    bool DecodeTo(GlobalActivityTracker::ModuleInfo* info,
+                  size_t record_size) const;
+    static ModuleInfoRecord* CreateFrom(
+        const GlobalActivityTracker::ModuleInfo& info,
+        PersistentMemoryAllocator* allocator);
+
+    // Updates the core information without changing the encoded strings. This
+    // is useful when a known module changes state (i.e. new load or unload).
+    bool UpdateFrom(const GlobalActivityTracker::ModuleInfo& info);
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(ModuleInfoRecord);
+  };
+
+  // A thin wrapper around the main thread-tracker that keeps additional
+  // information that the global tracker needs to handle joined threads.
+  class ManagedActivityTracker : public ThreadActivityTracker {
+   public:
+    ManagedActivityTracker(PersistentMemoryAllocator::Reference mem_reference,
+                           void* base,
+                           size_t size);
+    ~ManagedActivityTracker() override;
+
+    // The reference into persistent memory from which the thread-tracker's
+    // memory was created.
+    const PersistentMemoryAllocator::Reference mem_reference_;
+
+    // The physical address used for the thread-tracker's memory.
+    void* const mem_base_;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(ManagedActivityTracker);
+  };
+
+  // Creates a global tracker using a given persistent-memory |allocator| and
+  // providing the given |stack_depth| to each thread tracker it manages. The
+  // created object is activated so tracking has already started upon return.
+  // The |process_id| can be zero to get it from the OS but is taken for testing
+  // purposes.
+  GlobalActivityTracker(std::unique_ptr<PersistentMemoryAllocator> allocator,
+                        int stack_depth,
+                        int64_t process_id);
+
+  // Returns the memory used by an activity-tracker managed by this class.
+  // It is called during the destruction of a ManagedActivityTracker object.
+  void ReturnTrackerMemory(ManagedActivityTracker* tracker);
+
+  // Records exception information.
+  void RecordExceptionImpl(const void* pc, const void* origin, uint32_t code);
+
+  // Releases the activity-tracker associcated with thread. It is called
+  // automatically when a thread is joined and thus there is nothing more to
+  // be tracked. |value| is a pointer to a ManagedActivityTracker.
+  static void OnTLSDestroy(void* value);
+
+  // Does process-exit work. This can be run on any thread.
+  void CleanupAfterProcess(int64_t process_id,
+                           int64_t exit_stamp,
+                           int exit_code,
+                           std::string&& command_line);
+
+  // The persistent-memory allocator from which the memory for all trackers
+  // is taken.
+  std::unique_ptr<PersistentMemoryAllocator> allocator_;
+
+  // The size (in bytes) of memory required by a ThreadActivityTracker to
+  // provide the stack-depth requested during construction.
+  const size_t stack_memory_size_;
+
+  // The process-id of the current process. This is kept as a member variable,
+  // defined during initialization, for testing purposes.
+  const int64_t process_id_;
+
+  // The activity tracker for the currently executing thread.
+  ThreadLocalStorage::Slot this_thread_tracker_;
+
+  // The number of thread trackers currently active.
+  std::atomic<int> thread_tracker_count_;
+
+  // A caching memory allocator for thread-tracker objects.
+  ActivityTrackerMemoryAllocator thread_tracker_allocator_;
+  Lock thread_tracker_allocator_lock_;
+
+  // A caching memory allocator for user data attached to activity data.
+  ActivityTrackerMemoryAllocator user_data_allocator_;
+  Lock user_data_allocator_lock_;
+
+  // An object for holding arbitrary key value pairs with thread-safe access.
+  ThreadSafeUserData process_data_;
+
+  // A map of global module information, keyed by module path.
+  std::map<const std::string, ModuleInfoRecord*> modules_;
+  Lock modules_lock_;
+
+  // The active global activity tracker.
+  static subtle::AtomicWord g_tracker_;
+
+  // A lock that is used to protect access to the following fields.
+  Lock global_tracker_lock_;
+
+  // The collection of processes being tracked and their command-lines.
+  std::map<int64_t, std::string> known_processes_;
+
+  // A task-runner that can be used for doing background processing.
+  scoped_refptr<TaskRunner> background_task_runner_;
+
+  // A callback performed when a subprocess exits, including its exit-code
+  // and the phase it was in when that occurred. This will be called via
+  // the |background_task_runner_| if one is set or whatever thread reaped
+  // the process otherwise.
+  ProcessExitCallback process_exit_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(GlobalActivityTracker);
+};
+
+
+// Record entry in to and out of an arbitrary block of code.
+class BASE_EXPORT ScopedActivity
+    : public GlobalActivityTracker::ScopedThreadActivity {
+ public:
+  // Track activity at the specified FROM_HERE location for an arbitrary
+  // 4-bit |action|, an arbitrary 32-bit |id|, and 32-bits of arbitrary
+  // |info|. None of these values affect operation; they're all purely
+  // for association and analysis. To have unique identifiers across a
+  // diverse code-base, create the number by taking the first 8 characters
+  // of the hash of the activity being tracked.
+  //
+  // For example:
+  //   Tracking method: void MayNeverExit(uint32_t foo) {...}
+  //   echo -n "MayNeverExit" | sha1sum   =>   e44873ccab21e2b71270da24aa1...
+  //
+  //   void MayNeverExit(int32_t foo) {
+  //     base::debug::ScopedActivity track_me(0, 0xE44873CC, foo);
+  //     ...
+  //   }
+  ALWAYS_INLINE
+  ScopedActivity(uint8_t action, uint32_t id, int32_t info)
+      : ScopedActivity(GetProgramCounter(), action, id, info) {}
+  ScopedActivity() : ScopedActivity(0, 0, 0) {}
+
+  // Changes the |action| and/or |info| of this activity on the stack. This
+  // is useful for tracking progress through a function, updating the action
+  // to indicate "milestones" in the block (max 16 milestones: 0-15) or the
+  // info to reflect other changes. Changing both is not atomic so a snapshot
+  // operation could occur between the update of |action| and |info|.
+  void ChangeAction(uint8_t action);
+  void ChangeInfo(int32_t info);
+  void ChangeActionAndInfo(uint8_t action, int32_t info);
+
+ private:
+  // Constructs the object using a passed-in program-counter.
+  ScopedActivity(const void* program_counter,
+                 uint8_t action,
+                 uint32_t id,
+                 int32_t info);
+
+  // A copy of the ID code so it doesn't have to be passed by the caller when
+  // changing the |info| field.
+  uint32_t id_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedActivity);
+};
+
+
+// These "scoped" classes provide easy tracking of various blocking actions.
+
+class BASE_EXPORT ScopedTaskRunActivity
+    : public GlobalActivityTracker::ScopedThreadActivity {
+ public:
+  ALWAYS_INLINE
+  explicit ScopedTaskRunActivity(const PendingTask& task)
+      : ScopedTaskRunActivity(GetProgramCounter(), task) {}
+
+ private:
+  ScopedTaskRunActivity(const void* program_counter, const PendingTask& task);
+  DISALLOW_COPY_AND_ASSIGN(ScopedTaskRunActivity);
+};
+
+class BASE_EXPORT ScopedLockAcquireActivity
+    : public GlobalActivityTracker::ScopedThreadActivity {
+ public:
+  ALWAYS_INLINE
+  explicit ScopedLockAcquireActivity(const base::internal::LockImpl* lock)
+      : ScopedLockAcquireActivity(GetProgramCounter(), lock) {}
+
+ private:
+  ScopedLockAcquireActivity(const void* program_counter,
+                            const base::internal::LockImpl* lock);
+  DISALLOW_COPY_AND_ASSIGN(ScopedLockAcquireActivity);
+};
+
+class BASE_EXPORT ScopedEventWaitActivity
+    : public GlobalActivityTracker::ScopedThreadActivity {
+ public:
+  ALWAYS_INLINE
+  explicit ScopedEventWaitActivity(const WaitableEvent* event)
+      : ScopedEventWaitActivity(GetProgramCounter(), event) {}
+
+ private:
+  ScopedEventWaitActivity(const void* program_counter,
+                          const WaitableEvent* event);
+  DISALLOW_COPY_AND_ASSIGN(ScopedEventWaitActivity);
+};
+
+class BASE_EXPORT ScopedThreadJoinActivity
+    : public GlobalActivityTracker::ScopedThreadActivity {
+ public:
+  ALWAYS_INLINE
+  explicit ScopedThreadJoinActivity(const PlatformThreadHandle* thread)
+      : ScopedThreadJoinActivity(GetProgramCounter(), thread) {}
+
+ private:
+  ScopedThreadJoinActivity(const void* program_counter,
+                           const PlatformThreadHandle* thread);
+  DISALLOW_COPY_AND_ASSIGN(ScopedThreadJoinActivity);
+};
+
+// Some systems don't have base::Process
+#if !defined(OS_NACL) && !defined(OS_IOS)
+class BASE_EXPORT ScopedProcessWaitActivity
+    : public GlobalActivityTracker::ScopedThreadActivity {
+ public:
+  ALWAYS_INLINE
+  explicit ScopedProcessWaitActivity(const Process* process)
+      : ScopedProcessWaitActivity(GetProgramCounter(), process) {}
+
+ private:
+  ScopedProcessWaitActivity(const void* program_counter,
+                            const Process* process);
+  DISALLOW_COPY_AND_ASSIGN(ScopedProcessWaitActivity);
+};
+#endif
+
+}  // namespace debug
+}  // namespace base
+
+#endif  // BASE_DEBUG_ACTIVITY_TRACKER_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/alias.cc b/native/zucchini/vendor/libchrome/base/debug/alias.cc
new file mode 100644
index 0000000..ebc8b5a
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/debug/alias.cc
@@ -0,0 +1,27 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/debug/alias.h"
+#include "build/build_config.h"
+
+namespace base {
+namespace debug {
+
+#if defined(COMPILER_MSVC)
+#pragma optimize("", off)
+#elif defined(__clang__)
+#pragma clang optimize off
+#endif
+
+void Alias(const void* var) {
+}
+
+#if defined(COMPILER_MSVC)
+#pragma optimize("", on)
+#elif defined(__clang__)
+#pragma clang optimize on
+#endif
+
+}  // namespace debug
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/debug/alias.h b/native/zucchini/vendor/libchrome/base/debug/alias.h
new file mode 100644
index 0000000..128fdaa
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/debug/alias.h
@@ -0,0 +1,43 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_DEBUG_ALIAS_H_
+#define BASE_DEBUG_ALIAS_H_
+
+#include "base/base_export.h"
+#include "base/strings/string_util.h"
+
+namespace base {
+namespace debug {
+
+// Make the optimizer think that var is aliased. This is to prevent it from
+// optimizing out local variables that would not otherwise be live at the point
+// of a potential crash.
+// base::debug::Alias should only be used for local variables, not globals,
+// object members, or function return values - these must be copied to locals if
+// you want to ensure they are recorded in crash dumps.
+// Note that if the local variable is a pointer then its value will be retained
+// but the memory that it points to will probably not be saved in the crash
+// dump - by default only stack memory is saved. Therefore the aliasing
+// technique is usually only worthwhile with non-pointer variables. If you have
+// a pointer to an object and you want to retain the object's state you need to
+// copy the object or its fields to local variables. Example usage:
+//   int last_error = err_;
+//   base::debug::Alias(&last_error);
+//   DEBUG_ALIAS_FOR_CSTR(name_copy, p->name, 16);
+//   CHECK(false);
+void BASE_EXPORT Alias(const void* var);
+
+}  // namespace debug
+}  // namespace base
+
+// Convenience macro that copies the null-terminated string from |c_str| into a
+// stack-allocated char array named |var_name| that holds up to |char_count|
+// characters and should be preserved in memory dumps.
+#define DEBUG_ALIAS_FOR_CSTR(var_name, c_str, char_count)  \
+  char var_name[char_count];                               \
+  ::base::strlcpy(var_name, (c_str), arraysize(var_name)); \
+  ::base::debug::Alias(var_name);
+
+#endif  // BASE_DEBUG_ALIAS_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/debugger.h b/native/zucchini/vendor/libchrome/base/debug/debugger.h
new file mode 100644
index 0000000..8680e28
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/debug/debugger.h
@@ -0,0 +1,44 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This is a cross platform interface for helper functions related to
+// debuggers.  You should use this to test if you're running under a debugger,
+// and if you would like to yield (breakpoint) into the debugger.
+
+#ifndef BASE_DEBUG_DEBUGGER_H_
+#define BASE_DEBUG_DEBUGGER_H_
+
+#include "base/base_export.h"
+
+namespace base {
+namespace debug {
+
+// Waits wait_seconds seconds for a debugger to attach to the current process.
+// When silent is false, an exception is thrown when a debugger is detected.
+BASE_EXPORT bool WaitForDebugger(int wait_seconds, bool silent);
+
+// Returns true if the given process is being run under a debugger.
+//
+// On OS X, the underlying mechanism doesn't work when the sandbox is enabled.
+// To get around this, this function caches its value.
+//
+// WARNING: Because of this, on OS X, a call MUST be made to this function
+// BEFORE the sandbox is enabled.
+BASE_EXPORT bool BeingDebugged();
+
+// Break into the debugger, assumes a debugger is present.
+BASE_EXPORT void BreakDebugger();
+
+// Used in test code, this controls whether showing dialogs and breaking into
+// the debugger is suppressed for debug errors, even in debug mode (normally
+// release mode doesn't do this stuff --  this is controlled separately).
+// Normally UI is not suppressed.  This is normally used when running automated
+// tests where we want a crash rather than a dialog or a debugger.
+BASE_EXPORT void SetSuppressDebugUI(bool suppress);
+BASE_EXPORT bool IsDebugUISuppressed();
+
+}  // namespace debug
+}  // namespace base
+
+#endif  // BASE_DEBUG_DEBUGGER_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/debugger_posix.cc b/native/zucchini/vendor/libchrome/base/debug/debugger_posix.cc
new file mode 100644
index 0000000..b62bf01
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/debug/debugger_posix.cc
@@ -0,0 +1,272 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/debug/debugger.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <memory>
+#include <vector>
+
+#include "base/macros.h"
+#include "base/threading/platform_thread.h"
+#include "base/time/time.h"
+#include "build/build_config.h"
+
+#if defined(__GLIBCXX__)
+#include <cxxabi.h>
+#endif
+
+#if defined(OS_MACOSX)
+#include <AvailabilityMacros.h>
+#endif
+
+#if defined(OS_MACOSX) || defined(OS_BSD)
+#include <sys/sysctl.h>
+#endif
+
+#if defined(OS_FREEBSD)
+#include <sys/user.h>
+#endif
+
+#include <ostream>
+
+#include "base/debug/alias.h"
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#include "base/strings/string_piece.h"
+
+#if defined(USE_SYMBOLIZE)
+#include "base/third_party/symbolize/symbolize.h"
+#endif
+
+#if defined(OS_ANDROID)
+#include "base/threading/platform_thread.h"
+#endif
+
+namespace base {
+namespace debug {
+
+#if defined(OS_MACOSX) || defined(OS_BSD)
+
+// Based on Apple's recommended method as described in
+// http://developer.apple.com/qa/qa2004/qa1361.html
+bool BeingDebugged() {
+  // NOTE: This code MUST be async-signal safe (it's used by in-process
+  // stack dumping signal handler). NO malloc or stdio is allowed here.
+  //
+  // While some code used below may be async-signal unsafe, note how
+  // the result is cached (see |is_set| and |being_debugged| static variables
+  // right below). If this code is properly warmed-up early
+  // in the start-up process, it should be safe to use later.
+
+  // If the process is sandboxed then we can't use the sysctl, so cache the
+  // value.
+  static bool is_set = false;
+  static bool being_debugged = false;
+
+  if (is_set)
+    return being_debugged;
+
+  // Initialize mib, which tells sysctl what info we want.  In this case,
+  // we're looking for information about a specific process ID.
+  int mib[] = {
+    CTL_KERN,
+    KERN_PROC,
+    KERN_PROC_PID,
+    getpid()
+#if defined(OS_OPENBSD)
+    , sizeof(struct kinfo_proc),
+    0
+#endif
+  };
+
+  // Caution: struct kinfo_proc is marked __APPLE_API_UNSTABLE.  The source and
+  // binary interfaces may change.
+  struct kinfo_proc info;
+  size_t info_size = sizeof(info);
+
+#if defined(OS_OPENBSD)
+  if (sysctl(mib, arraysize(mib), NULL, &info_size, NULL, 0) < 0)
+    return -1;
+
+  mib[5] = (info_size / sizeof(struct kinfo_proc));
+#endif
+
+  int sysctl_result = sysctl(mib, arraysize(mib), &info, &info_size, NULL, 0);
+  DCHECK_EQ(sysctl_result, 0);
+  if (sysctl_result != 0) {
+    is_set = true;
+    being_debugged = false;
+    return being_debugged;
+  }
+
+  // This process is being debugged if the P_TRACED flag is set.
+  is_set = true;
+#if defined(OS_FREEBSD)
+  being_debugged = (info.ki_flag & P_TRACED) != 0;
+#elif defined(OS_BSD)
+  being_debugged = (info.p_flag & P_TRACED) != 0;
+#else
+  being_debugged = (info.kp_proc.p_flag & P_TRACED) != 0;
+#endif
+  return being_debugged;
+}
+
+#elif defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_AIX)
+
+// We can look in /proc/self/status for TracerPid.  We are likely used in crash
+// handling, so we are careful not to use the heap or have side effects.
+// Another option that is common is to try to ptrace yourself, but then we
+// can't detach without forking(), and that's not so great.
+// static
+bool BeingDebugged() {
+  // NOTE: This code MUST be async-signal safe (it's used by in-process
+  // stack dumping signal handler). NO malloc or stdio is allowed here.
+
+  int status_fd = open("/proc/self/status", O_RDONLY);
+  if (status_fd == -1)
+    return false;
+
+  // We assume our line will be in the first 1024 characters and that we can
+  // read this much all at once.  In practice this will generally be true.
+  // This simplifies and speeds up things considerably.
+  char buf[1024];
+
+  ssize_t num_read = HANDLE_EINTR(read(status_fd, buf, sizeof(buf)));
+  if (IGNORE_EINTR(close(status_fd)) < 0)
+    return false;
+
+  if (num_read <= 0)
+    return false;
+
+  StringPiece status(buf, num_read);
+  StringPiece tracer("TracerPid:\t");
+
+  StringPiece::size_type pid_index = status.find(tracer);
+  if (pid_index == StringPiece::npos)
+    return false;
+
+  // Our pid is 0 without a debugger, assume this for any pid starting with 0.
+  pid_index += tracer.size();
+  return pid_index < status.size() && status[pid_index] != '0';
+}
+
+#elif defined(OS_FUCHSIA)
+
+bool BeingDebugged() {
+  // TODO(fuchsia): No gdb/gdbserver in the SDK yet.
+  return false;
+}
+
+#else
+
+bool BeingDebugged() {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+#endif
+
+// We want to break into the debugger in Debug mode, and cause a crash dump in
+// Release mode. Breakpad behaves as follows:
+//
+// +-------+-----------------+-----------------+
+// | OS    | Dump on SIGTRAP | Dump on SIGABRT |
+// +-------+-----------------+-----------------+
+// | Linux |       N         |        Y        |
+// | Mac   |       Y         |        N        |
+// +-------+-----------------+-----------------+
+//
+// Thus we do the following:
+// Linux: Debug mode if a debugger is attached, send SIGTRAP; otherwise send
+//        SIGABRT
+// Mac: Always send SIGTRAP.
+
+#if defined(ARCH_CPU_ARMEL)
+#define DEBUG_BREAK_ASM() asm("bkpt 0")
+#elif defined(ARCH_CPU_ARM64)
+#define DEBUG_BREAK_ASM() asm("brk 0")
+#elif defined(ARCH_CPU_MIPS_FAMILY)
+#define DEBUG_BREAK_ASM() asm("break 2")
+#elif defined(ARCH_CPU_X86_FAMILY)
+#define DEBUG_BREAK_ASM() asm("int3")
+#endif
+
+#if defined(NDEBUG) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
+#define DEBUG_BREAK() abort()
+#elif defined(OS_NACL)
+// The NaCl verifier doesn't let use use int3.  For now, we call abort().  We
+// should ask for advice from some NaCl experts about the optimum thing here.
+// http://code.google.com/p/nativeclient/issues/detail?id=645
+#define DEBUG_BREAK() abort()
+#elif !defined(OS_MACOSX)
+// Though Android has a "helpful" process called debuggerd to catch native
+// signals on the general assumption that they are fatal errors. If no debugger
+// is attached, we call abort since Breakpad needs SIGABRT to create a dump.
+// When debugger is attached, for ARM platform the bkpt instruction appears
+// to cause SIGBUS which is trapped by debuggerd, and we've had great
+// difficulty continuing in a debugger once we stop from SIG triggered by native
+// code, use GDB to set |go| to 1 to resume execution; for X86 platform, use
+// "int3" to setup breakpiont and raise SIGTRAP.
+//
+// On other POSIX architectures, except Mac OS X, we use the same logic to
+// ensure that breakpad creates a dump on crashes while it is still possible to
+// use a debugger.
+namespace {
+void DebugBreak() {
+  if (!BeingDebugged()) {
+    abort();
+  } else {
+#if defined(DEBUG_BREAK_ASM)
+    DEBUG_BREAK_ASM();
+#else
+    volatile int go = 0;
+    while (!go) {
+      base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
+    }
+#endif
+  }
+}
+}  // namespace
+#define DEBUG_BREAK() DebugBreak()
+#elif defined(DEBUG_BREAK_ASM)
+#define DEBUG_BREAK() DEBUG_BREAK_ASM()
+#else
+#error "Don't know how to debug break on this architecture/OS"
+#endif
+
+void BreakDebugger() {
+  // NOTE: This code MUST be async-signal safe (it's used by in-process
+  // stack dumping signal handler). NO malloc or stdio is allowed here.
+
+  // Linker's ICF feature may merge this function with other functions with the
+  // same definition (e.g. any function whose sole job is to call abort()) and
+  // it may confuse the crash report processing system. http://crbug.com/508489
+  static int static_variable_to_make_this_function_unique = 0;
+  base::debug::Alias(&static_variable_to_make_this_function_unique);
+
+  DEBUG_BREAK();
+#if defined(OS_ANDROID) && !defined(OFFICIAL_BUILD)
+  // For Android development we always build release (debug builds are
+  // unmanageably large), so the unofficial build is used for debugging. It is
+  // helpful to be able to insert BreakDebugger() statements in the source,
+  // attach the debugger, inspect the state of the program and then resume it by
+  // setting the 'go' variable above.
+#elif defined(NDEBUG)
+  // Terminate the program after signaling the debug break.
+  _exit(1);
+#endif
+}
+
+}  // namespace debug
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/debug/debugging_buildflags.h b/native/zucchini/vendor/libchrome/base/debug/debugging_buildflags.h
new file mode 100644
index 0000000..33e3dd0
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/debug/debugging_buildflags.h
@@ -0,0 +1,12 @@
+// Generated by build/write_buildflag_header.py
+// From "base_debugging_flags"
+#ifndef BASE_DEBUG_DEBUGGING_FLAGS_H_
+#define BASE_DEBUG_DEBUGGING_FLAGS_H_
+#include "build/buildflag.h"
+#define BUILDFLAG_INTERNAL_ENABLE_PROFILING() (0)
+#define BUILDFLAG_INTERNAL_ENABLE_MEMORY_TASK_PROFILER() (0)
+#define BUILDFLAG_INTERNAL_CAN_UNWIND_WITH_FRAME_POINTERS() (0)
+#define BUILDFLAG_INTERNAL_ENABLE_LOCATION_SOURCE() (0)
+#define BUILDFLAG_INTERNAL_CFI_ENFORCEMENT_TRAP() (0)
+#define BUILDFLAG_INTERNAL_ENABLE_MUTEX_PRIORITY_INHERITANCE() (0)
+#endif  // BASE_DEBUG_DEBUGGING_FLAGS_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/leak_annotations.h b/native/zucchini/vendor/libchrome/base/debug/leak_annotations.h
new file mode 100644
index 0000000..dc50246
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/debug/leak_annotations.h
@@ -0,0 +1,46 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_DEBUG_LEAK_ANNOTATIONS_H_
+#define BASE_DEBUG_LEAK_ANNOTATIONS_H_
+
+#include "base/macros.h"
+#include "build/build_config.h"
+
+// This file defines macros which can be used to annotate intentional memory
+// leaks. Support for annotations is implemented in LeakSanitizer. Annotated
+// objects will be treated as a source of live pointers, i.e. any heap objects
+// reachable by following pointers from an annotated object will not be
+// reported as leaks.
+//
+// ANNOTATE_SCOPED_MEMORY_LEAK: all allocations made in the current scope
+// will be annotated as leaks.
+// ANNOTATE_LEAKING_OBJECT_PTR(X): the heap object referenced by pointer X will
+// be annotated as a leak.
+
+#if defined(LEAK_SANITIZER) && !defined(OS_NACL)
+
+#include <sanitizer/lsan_interface.h>
+
+class ScopedLeakSanitizerDisabler {
+ public:
+  ScopedLeakSanitizerDisabler() { __lsan_disable(); }
+  ~ScopedLeakSanitizerDisabler() { __lsan_enable(); }
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScopedLeakSanitizerDisabler);
+};
+
+#define ANNOTATE_SCOPED_MEMORY_LEAK \
+    ScopedLeakSanitizerDisabler leak_sanitizer_disabler; static_cast<void>(0)
+
+#define ANNOTATE_LEAKING_OBJECT_PTR(X) __lsan_ignore_object(X);
+
+#else
+
+#define ANNOTATE_SCOPED_MEMORY_LEAK ((void)0)
+#define ANNOTATE_LEAKING_OBJECT_PTR(X) ((void)0)
+
+#endif
+
+#endif  // BASE_DEBUG_LEAK_ANNOTATIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/proc_maps_linux.h b/native/zucchini/vendor/libchrome/base/debug/proc_maps_linux.h
new file mode 100644
index 0000000..f5f8a59
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/debug/proc_maps_linux.h
@@ -0,0 +1,94 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_DEBUG_PROC_MAPS_LINUX_H_
+#define BASE_DEBUG_PROC_MAPS_LINUX_H_
+
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+
+#include "base/base_export.h"
+
+namespace base {
+namespace debug {
+
+// Describes a region of mapped memory and the path of the file mapped.
+struct MappedMemoryRegion {
+  enum Permission {
+    READ = 1 << 0,
+    WRITE = 1 << 1,
+    EXECUTE = 1 << 2,
+    PRIVATE = 1 << 3,  // If set, region is private, otherwise it is shared.
+  };
+
+  // The address range [start,end) of mapped memory.
+  uintptr_t start;
+  uintptr_t end;
+
+  // Byte offset into |path| of the range mapped into memory.
+  unsigned long long offset;
+
+  // Image base, if this mapping corresponds to an ELF image.
+  uintptr_t base;
+
+  // Bitmask of read/write/execute/private/shared permissions.
+  uint8_t permissions;
+
+  // Name of the file mapped into memory.
+  //
+  // NOTE: path names aren't guaranteed to point at valid files. For example,
+  // "[heap]" and "[stack]" are used to represent the location of the process'
+  // heap and stack, respectively.
+  std::string path;
+};
+
+// Reads the data from /proc/self/maps and stores the result in |proc_maps|.
+// Returns true if successful, false otherwise.
+//
+// There is *NO* guarantee that the resulting contents will be free of
+// duplicates or even contain valid entries by time the method returns.
+//
+//
+// THE GORY DETAILS
+//
+// Did you know it's next-to-impossible to atomically read the whole contents
+// of /proc/<pid>/maps? You would think that if we passed in a large-enough
+// buffer to read() that It Should Just Work(tm), but sadly that's not the case.
+//
+// Linux's procfs uses seq_file [1] for handling iteration, text formatting,
+// and dealing with resulting data that is larger than the size of a page. That
+// last bit is especially important because it means that seq_file will never
+// return more than the size of a page in a single call to read().
+//
+// Unfortunately for a program like Chrome the size of /proc/self/maps is
+// larger than the size of page so we're forced to call read() multiple times.
+// If the virtual memory table changed in any way between calls to read() (e.g.,
+// a different thread calling mprotect()), it can make seq_file generate
+// duplicate entries or skip entries.
+//
+// Even if seq_file was changed to keep flushing the contents of its page-sized
+// buffer to the usermode buffer inside a single call to read(), it has to
+// release its lock on the virtual memory table to handle page faults while
+// copying data to usermode. This puts us in the same situation where the table
+// can change while we're copying data.
+//
+// Alternatives such as fork()-and-suspend-the-parent-while-child-reads were
+// attempted, but they present more subtle problems than it's worth. Depending
+// on your use case your best bet may be to read /proc/<pid>/maps prior to
+// starting other threads.
+//
+// [1] http://kernelnewbies.org/Documents/SeqFileHowTo
+BASE_EXPORT bool ReadProcMaps(std::string* proc_maps);
+
+// Parses /proc/<pid>/maps input data and stores in |regions|. Returns true
+// and updates |regions| if and only if all of |input| was successfully parsed.
+BASE_EXPORT bool ParseProcMaps(const std::string& input,
+                               std::vector<MappedMemoryRegion>* regions);
+
+}  // namespace debug
+}  // namespace base
+
+#endif  // BASE_DEBUG_PROC_MAPS_LINUX_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/stack_trace.cc b/native/zucchini/vendor/libchrome/base/debug/stack_trace.cc
new file mode 100644
index 0000000..7715121
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/debug/stack_trace.cc
@@ -0,0 +1,277 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/debug/stack_trace.h"
+
+#include <string.h>
+
+#include <algorithm>
+#include <sstream>
+
+#include "base/logging.h"
+#include "base/macros.h"
+
+#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
+
+#if defined(OS_LINUX) || defined(OS_ANDROID)
+#include <pthread.h>
+#include "base/process/process_handle.h"
+#include "base/threading/platform_thread.h"
+#endif
+
+#if defined(OS_MACOSX)
+#include <pthread.h>
+#endif
+
+#if defined(OS_LINUX) && defined(__GLIBC__)
+extern "C" void* __libc_stack_end;
+#endif
+
+#endif  // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
+
+namespace base {
+namespace debug {
+
+namespace {
+
+#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
+
+#if defined(__arm__) && defined(__GNUC__) && !defined(__clang__)
+// GCC and LLVM generate slightly different frames on ARM, see
+// https://llvm.org/bugs/show_bug.cgi?id=18505 - LLVM generates
+// x86-compatible frame, while GCC needs adjustment.
+constexpr size_t kStackFrameAdjustment = sizeof(uintptr_t);
+#else
+constexpr size_t kStackFrameAdjustment = 0;
+#endif
+
+uintptr_t GetNextStackFrame(uintptr_t fp) {
+  return reinterpret_cast<const uintptr_t*>(fp)[0] - kStackFrameAdjustment;
+}
+
+uintptr_t GetStackFramePC(uintptr_t fp) {
+  return reinterpret_cast<const uintptr_t*>(fp)[1];
+}
+
+bool IsStackFrameValid(uintptr_t fp, uintptr_t prev_fp, uintptr_t stack_end) {
+  // With the stack growing downwards, older stack frame must be
+  // at a greater address that the current one.
+  if (fp <= prev_fp) return false;
+
+  // Assume huge stack frames are bogus.
+  if (fp - prev_fp > 100000) return false;
+
+  // Check alignment.
+  if (fp & (sizeof(uintptr_t) - 1)) return false;
+
+  if (stack_end) {
+    // Both fp[0] and fp[1] must be within the stack.
+    if (fp > stack_end - 2 * sizeof(uintptr_t)) return false;
+
+    // Additional check to filter out false positives.
+    if (GetStackFramePC(fp) < 32768) return false;
+  }
+
+  return true;
+};
+
+// ScanStackForNextFrame() scans the stack for a valid frame to allow unwinding
+// past system libraries. Only supported on Linux where system libraries are
+// usually in the middle of the trace:
+//
+//   TraceStackFramePointers
+//   <more frames from Chrome>
+//   base::WorkSourceDispatch   <-- unwinding stops (next frame is invalid),
+//   g_main_context_dispatch        ScanStackForNextFrame() is called
+//   <more frames from glib>
+//   g_main_context_iteration
+//   base::MessagePumpGlib::Run <-- ScanStackForNextFrame() finds valid frame,
+//   base::RunLoop::Run             unwinding resumes
+//   <more frames from Chrome>
+//   __libc_start_main
+//
+// For stack scanning to be efficient it's very important for the thread to
+// be started by Chrome. In that case we naturally terminate unwinding once
+// we reach the origin of the stack (i.e. GetStackEnd()). If the thread is
+// not started by Chrome (e.g. Android's main thread), then we end up always
+// scanning area at the origin of the stack, wasting time and not finding any
+// frames (since Android libraries don't have frame pointers).
+//
+// ScanStackForNextFrame() returns 0 if it couldn't find a valid frame
+// (or if stack scanning is not supported on the current platform).
+uintptr_t ScanStackForNextFrame(uintptr_t fp, uintptr_t stack_end) {
+#if defined(OS_LINUX)
+  // Enough to resume almost all prematurely terminated traces.
+  constexpr size_t kMaxStackScanArea = 8192;
+
+  if (!stack_end) {
+    // Too dangerous to scan without knowing where the stack ends.
+    return 0;
+  }
+
+  fp += sizeof(uintptr_t);  // current frame is known to be invalid
+  uintptr_t last_fp_to_scan = std::min(fp + kMaxStackScanArea, stack_end) -
+                                  sizeof(uintptr_t);
+  for (;fp <= last_fp_to_scan; fp += sizeof(uintptr_t)) {
+    uintptr_t next_fp = GetNextStackFrame(fp);
+    if (IsStackFrameValid(next_fp, fp, stack_end)) {
+      // Check two frames deep. Since stack frame is just a pointer to
+      // a higher address on the stack, it's relatively easy to find
+      // something that looks like one. However two linked frames are
+      // far less likely to be bogus.
+      uintptr_t next2_fp = GetNextStackFrame(next_fp);
+      if (IsStackFrameValid(next2_fp, next_fp, stack_end)) {
+        return fp;
+      }
+    }
+  }
+#endif  // defined(OS_LINUX)
+
+  return 0;
+}
+
+// Links stack frame |fp| to |parent_fp|, so that during stack unwinding
+// TraceStackFramePointers() visits |parent_fp| after visiting |fp|.
+// Both frame pointers must come from __builtin_frame_address().
+// Returns previous stack frame |fp| was linked to.
+void* LinkStackFrames(void* fpp, void* parent_fp) {
+  uintptr_t fp = reinterpret_cast<uintptr_t>(fpp) - kStackFrameAdjustment;
+  void* prev_parent_fp = reinterpret_cast<void**>(fp)[0];
+  reinterpret_cast<void**>(fp)[0] = parent_fp;
+  return prev_parent_fp;
+}
+
+#endif  // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
+
+}  // namespace
+
+#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
+uintptr_t GetStackEnd() {
+#if defined(OS_ANDROID)
+  // Bionic reads proc/maps on every call to pthread_getattr_np() when called
+  // from the main thread. So we need to cache end of stack in that case to get
+  // acceptable performance.
+  // For all other threads pthread_getattr_np() is fast enough as it just reads
+  // values from its pthread_t argument.
+  static uintptr_t main_stack_end = 0;
+
+  bool is_main_thread = GetCurrentProcId() == PlatformThread::CurrentId();
+  if (is_main_thread && main_stack_end) {
+    return main_stack_end;
+  }
+
+  uintptr_t stack_begin = 0;
+  size_t stack_size = 0;
+  pthread_attr_t attributes;
+  int error = pthread_getattr_np(pthread_self(), &attributes);
+  if (!error) {
+    error = pthread_attr_getstack(
+        &attributes, reinterpret_cast<void**>(&stack_begin), &stack_size);
+    pthread_attr_destroy(&attributes);
+  }
+  DCHECK(!error);
+
+  uintptr_t stack_end = stack_begin + stack_size;
+  if (is_main_thread) {
+    main_stack_end = stack_end;
+  }
+  return stack_end;  // 0 in case of error
+
+#elif defined(OS_LINUX) && defined(__GLIBC__)
+
+  if (GetCurrentProcId() == PlatformThread::CurrentId()) {
+    // For the main thread we have a shortcut.
+    return reinterpret_cast<uintptr_t>(__libc_stack_end);
+  }
+
+// No easy way to get end of the stack for non-main threads,
+// see crbug.com/617730.
+#elif defined(OS_MACOSX)
+  return reinterpret_cast<uintptr_t>(pthread_get_stackaddr_np(pthread_self()));
+#endif
+
+  // Don't know how to get end of the stack.
+  return 0;
+}
+#endif  // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
+
+StackTrace::StackTrace() : StackTrace(arraysize(trace_)) {}
+
+StackTrace::StackTrace(const void* const* trace, size_t count) {
+  count = std::min(count, arraysize(trace_));
+  if (count)
+    memcpy(trace_, trace, count * sizeof(trace_[0]));
+  count_ = count;
+}
+
+const void *const *StackTrace::Addresses(size_t* count) const {
+  *count = count_;
+  if (count_)
+    return trace_;
+  return nullptr;
+}
+
+std::string StackTrace::ToString() const {
+  std::stringstream stream;
+#if !defined(__UCLIBC__) && !defined(_AIX)
+  OutputToStream(&stream);
+#endif
+  return stream.str();
+}
+
+#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
+
+size_t TraceStackFramePointers(const void** out_trace,
+                               size_t max_depth,
+                               size_t skip_initial) {
+  // Usage of __builtin_frame_address() enables frame pointers in this
+  // function even if they are not enabled globally. So 'fp' will always
+  // be valid.
+  uintptr_t fp = reinterpret_cast<uintptr_t>(__builtin_frame_address(0)) -
+                    kStackFrameAdjustment;
+
+  uintptr_t stack_end = GetStackEnd();
+
+  size_t depth = 0;
+  while (depth < max_depth) {
+    if (skip_initial != 0) {
+      skip_initial--;
+    } else {
+      out_trace[depth++] = reinterpret_cast<const void*>(GetStackFramePC(fp));
+    }
+
+    uintptr_t next_fp = GetNextStackFrame(fp);
+    if (IsStackFrameValid(next_fp, fp, stack_end)) {
+      fp = next_fp;
+      continue;
+    }
+
+    next_fp = ScanStackForNextFrame(fp, stack_end);
+    if (next_fp) {
+      fp = next_fp;
+      continue;
+    }
+
+    // Failed to find next frame.
+    break;
+  }
+
+  return depth;
+}
+
+ScopedStackFrameLinker::ScopedStackFrameLinker(void* fp, void* parent_fp)
+    : fp_(fp),
+      parent_fp_(parent_fp),
+      original_parent_fp_(LinkStackFrames(fp, parent_fp)) {}
+
+ScopedStackFrameLinker::~ScopedStackFrameLinker() {
+  void* previous_parent_fp = LinkStackFrames(fp_, original_parent_fp_);
+  CHECK_EQ(parent_fp_, previous_parent_fp)
+      << "Stack frame's parent pointer has changed!";
+}
+
+#endif  // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
+
+}  // namespace debug
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/debug/stack_trace.h b/native/zucchini/vendor/libchrome/base/debug/stack_trace.h
new file mode 100644
index 0000000..81e6672
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/debug/stack_trace.h
@@ -0,0 +1,197 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_DEBUG_STACK_TRACE_H_
+#define BASE_DEBUG_STACK_TRACE_H_
+
+#include <stddef.h>
+
+#include <iosfwd>
+#include <string>
+
+#include "base/base_export.h"
+#include "base/debug/debugging_buildflags.h"
+#include "base/macros.h"
+#include "build/build_config.h"
+
+#if defined(OS_POSIX)
+#include <unistd.h>
+#endif
+
+#if defined(OS_WIN)
+struct _EXCEPTION_POINTERS;
+struct _CONTEXT;
+#endif
+
+namespace base {
+namespace debug {
+
+// Enables stack dump to console output on exception and signals.
+// When enabled, the process will quit immediately. This is meant to be used in
+// unit_tests only! This is not thread-safe: only call from main thread.
+// In sandboxed processes, this has to be called before the sandbox is turned
+// on.
+// Calling this function on Linux opens /proc/self/maps and caches its
+// contents. In non-official builds, this function also opens the object files
+// that are loaded in memory and caches their file descriptors (this cannot be
+// done in official builds because it has security implications).
+BASE_EXPORT bool EnableInProcessStackDumping();
+
+#if defined(OS_POSIX)
+BASE_EXPORT void SetStackDumpFirstChanceCallback(bool (*handler)(int,
+                                                                 void*,
+                                                                 void*));
+#endif
+
+// Returns end of the stack, or 0 if we couldn't get it.
+#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
+BASE_EXPORT uintptr_t GetStackEnd();
+#endif
+
+// A stacktrace can be helpful in debugging. For example, you can include a
+// stacktrace member in a object (probably around #ifndef NDEBUG) so that you
+// can later see where the given object was created from.
+class BASE_EXPORT StackTrace {
+ public:
+  // Creates a stacktrace from the current location.
+  StackTrace();
+
+  // Creates a stacktrace from the current location, of up to |count| entries.
+  // |count| will be limited to at most |kMaxTraces|.
+  explicit StackTrace(size_t count);
+
+  // Creates a stacktrace from an existing array of instruction
+  // pointers (such as returned by Addresses()).  |count| will be
+  // limited to at most |kMaxTraces|.
+  StackTrace(const void* const* trace, size_t count);
+
+#if defined(OS_WIN)
+  // Creates a stacktrace for an exception.
+  // Note: this function will throw an import not found (StackWalk64) exception
+  // on system without dbghelp 5.1.
+  StackTrace(_EXCEPTION_POINTERS* exception_pointers);
+  StackTrace(const _CONTEXT* context);
+#endif
+
+  // Copying and assignment are allowed with the default functions.
+
+  // Gets an array of instruction pointer values. |*count| will be set to the
+  // number of elements in the returned array.
+  const void* const* Addresses(size_t* count) const;
+
+  // Prints the stack trace to stderr.
+  void Print() const;
+
+#if !defined(__UCLIBC__) & !defined(_AIX)
+  // Resolves backtrace to symbols and write to stream.
+  void OutputToStream(std::ostream* os) const;
+#endif
+
+  // Resolves backtrace to symbols and returns as string.
+  std::string ToString() const;
+
+ private:
+#if defined(OS_WIN)
+  void InitTrace(const _CONTEXT* context_record);
+#endif
+
+  // From http://msdn.microsoft.com/en-us/library/bb204633.aspx,
+  // the sum of FramesToSkip and FramesToCapture must be less than 63,
+  // so set it to 62. Even if on POSIX it could be a larger value, it usually
+  // doesn't give much more information.
+  static const int kMaxTraces = 62;
+
+  void* trace_[kMaxTraces];
+
+  // The number of valid frames in |trace_|.
+  size_t count_;
+};
+
+#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
+// Traces the stack by using frame pointers. This function is faster but less
+// reliable than StackTrace. It should work for debug and profiling builds,
+// but not for release builds (although there are some exceptions).
+//
+// Writes at most |max_depth| frames (instruction pointers) into |out_trace|
+// after skipping |skip_initial| frames. Note that the function itself is not
+// added to the trace so |skip_initial| should be 0 in most cases.
+// Returns number of frames written.
+BASE_EXPORT size_t TraceStackFramePointers(const void** out_trace,
+                                           size_t max_depth,
+                                           size_t skip_initial);
+
+// Links stack frame |fp| to |parent_fp|, so that during stack unwinding
+// TraceStackFramePointers() visits |parent_fp| after visiting |fp|.
+// Both frame pointers must come from __builtin_frame_address().
+// Destructor restores original linkage of |fp| to avoid corrupting caller's
+// frame register on return.
+//
+// This class can be used to repair broken stack frame chain in cases
+// when execution flow goes into code built without frame pointers:
+//
+// void DoWork() {
+//   Call_SomeLibrary();
+// }
+// static __thread void*  g_saved_fp;
+// void Call_SomeLibrary() {
+//   g_saved_fp = __builtin_frame_address(0);
+//   some_library_call(...); // indirectly calls SomeLibrary_Callback()
+// }
+// void SomeLibrary_Callback() {
+//   ScopedStackFrameLinker linker(__builtin_frame_address(0), g_saved_fp);
+//   ...
+//   TraceStackFramePointers(...);
+// }
+//
+// This produces the following trace:
+//
+// #0 SomeLibrary_Callback()
+// #1 <address of the code inside SomeLibrary that called #0>
+// #2 DoWork()
+// ...rest of the trace...
+//
+// SomeLibrary doesn't use frame pointers, so when SomeLibrary_Callback()
+// is called, stack frame register contains bogus value that becomes callback'
+// parent frame address. Without ScopedStackFrameLinker unwinding would've
+// stopped at that bogus frame address yielding just two first frames (#0, #1).
+// ScopedStackFrameLinker overwrites callback's parent frame address with
+// Call_SomeLibrary's frame, so unwinder produces full trace without even
+// noticing that stack frame chain was broken.
+class BASE_EXPORT ScopedStackFrameLinker {
+ public:
+  ScopedStackFrameLinker(void* fp, void* parent_fp);
+  ~ScopedStackFrameLinker();
+
+ private:
+  void* fp_;
+  void* parent_fp_;
+  void* original_parent_fp_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedStackFrameLinker);
+};
+
+#endif  // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
+
+namespace internal {
+
+#if defined(OS_POSIX) && !defined(OS_ANDROID)
+// POSIX doesn't define any async-signal safe function for converting
+// an integer to ASCII. We'll have to define our own version.
+// itoa_r() converts a (signed) integer to ASCII. It returns "buf", if the
+// conversion was successful or NULL otherwise. It never writes more than "sz"
+// bytes. Output will be truncated as needed, and a NUL character is always
+// appended.
+BASE_EXPORT char *itoa_r(intptr_t i,
+                         char *buf,
+                         size_t sz,
+                         int base,
+                         size_t padding);
+#endif  // defined(OS_POSIX) && !defined(OS_ANDROID)
+
+}  // namespace internal
+
+}  // namespace debug
+}  // namespace base
+
+#endif  // BASE_DEBUG_STACK_TRACE_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/stack_trace_posix.cc b/native/zucchini/vendor/libchrome/base/debug/stack_trace_posix.cc
new file mode 100644
index 0000000..f3f05da
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/debug/stack_trace_posix.cc
@@ -0,0 +1,898 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/debug/stack_trace.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <vector>
+
+#if !defined(USE_SYMBOLIZE)
+#include <cxxabi.h>
+#endif
+#if !defined(__UCLIBC__) && !defined(_AIX)
+#include <execinfo.h>
+#endif
+
+#if defined(OS_MACOSX)
+#include <AvailabilityMacros.h>
+#endif
+
+#if defined(OS_LINUX)
+#include "base/debug/proc_maps_linux.h"
+#endif
+
+#include "base/cfi_buildflags.h"
+#include "base/debug/debugger.h"
+#include "base/files/scoped_file.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/free_deleter.h"
+#include "base/memory/singleton.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/posix/eintr_wrapper.h"
+#include "base/strings/string_number_conversions.h"
+#include "build/build_config.h"
+
+#if defined(USE_SYMBOLIZE)
+#include "base/third_party/symbolize/symbolize.h"
+#endif
+
+namespace base {
+namespace debug {
+
+namespace {
+
+volatile sig_atomic_t in_signal_handler = 0;
+
+bool (*try_handle_signal)(int, void*, void*) = nullptr;
+
+#if !defined(USE_SYMBOLIZE)
+// The prefix used for mangled symbols, per the Itanium C++ ABI:
+// http://www.codesourcery.com/cxx-abi/abi.html#mangling
+const char kMangledSymbolPrefix[] = "_Z";
+
+// Characters that can be used for symbols, generated by Ruby:
+// (('a'..'z').to_a+('A'..'Z').to_a+('0'..'9').to_a + ['_']).join
+const char kSymbolCharacters[] =
+    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
+#endif  // !defined(USE_SYMBOLIZE)
+
+#if !defined(USE_SYMBOLIZE)
+// Demangles C++ symbols in the given text. Example:
+//
+// "out/Debug/base_unittests(_ZN10StackTraceC1Ev+0x20) [0x817778c]"
+// =>
+// "out/Debug/base_unittests(StackTrace::StackTrace()+0x20) [0x817778c]"
+void DemangleSymbols(std::string* text) {
+  // Note: code in this function is NOT async-signal safe (std::string uses
+  // malloc internally).
+
+#if !defined(__UCLIBC__) && !defined(_AIX)
+  std::string::size_type search_from = 0;
+  while (search_from < text->size()) {
+    // Look for the start of a mangled symbol, from search_from.
+    std::string::size_type mangled_start =
+        text->find(kMangledSymbolPrefix, search_from);
+    if (mangled_start == std::string::npos) {
+      break;  // Mangled symbol not found.
+    }
+
+    // Look for the end of the mangled symbol.
+    std::string::size_type mangled_end =
+        text->find_first_not_of(kSymbolCharacters, mangled_start);
+    if (mangled_end == std::string::npos) {
+      mangled_end = text->size();
+    }
+    std::string mangled_symbol =
+        text->substr(mangled_start, mangled_end - mangled_start);
+
+    // Try to demangle the mangled symbol candidate.
+    int status = 0;
+    std::unique_ptr<char, base::FreeDeleter> demangled_symbol(
+        abi::__cxa_demangle(mangled_symbol.c_str(), nullptr, 0, &status));
+    if (status == 0) {  // Demangling is successful.
+      // Remove the mangled symbol.
+      text->erase(mangled_start, mangled_end - mangled_start);
+      // Insert the demangled symbol.
+      text->insert(mangled_start, demangled_symbol.get());
+      // Next time, we'll start right after the demangled symbol we inserted.
+      search_from = mangled_start + strlen(demangled_symbol.get());
+    } else {
+      // Failed to demangle.  Retry after the "_Z" we just found.
+      search_from = mangled_start + 2;
+    }
+  }
+#endif  // !defined(__UCLIBC__) && !defined(_AIX)
+}
+#endif  // !defined(USE_SYMBOLIZE)
+
+class BacktraceOutputHandler {
+ public:
+  virtual void HandleOutput(const char* output) = 0;
+
+ protected:
+  virtual ~BacktraceOutputHandler() = default;
+};
+
+#if !defined(__UCLIBC__) && !defined(_AIX)
+void OutputPointer(void* pointer, BacktraceOutputHandler* handler) {
+  // This should be more than enough to store a 64-bit number in hex:
+  // 16 hex digits + 1 for null-terminator.
+  char buf[17] = { '\0' };
+  handler->HandleOutput("0x");
+  internal::itoa_r(reinterpret_cast<intptr_t>(pointer),
+                   buf, sizeof(buf), 16, 12);
+  handler->HandleOutput(buf);
+}
+
+#if defined(USE_SYMBOLIZE)
+void OutputFrameId(intptr_t frame_id, BacktraceOutputHandler* handler) {
+  // Max unsigned 64-bit number in decimal has 20 digits (18446744073709551615).
+  // Hence, 30 digits should be more than enough to represent it in decimal
+  // (including the null-terminator).
+  char buf[30] = { '\0' };
+  handler->HandleOutput("#");
+  internal::itoa_r(frame_id, buf, sizeof(buf), 10, 1);
+  handler->HandleOutput(buf);
+}
+#endif  // defined(USE_SYMBOLIZE)
+
+void ProcessBacktrace(void *const *trace,
+                      size_t size,
+                      BacktraceOutputHandler* handler) {
+  // NOTE: This code MUST be async-signal safe (it's used by in-process
+  // stack dumping signal handler). NO malloc or stdio is allowed here.
+
+#if defined(USE_SYMBOLIZE)
+  for (size_t i = 0; i < size; ++i) {
+    OutputFrameId(i, handler);
+    handler->HandleOutput(" ");
+    OutputPointer(trace[i], handler);
+    handler->HandleOutput(" ");
+
+    char buf[1024] = { '\0' };
+
+    // Subtract by one as return address of function may be in the next
+    // function when a function is annotated as noreturn.
+    void* address = static_cast<char*>(trace[i]) - 1;
+    if (google::Symbolize(address, buf, sizeof(buf)))
+      handler->HandleOutput(buf);
+    else
+      handler->HandleOutput("<unknown>");
+
+    handler->HandleOutput("\n");
+  }
+#else
+  bool printed = false;
+
+  // Below part is async-signal unsafe (uses malloc), so execute it only
+  // when we are not executing the signal handler.
+  if (in_signal_handler == 0) {
+    std::unique_ptr<char*, FreeDeleter> trace_symbols(
+        backtrace_symbols(trace, size));
+    if (trace_symbols.get()) {
+      for (size_t i = 0; i < size; ++i) {
+        std::string trace_symbol = trace_symbols.get()[i];
+        DemangleSymbols(&trace_symbol);
+        handler->HandleOutput(trace_symbol.c_str());
+        handler->HandleOutput("\n");
+      }
+
+      printed = true;
+    }
+  }
+
+  if (!printed) {
+    for (size_t i = 0; i < size; ++i) {
+      handler->HandleOutput(" [");
+      OutputPointer(trace[i], handler);
+      handler->HandleOutput("]\n");
+    }
+  }
+#endif  // defined(USE_SYMBOLIZE)
+}
+#endif  // !defined(__UCLIBC__) && !defined(_AIX)
+
+void PrintToStderr(const char* output) {
+  // NOTE: This code MUST be async-signal safe (it's used by in-process
+  // stack dumping signal handler). NO malloc or stdio is allowed here.
+  ignore_result(HANDLE_EINTR(write(STDERR_FILENO, output, strlen(output))));
+}
+
+void StackDumpSignalHandler(int signal, siginfo_t* info, void* void_context) {
+  // NOTE: This code MUST be async-signal safe.
+  // NO malloc or stdio is allowed here.
+
+  // Give a registered callback a chance to recover from this signal
+  //
+  // V8 uses guard regions to guarantee memory safety in WebAssembly. This means
+  // some signals might be expected if they originate from Wasm code while
+  // accessing the guard region. We give V8 the chance to handle and recover
+  // from these signals first.
+  if (try_handle_signal != nullptr &&
+      try_handle_signal(signal, info, void_context)) {
+    // The first chance handler took care of this. The SA_RESETHAND flag
+    // replaced this signal handler upon entry, but we want to stay
+    // installed. Thus, we reinstall ourselves before returning.
+    struct sigaction action;
+    memset(&action, 0, sizeof(action));
+    action.sa_flags = SA_RESETHAND | SA_SIGINFO;
+    action.sa_sigaction = &StackDumpSignalHandler;
+    sigemptyset(&action.sa_mask);
+
+    sigaction(signal, &action, nullptr);
+    return;
+  }
+
+// Do not take the "in signal handler" code path on Mac in a DCHECK-enabled
+// build, as this prevents seeing a useful (symbolized) stack trace on a crash
+// or DCHECK() failure. While it may not be fully safe to run the stack symbol
+// printing code, in practice it's better to provide meaningful stack traces -
+// and the risk is low given we're likely crashing already.
+#if !defined(OS_MACOSX) || !DCHECK_IS_ON()
+  // Record the fact that we are in the signal handler now, so that the rest
+  // of StackTrace can behave in an async-signal-safe manner.
+  in_signal_handler = 1;
+#endif
+
+  if (BeingDebugged())
+    BreakDebugger();
+
+  PrintToStderr("Received signal ");
+  char buf[1024] = { 0 };
+  internal::itoa_r(signal, buf, sizeof(buf), 10, 0);
+  PrintToStderr(buf);
+  if (signal == SIGBUS) {
+    if (info->si_code == BUS_ADRALN)
+      PrintToStderr(" BUS_ADRALN ");
+    else if (info->si_code == BUS_ADRERR)
+      PrintToStderr(" BUS_ADRERR ");
+    else if (info->si_code == BUS_OBJERR)
+      PrintToStderr(" BUS_OBJERR ");
+    else
+      PrintToStderr(" <unknown> ");
+  } else if (signal == SIGFPE) {
+    if (info->si_code == FPE_FLTDIV)
+      PrintToStderr(" FPE_FLTDIV ");
+    else if (info->si_code == FPE_FLTINV)
+      PrintToStderr(" FPE_FLTINV ");
+    else if (info->si_code == FPE_FLTOVF)
+      PrintToStderr(" FPE_FLTOVF ");
+    else if (info->si_code == FPE_FLTRES)
+      PrintToStderr(" FPE_FLTRES ");
+    else if (info->si_code == FPE_FLTSUB)
+      PrintToStderr(" FPE_FLTSUB ");
+    else if (info->si_code == FPE_FLTUND)
+      PrintToStderr(" FPE_FLTUND ");
+    else if (info->si_code == FPE_INTDIV)
+      PrintToStderr(" FPE_INTDIV ");
+    else if (info->si_code == FPE_INTOVF)
+      PrintToStderr(" FPE_INTOVF ");
+    else
+      PrintToStderr(" <unknown> ");
+  } else if (signal == SIGILL) {
+    if (info->si_code == ILL_BADSTK)
+      PrintToStderr(" ILL_BADSTK ");
+    else if (info->si_code == ILL_COPROC)
+      PrintToStderr(" ILL_COPROC ");
+    else if (info->si_code == ILL_ILLOPN)
+      PrintToStderr(" ILL_ILLOPN ");
+    else if (info->si_code == ILL_ILLADR)
+      PrintToStderr(" ILL_ILLADR ");
+    else if (info->si_code == ILL_ILLTRP)
+      PrintToStderr(" ILL_ILLTRP ");
+    else if (info->si_code == ILL_PRVOPC)
+      PrintToStderr(" ILL_PRVOPC ");
+    else if (info->si_code == ILL_PRVREG)
+      PrintToStderr(" ILL_PRVREG ");
+    else
+      PrintToStderr(" <unknown> ");
+  } else if (signal == SIGSEGV) {
+    if (info->si_code == SEGV_MAPERR)
+      PrintToStderr(" SEGV_MAPERR ");
+    else if (info->si_code == SEGV_ACCERR)
+      PrintToStderr(" SEGV_ACCERR ");
+    else
+      PrintToStderr(" <unknown> ");
+  }
+  if (signal == SIGBUS || signal == SIGFPE ||
+      signal == SIGILL || signal == SIGSEGV) {
+    internal::itoa_r(reinterpret_cast<intptr_t>(info->si_addr),
+                     buf, sizeof(buf), 16, 12);
+    PrintToStderr(buf);
+  }
+  PrintToStderr("\n");
+
+#if BUILDFLAG(CFI_ENFORCEMENT_TRAP)
+  if (signal == SIGILL && info->si_code == ILL_ILLOPN) {
+    PrintToStderr(
+        "CFI: Most likely a control flow integrity violation; for more "
+        "information see:\n");
+    PrintToStderr(
+        "https://www.chromium.org/developers/testing/control-flow-integrity\n");
+  }
+#endif  // BUILDFLAG(CFI_ENFORCEMENT_TRAP)
+
+  debug::StackTrace().Print();
+
+#if defined(OS_LINUX)
+#if ARCH_CPU_X86_FAMILY
+  ucontext_t* context = reinterpret_cast<ucontext_t*>(void_context);
+  const struct {
+    const char* label;
+    greg_t value;
+  } registers[] = {
+#if ARCH_CPU_32_BITS
+    { "  gs: ", context->uc_mcontext.gregs[REG_GS] },
+    { "  fs: ", context->uc_mcontext.gregs[REG_FS] },
+    { "  es: ", context->uc_mcontext.gregs[REG_ES] },
+    { "  ds: ", context->uc_mcontext.gregs[REG_DS] },
+    { " edi: ", context->uc_mcontext.gregs[REG_EDI] },
+    { " esi: ", context->uc_mcontext.gregs[REG_ESI] },
+    { " ebp: ", context->uc_mcontext.gregs[REG_EBP] },
+    { " esp: ", context->uc_mcontext.gregs[REG_ESP] },
+    { " ebx: ", context->uc_mcontext.gregs[REG_EBX] },
+    { " edx: ", context->uc_mcontext.gregs[REG_EDX] },
+    { " ecx: ", context->uc_mcontext.gregs[REG_ECX] },
+    { " eax: ", context->uc_mcontext.gregs[REG_EAX] },
+    { " trp: ", context->uc_mcontext.gregs[REG_TRAPNO] },
+    { " err: ", context->uc_mcontext.gregs[REG_ERR] },
+    { "  ip: ", context->uc_mcontext.gregs[REG_EIP] },
+    { "  cs: ", context->uc_mcontext.gregs[REG_CS] },
+    { " efl: ", context->uc_mcontext.gregs[REG_EFL] },
+    { " usp: ", context->uc_mcontext.gregs[REG_UESP] },
+    { "  ss: ", context->uc_mcontext.gregs[REG_SS] },
+#elif ARCH_CPU_64_BITS
+    { "  r8: ", context->uc_mcontext.gregs[REG_R8] },
+    { "  r9: ", context->uc_mcontext.gregs[REG_R9] },
+    { " r10: ", context->uc_mcontext.gregs[REG_R10] },
+    { " r11: ", context->uc_mcontext.gregs[REG_R11] },
+    { " r12: ", context->uc_mcontext.gregs[REG_R12] },
+    { " r13: ", context->uc_mcontext.gregs[REG_R13] },
+    { " r14: ", context->uc_mcontext.gregs[REG_R14] },
+    { " r15: ", context->uc_mcontext.gregs[REG_R15] },
+    { "  di: ", context->uc_mcontext.gregs[REG_RDI] },
+    { "  si: ", context->uc_mcontext.gregs[REG_RSI] },
+    { "  bp: ", context->uc_mcontext.gregs[REG_RBP] },
+    { "  bx: ", context->uc_mcontext.gregs[REG_RBX] },
+    { "  dx: ", context->uc_mcontext.gregs[REG_RDX] },
+    { "  ax: ", context->uc_mcontext.gregs[REG_RAX] },
+    { "  cx: ", context->uc_mcontext.gregs[REG_RCX] },
+    { "  sp: ", context->uc_mcontext.gregs[REG_RSP] },
+    { "  ip: ", context->uc_mcontext.gregs[REG_RIP] },
+    { " efl: ", context->uc_mcontext.gregs[REG_EFL] },
+    { " cgf: ", context->uc_mcontext.gregs[REG_CSGSFS] },
+    { " erf: ", context->uc_mcontext.gregs[REG_ERR] },
+    { " trp: ", context->uc_mcontext.gregs[REG_TRAPNO] },
+    { " msk: ", context->uc_mcontext.gregs[REG_OLDMASK] },
+    { " cr2: ", context->uc_mcontext.gregs[REG_CR2] },
+#endif  // ARCH_CPU_32_BITS
+  };
+
+#if ARCH_CPU_32_BITS
+  const int kRegisterPadding = 8;
+#elif ARCH_CPU_64_BITS
+  const int kRegisterPadding = 16;
+#endif
+
+  for (size_t i = 0; i < arraysize(registers); i++) {
+    PrintToStderr(registers[i].label);
+    internal::itoa_r(registers[i].value, buf, sizeof(buf),
+                     16, kRegisterPadding);
+    PrintToStderr(buf);
+
+    if ((i + 1) % 4 == 0)
+      PrintToStderr("\n");
+  }
+  PrintToStderr("\n");
+#endif  // ARCH_CPU_X86_FAMILY
+#endif  // defined(OS_LINUX)
+
+  PrintToStderr("[end of stack trace]\n");
+
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  if (::signal(signal, SIG_DFL) == SIG_ERR)
+    _exit(1);
+#else
+  // Non-Mac OSes should probably reraise the signal as well, but the Linux
+  // sandbox tests break on CrOS devices.
+  // https://code.google.com/p/chromium/issues/detail?id=551681
+  PrintToStderr("Calling _exit(1). Core file will not be generated.\n");
+  _exit(1);
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+}
+
+class PrintBacktraceOutputHandler : public BacktraceOutputHandler {
+ public:
+  PrintBacktraceOutputHandler() = default;
+
+  void HandleOutput(const char* output) override {
+    // NOTE: This code MUST be async-signal safe (it's used by in-process
+    // stack dumping signal handler). NO malloc or stdio is allowed here.
+    PrintToStderr(output);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PrintBacktraceOutputHandler);
+};
+
+class StreamBacktraceOutputHandler : public BacktraceOutputHandler {
+ public:
+  explicit StreamBacktraceOutputHandler(std::ostream* os) : os_(os) {
+  }
+
+  void HandleOutput(const char* output) override { (*os_) << output; }
+
+ private:
+  std::ostream* os_;
+
+  DISALLOW_COPY_AND_ASSIGN(StreamBacktraceOutputHandler);
+};
+
+void WarmUpBacktrace() {
+  // Warm up stack trace infrastructure. It turns out that on the first
+  // call glibc initializes some internal data structures using pthread_once,
+  // and even backtrace() can call malloc(), leading to hangs.
+  //
+  // Example stack trace snippet (with tcmalloc):
+  //
+  // #8  0x0000000000a173b5 in tc_malloc
+  //             at ./third_party/tcmalloc/chromium/src/debugallocation.cc:1161
+  // #9  0x00007ffff7de7900 in _dl_map_object_deps at dl-deps.c:517
+  // #10 0x00007ffff7ded8a9 in dl_open_worker at dl-open.c:262
+  // #11 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178
+  // #12 0x00007ffff7ded31a in _dl_open (file=0x7ffff625e298 "libgcc_s.so.1")
+  //             at dl-open.c:639
+  // #13 0x00007ffff6215602 in do_dlopen at dl-libc.c:89
+  // #14 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178
+  // #15 0x00007ffff62156c4 in dlerror_run at dl-libc.c:48
+  // #16 __GI___libc_dlopen_mode at dl-libc.c:165
+  // #17 0x00007ffff61ef8f5 in init
+  //             at ../sysdeps/x86_64/../ia64/backtrace.c:53
+  // #18 0x00007ffff6aad400 in pthread_once
+  //             at ../nptl/sysdeps/unix/sysv/linux/x86_64/pthread_once.S:104
+  // #19 0x00007ffff61efa14 in __GI___backtrace
+  //             at ../sysdeps/x86_64/../ia64/backtrace.c:104
+  // #20 0x0000000000752a54 in base::debug::StackTrace::StackTrace
+  //             at base/debug/stack_trace_posix.cc:175
+  // #21 0x00000000007a4ae5 in
+  //             base::(anonymous namespace)::StackDumpSignalHandler
+  //             at base/process_util_posix.cc:172
+  // #22 <signal handler called>
+  StackTrace stack_trace;
+}
+
+#if defined(USE_SYMBOLIZE)
+
+// class SandboxSymbolizeHelper.
+//
+// The purpose of this class is to prepare and install a "file open" callback
+// needed by the stack trace symbolization code
+// (base/third_party/symbolize/symbolize.h) so that it can function properly
+// in a sandboxed process.  The caveat is that this class must be instantiated
+// before the sandboxing is enabled so that it can get the chance to open all
+// the object files that are loaded in the virtual address space of the current
+// process.
+class SandboxSymbolizeHelper {
+ public:
+  // Returns the singleton instance.
+  static SandboxSymbolizeHelper* GetInstance() {
+    return Singleton<SandboxSymbolizeHelper,
+                     LeakySingletonTraits<SandboxSymbolizeHelper>>::get();
+  }
+
+ private:
+  friend struct DefaultSingletonTraits<SandboxSymbolizeHelper>;
+
+  SandboxSymbolizeHelper()
+      : is_initialized_(false) {
+    Init();
+  }
+
+  ~SandboxSymbolizeHelper() {
+    UnregisterCallback();
+    CloseObjectFiles();
+  }
+
+  // Returns a O_RDONLY file descriptor for |file_path| if it was opened
+  // successfully during the initialization.  The file is repositioned at
+  // offset 0.
+  // IMPORTANT: This function must be async-signal-safe because it can be
+  // called from a signal handler (symbolizing stack frames for a crash).
+  int GetFileDescriptor(const char* file_path) {
+    int fd = -1;
+
+#if !defined(OFFICIAL_BUILD)
+    if (file_path) {
+      // The assumption here is that iterating over std::map<std::string, int>
+      // using a const_iterator does not allocate dynamic memory, hense it is
+      // async-signal-safe.
+      std::map<std::string, int>::const_iterator it;
+      for (it = modules_.begin(); it != modules_.end(); ++it) {
+        if (strcmp((it->first).c_str(), file_path) == 0) {
+          // POSIX.1-2004 requires an implementation to guarantee that dup()
+          // is async-signal-safe.
+          fd = HANDLE_EINTR(dup(it->second));
+          break;
+        }
+      }
+      // POSIX.1-2004 requires an implementation to guarantee that lseek()
+      // is async-signal-safe.
+      if (fd >= 0 && lseek(fd, 0, SEEK_SET) < 0) {
+        // Failed to seek.
+        fd = -1;
+      }
+    }
+#endif  // !defined(OFFICIAL_BUILD)
+
+    return fd;
+  }
+
+  // Searches for the object file (from /proc/self/maps) that contains
+  // the specified pc.  If found, sets |start_address| to the start address
+  // of where this object file is mapped in memory, sets the module base
+  // address into |base_address|, copies the object file name into
+  // |out_file_name|, and attempts to open the object file.  If the object
+  // file is opened successfully, returns the file descriptor.  Otherwise,
+  // returns -1.  |out_file_name_size| is the size of the file name buffer
+  // (including the null terminator).
+  // IMPORTANT: This function must be async-signal-safe because it can be
+  // called from a signal handler (symbolizing stack frames for a crash).
+  static int OpenObjectFileContainingPc(uint64_t pc, uint64_t& start_address,
+                                        uint64_t& base_address, char* file_path,
+                                        int file_path_size) {
+    // This method can only be called after the singleton is instantiated.
+    // This is ensured by the following facts:
+    // * This is the only static method in this class, it is private, and
+    //   the class has no friends (except for the DefaultSingletonTraits).
+    //   The compiler guarantees that it can only be called after the
+    //   singleton is instantiated.
+    // * This method is used as a callback for the stack tracing code and
+    //   the callback registration is done in the constructor, so logically
+    //   it cannot be called before the singleton is created.
+    SandboxSymbolizeHelper* instance = GetInstance();
+
+    // The assumption here is that iterating over
+    // std::vector<MappedMemoryRegion> using a const_iterator does not allocate
+    // dynamic memory, hence it is async-signal-safe.
+    for (const MappedMemoryRegion& region : instance->regions_) {
+      if (region.start <= pc && pc < region.end) {
+        start_address = region.start;
+        base_address = region.base;
+        if (file_path && file_path_size > 0) {
+          strncpy(file_path, region.path.c_str(), file_path_size);
+          // Ensure null termination.
+          file_path[file_path_size - 1] = '\0';
+        }
+        return instance->GetFileDescriptor(region.path.c_str());
+      }
+    }
+    return -1;
+  }
+
+  // Set the base address for each memory region by reading ELF headers in
+  // process memory.
+  void SetBaseAddressesForMemoryRegions() {
+    base::ScopedFD mem_fd(
+        HANDLE_EINTR(open("/proc/self/mem", O_RDONLY | O_CLOEXEC)));
+    if (!mem_fd.is_valid())
+      return;
+
+    auto safe_memcpy = [&mem_fd](void* dst, uintptr_t src, size_t size) {
+      return HANDLE_EINTR(pread(mem_fd.get(), dst, size, src)) == ssize_t(size);
+    };
+
+    uintptr_t cur_base = 0;
+    for (auto& r : regions_) {
+      ElfW(Ehdr) ehdr;
+      static_assert(SELFMAG <= sizeof(ElfW(Ehdr)), "SELFMAG too large");
+      if ((r.permissions & MappedMemoryRegion::READ) &&
+          safe_memcpy(&ehdr, r.start, sizeof(ElfW(Ehdr))) &&
+          memcmp(ehdr.e_ident, ELFMAG, SELFMAG) == 0) {
+        switch (ehdr.e_type) {
+          case ET_EXEC:
+            cur_base = 0;
+            break;
+          case ET_DYN:
+            // Find the segment containing file offset 0. This will correspond
+            // to the ELF header that we just read. Normally this will have
+            // virtual address 0, but this is not guaranteed. We must subtract
+            // the virtual address from the address where the ELF header was
+            // mapped to get the base address.
+            //
+            // If we fail to find a segment for file offset 0, use the address
+            // of the ELF header as the base address.
+            cur_base = r.start;
+            for (unsigned i = 0; i != ehdr.e_phnum; ++i) {
+              ElfW(Phdr) phdr;
+              if (safe_memcpy(&phdr, r.start + ehdr.e_phoff + i * sizeof(phdr),
+                              sizeof(phdr)) &&
+                  phdr.p_type == PT_LOAD && phdr.p_offset == 0) {
+                cur_base = r.start - phdr.p_vaddr;
+                break;
+              }
+            }
+            break;
+          default:
+            // ET_REL or ET_CORE. These aren't directly executable, so they
+            // don't affect the base address.
+            break;
+        }
+      }
+
+      r.base = cur_base;
+    }
+  }
+
+  // Parses /proc/self/maps in order to compile a list of all object file names
+  // for the modules that are loaded in the current process.
+  // Returns true on success.
+  bool CacheMemoryRegions() {
+    // Reads /proc/self/maps.
+    std::string contents;
+    if (!ReadProcMaps(&contents)) {
+      LOG(ERROR) << "Failed to read /proc/self/maps";
+      return false;
+    }
+
+    // Parses /proc/self/maps.
+    if (!ParseProcMaps(contents, &regions_)) {
+      LOG(ERROR) << "Failed to parse the contents of /proc/self/maps";
+      return false;
+    }
+
+    SetBaseAddressesForMemoryRegions();
+
+    is_initialized_ = true;
+    return true;
+  }
+
+  // Opens all object files and caches their file descriptors.
+  void OpenSymbolFiles() {
+    // Pre-opening and caching the file descriptors of all loaded modules is
+    // not safe for production builds.  Hence it is only done in non-official
+    // builds.  For more details, take a look at: http://crbug.com/341966.
+#if !defined(OFFICIAL_BUILD)
+    // Open the object files for all read-only executable regions and cache
+    // their file descriptors.
+    std::vector<MappedMemoryRegion>::const_iterator it;
+    for (it = regions_.begin(); it != regions_.end(); ++it) {
+      const MappedMemoryRegion& region = *it;
+      // Only interesed in read-only executable regions.
+      if ((region.permissions & MappedMemoryRegion::READ) ==
+              MappedMemoryRegion::READ &&
+          (region.permissions & MappedMemoryRegion::WRITE) == 0 &&
+          (region.permissions & MappedMemoryRegion::EXECUTE) ==
+              MappedMemoryRegion::EXECUTE) {
+        if (region.path.empty()) {
+          // Skip regions with empty file names.
+          continue;
+        }
+        if (region.path[0] == '[') {
+          // Skip pseudo-paths, like [stack], [vdso], [heap], etc ...
+          continue;
+        }
+        // Avoid duplicates.
+        if (modules_.find(region.path) == modules_.end()) {
+          int fd = open(region.path.c_str(), O_RDONLY | O_CLOEXEC);
+          if (fd >= 0) {
+            modules_.insert(std::make_pair(region.path, fd));
+          } else {
+            LOG(WARNING) << "Failed to open file: " << region.path
+                         << "\n  Error: " << strerror(errno);
+          }
+        }
+      }
+    }
+#endif  // !defined(OFFICIAL_BUILD)
+  }
+
+  // Initializes and installs the symbolization callback.
+  void Init() {
+    if (CacheMemoryRegions()) {
+      OpenSymbolFiles();
+      google::InstallSymbolizeOpenObjectFileCallback(
+          &OpenObjectFileContainingPc);
+    }
+  }
+
+  // Unregister symbolization callback.
+  void UnregisterCallback() {
+    if (is_initialized_) {
+      google::InstallSymbolizeOpenObjectFileCallback(nullptr);
+      is_initialized_ = false;
+    }
+  }
+
+  // Closes all file descriptors owned by this instance.
+  void CloseObjectFiles() {
+#if !defined(OFFICIAL_BUILD)
+    std::map<std::string, int>::iterator it;
+    for (it = modules_.begin(); it != modules_.end(); ++it) {
+      int ret = IGNORE_EINTR(close(it->second));
+      DCHECK(!ret);
+      it->second = -1;
+    }
+    modules_.clear();
+#endif  // !defined(OFFICIAL_BUILD)
+  }
+
+  // Set to true upon successful initialization.
+  bool is_initialized_;
+
+#if !defined(OFFICIAL_BUILD)
+  // Mapping from file name to file descriptor.  Includes file descriptors
+  // for all successfully opened object files and the file descriptor for
+  // /proc/self/maps.  This code is not safe for production builds.
+  std::map<std::string, int> modules_;
+#endif  // !defined(OFFICIAL_BUILD)
+
+  // Cache for the process memory regions.  Produced by parsing the contents
+  // of /proc/self/maps cache.
+  std::vector<MappedMemoryRegion> regions_;
+
+  DISALLOW_COPY_AND_ASSIGN(SandboxSymbolizeHelper);
+};
+#endif  // USE_SYMBOLIZE
+
+}  // namespace
+
+bool EnableInProcessStackDumping() {
+#if defined(USE_SYMBOLIZE)
+  SandboxSymbolizeHelper::GetInstance();
+#endif  // USE_SYMBOLIZE
+
+  // When running in an application, our code typically expects SIGPIPE
+  // to be ignored.  Therefore, when testing that same code, it should run
+  // with SIGPIPE ignored as well.
+  struct sigaction sigpipe_action;
+  memset(&sigpipe_action, 0, sizeof(sigpipe_action));
+  sigpipe_action.sa_handler = SIG_IGN;
+  sigemptyset(&sigpipe_action.sa_mask);
+  bool success = (sigaction(SIGPIPE, &sigpipe_action, nullptr) == 0);
+
+  // Avoid hangs during backtrace initialization, see above.
+  WarmUpBacktrace();
+
+  struct sigaction action;
+  memset(&action, 0, sizeof(action));
+  action.sa_flags = SA_RESETHAND | SA_SIGINFO;
+  action.sa_sigaction = &StackDumpSignalHandler;
+  sigemptyset(&action.sa_mask);
+
+  success &= (sigaction(SIGILL, &action, nullptr) == 0);
+  success &= (sigaction(SIGABRT, &action, nullptr) == 0);
+  success &= (sigaction(SIGFPE, &action, nullptr) == 0);
+  success &= (sigaction(SIGBUS, &action, nullptr) == 0);
+  success &= (sigaction(SIGSEGV, &action, nullptr) == 0);
+// On Linux, SIGSYS is reserved by the kernel for seccomp-bpf sandboxing.
+#if !defined(OS_LINUX)
+  success &= (sigaction(SIGSYS, &action, nullptr) == 0);
+#endif  // !defined(OS_LINUX)
+
+  return success;
+}
+
+void SetStackDumpFirstChanceCallback(bool (*handler)(int, void*, void*)) {
+  DCHECK(try_handle_signal == nullptr || handler == nullptr);
+  try_handle_signal = handler;
+}
+
+StackTrace::StackTrace(size_t count) {
+// NOTE: This code MUST be async-signal safe (it's used by in-process
+// stack dumping signal handler). NO malloc or stdio is allowed here.
+
+#if !defined(__UCLIBC__) && !defined(_AIX)
+  count = std::min(arraysize(trace_), count);
+
+  // Though the backtrace API man page does not list any possible negative
+  // return values, we take no chance.
+  count_ = base::saturated_cast<size_t>(backtrace(trace_, count));
+#else
+  count_ = 0;
+#endif
+}
+
+void StackTrace::Print() const {
+  // NOTE: This code MUST be async-signal safe (it's used by in-process
+  // stack dumping signal handler). NO malloc or stdio is allowed here.
+
+#if !defined(__UCLIBC__) && !defined(_AIX)
+  PrintBacktraceOutputHandler handler;
+  ProcessBacktrace(trace_, count_, &handler);
+#endif
+}
+
+#if !defined(__UCLIBC__) && !defined(_AIX)
+void StackTrace::OutputToStream(std::ostream* os) const {
+  StreamBacktraceOutputHandler handler(os);
+  ProcessBacktrace(trace_, count_, &handler);
+}
+#endif
+
+namespace internal {
+
+// NOTE: code from sandbox/linux/seccomp-bpf/demo.cc.
+char* itoa_r(intptr_t i, char* buf, size_t sz, int base, size_t padding) {
+  // Make sure we can write at least one NUL byte.
+  size_t n = 1;
+  if (n > sz)
+    return nullptr;
+
+  if (base < 2 || base > 16) {
+    buf[0] = '\000';
+    return nullptr;
+  }
+
+  char* start = buf;
+
+  uintptr_t j = i;
+
+  // Handle negative numbers (only for base 10).
+  if (i < 0 && base == 10) {
+    // This does "j = -i" while avoiding integer overflow.
+    j = static_cast<uintptr_t>(-(i + 1)) + 1;
+
+    // Make sure we can write the '-' character.
+    if (++n > sz) {
+      buf[0] = '\000';
+      return nullptr;
+    }
+    *start++ = '-';
+  }
+
+  // Loop until we have converted the entire number. Output at least one
+  // character (i.e. '0').
+  char* ptr = start;
+  do {
+    // Make sure there is still enough space left in our output buffer.
+    if (++n > sz) {
+      buf[0] = '\000';
+      return nullptr;
+    }
+
+    // Output the next digit.
+    *ptr++ = "0123456789abcdef"[j % base];
+    j /= base;
+
+    if (padding > 0)
+      padding--;
+  } while (j > 0 || padding > 0);
+
+  // Terminate the output with a NUL character.
+  *ptr = '\000';
+
+  // Conversion to ASCII actually resulted in the digits being in reverse
+  // order. We can't easily generate them in forward order, as we can't tell
+  // the number of characters needed until we are done converting.
+  // So, now, we reverse the string (except for the possible "-" sign).
+  while (--ptr > start) {
+    char ch = *ptr;
+    *ptr = *start;
+    *start++ = ch;
+  }
+  return buf;
+}
+
+}  // namespace internal
+
+}  // namespace debug
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/environment.h b/native/zucchini/vendor/libchrome/base/environment.h
new file mode 100644
index 0000000..e842ab0
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/environment.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_ENVIRONMENT_H_
+#define BASE_ENVIRONMENT_H_
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include "base/base_export.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_piece.h"
+#include "build/build_config.h"
+
+namespace base {
+
+namespace env_vars {
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+BASE_EXPORT extern const char kHome[];
+#endif
+
+}  // namespace env_vars
+
+class BASE_EXPORT Environment {
+ public:
+  virtual ~Environment();
+
+  // Returns the appropriate platform-specific instance.
+  static std::unique_ptr<Environment> Create();
+
+  // Gets an environment variable's value and stores it in |result|.
+  // Returns false if the key is unset.
+  virtual bool GetVar(StringPiece variable_name, std::string* result) = 0;
+
+  // Syntactic sugar for GetVar(variable_name, nullptr);
+  virtual bool HasVar(StringPiece variable_name);
+
+  // Returns true on success, otherwise returns false.
+  virtual bool SetVar(StringPiece variable_name,
+                      const std::string& new_value) = 0;
+
+  // Returns true on success, otherwise returns false.
+  virtual bool UnSetVar(StringPiece variable_name) = 0;
+};
+
+
+#if defined(OS_WIN)
+
+typedef string16 NativeEnvironmentString;
+typedef std::map<NativeEnvironmentString, NativeEnvironmentString>
+    EnvironmentMap;
+
+// Returns a modified environment vector constructed from the given environment
+// and the list of changes given in |changes|. Each key in the environment is
+// matched against the first element of the pairs. In the event of a match, the
+// value is replaced by the second of the pair, unless the second is empty, in
+// which case the key-value is removed.
+//
+// This Windows version takes and returns a Windows-style environment block
+// which is a concatenated list of null-terminated 16-bit strings. The end is
+// marked by a double-null terminator. The size of the returned string will
+// include the terminators.
+BASE_EXPORT string16 AlterEnvironment(const wchar_t* env,
+                                      const EnvironmentMap& changes);
+
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+
+typedef std::string NativeEnvironmentString;
+typedef std::map<NativeEnvironmentString, NativeEnvironmentString>
+    EnvironmentMap;
+
+// See general comments for the Windows version above.
+//
+// This Posix version takes and returns a Posix-style environment block, which
+// is a null-terminated list of pointers to null-terminated strings. The
+// returned array will have appended to it the storage for the array itself so
+// there is only one pointer to manage, but this means that you can't copy the
+// array without keeping the original around.
+BASE_EXPORT std::unique_ptr<char* []> AlterEnvironment(
+    const char* const* env,
+    const EnvironmentMap& changes);
+
+#endif
+
+}  // namespace base
+
+#endif  // BASE_ENVIRONMENT_H_
diff --git a/native/zucchini/vendor/libchrome/base/feature_list.h b/native/zucchini/vendor/libchrome/base/feature_list.h
new file mode 100644
index 0000000..2237507
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/feature_list.h
@@ -0,0 +1,310 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_FEATURE_LIST_H_
+#define BASE_FEATURE_LIST_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/gtest_prod_util.h"
+#include "base/macros.h"
+#include "base/metrics/persistent_memory_allocator.h"
+#include "base/strings/string_piece.h"
+#include "base/synchronization/lock.h"
+
+namespace base {
+
+class FieldTrial;
+
+// Specifies whether a given feature is enabled or disabled by default.
+enum FeatureState {
+  FEATURE_DISABLED_BY_DEFAULT,
+  FEATURE_ENABLED_BY_DEFAULT,
+};
+
+// The Feature struct is used to define the default state for a feature. See
+// comment below for more details. There must only ever be one struct instance
+// for a given feature name - generally defined as a constant global variable or
+// file static. It should never be used as a constexpr as it breaks
+// pointer-based identity lookup.
+struct BASE_EXPORT Feature {
+  // The name of the feature. This should be unique to each feature and is used
+  // for enabling/disabling features via command line flags and experiments.
+  // It is strongly recommended to use CamelCase style for feature names, e.g.
+  // "MyGreatFeature".
+  const char* const name;
+
+  // The default state (i.e. enabled or disabled) for this feature.
+  const FeatureState default_state;
+};
+
+#if DCHECK_IS_CONFIGURABLE
+// DCHECKs have been built-in, and are configurable at run-time to be fatal, or
+// not, via a DcheckIsFatal feature. We define the Feature here since it is
+// checked in FeatureList::SetInstance(). See https://crbug.com/596231.
+extern BASE_EXPORT const Feature kDCheckIsFatalFeature;
+#endif  // DCHECK_IS_CONFIGURABLE
+
+// The FeatureList class is used to determine whether a given feature is on or
+// off. It provides an authoritative answer, taking into account command-line
+// overrides and experimental control.
+//
+// The basic use case is for any feature that can be toggled (e.g. through
+// command-line or an experiment) to have a defined Feature struct, e.g.:
+//
+//   const base::Feature kMyGreatFeature {
+//     "MyGreatFeature", base::FEATURE_ENABLED_BY_DEFAULT
+//   };
+//
+// Then, client code that wishes to query the state of the feature would check:
+//
+//   if (base::FeatureList::IsEnabled(kMyGreatFeature)) {
+//     // Feature code goes here.
+//   }
+//
+// Behind the scenes, the above call would take into account any command-line
+// flags to enable or disable the feature, any experiments that may control it
+// and finally its default state (in that order of priority), to determine
+// whether the feature is on.
+//
+// Features can be explicitly forced on or off by specifying a list of comma-
+// separated feature names via the following command-line flags:
+//
+//   --enable-features=Feature5,Feature7
+//   --disable-features=Feature1,Feature2,Feature3
+//
+// To enable/disable features in a test, do NOT append --enable-features or
+// --disable-features to the command-line directly. Instead, use
+// ScopedFeatureList. See base/test/scoped_feature_list.h for details.
+//
+// After initialization (which should be done single-threaded), the FeatureList
+// API is thread safe.
+//
+// Note: This class is a singleton, but does not use base/memory/singleton.h in
+// order to have control over its initialization sequence. Specifically, the
+// intended use is to create an instance of this class and fully initialize it,
+// before setting it as the singleton for a process, via SetInstance().
+class BASE_EXPORT FeatureList {
+ public:
+  FeatureList();
+  ~FeatureList();
+
+  // Initializes feature overrides via command-line flags |enable_features| and
+  // |disable_features|, each of which is a comma-separated list of features to
+  // enable or disable, respectively. If a feature appears on both lists, then
+  // it will be disabled. If a list entry has the format "FeatureName<TrialName"
+  // then this initialization will also associate the feature state override
+  // with the named field trial, if it exists. If a feature name is prefixed
+  // with the '*' character, it will be created with OVERRIDE_USE_DEFAULT -
+  // which is useful for associating with a trial while using the default state.
+  // Must only be invoked during the initialization phase (before
+  // FinalizeInitialization() has been called).
+  void InitializeFromCommandLine(const std::string& enable_features,
+                                 const std::string& disable_features);
+
+  // Initializes feature overrides through the field trial allocator, which
+  // we're using to store the feature names, their override state, and the name
+  // of the associated field trial.
+  void InitializeFromSharedMemory(PersistentMemoryAllocator* allocator);
+
+  // Specifies whether a feature override enables or disables the feature.
+  enum OverrideState {
+    OVERRIDE_USE_DEFAULT,
+    OVERRIDE_DISABLE_FEATURE,
+    OVERRIDE_ENABLE_FEATURE,
+  };
+
+  // Returns true if the state of |feature_name| has been overridden via
+  // |InitializeFromCommandLine()|.
+  bool IsFeatureOverriddenFromCommandLine(const std::string& feature_name,
+                                          OverrideState state) const;
+
+  // Associates a field trial for reporting purposes corresponding to the
+  // command-line setting the feature state to |for_overridden_state|. The trial
+  // will be activated when the state of the feature is first queried. This
+  // should be called during registration, after InitializeFromCommandLine() has
+  // been called but before the instance is registered via SetInstance().
+  void AssociateReportingFieldTrial(const std::string& feature_name,
+                                    OverrideState for_overridden_state,
+                                    FieldTrial* field_trial);
+
+  // Registers a field trial to override the enabled state of the specified
+  // feature to |override_state|. Command-line overrides still take precedence
+  // over field trials, so this will have no effect if the feature is being
+  // overridden from the command-line. The associated field trial will be
+  // activated when the feature state for this feature is queried. This should
+  // be called during registration, after InitializeFromCommandLine() has been
+  // called but before the instance is registered via SetInstance().
+  void RegisterFieldTrialOverride(const std::string& feature_name,
+                                  OverrideState override_state,
+                                  FieldTrial* field_trial);
+
+  // Loops through feature overrides and serializes them all into |allocator|.
+  void AddFeaturesToAllocator(PersistentMemoryAllocator* allocator);
+
+  // Returns comma-separated lists of feature names (in the same format that is
+  // accepted by InitializeFromCommandLine()) corresponding to features that
+  // have been overridden - either through command-line or via FieldTrials. For
+  // those features that have an associated FieldTrial, the output entry will be
+  // of the format "FeatureName<TrialName", where "TrialName" is the name of the
+  // FieldTrial. Features that have overrides with OVERRIDE_USE_DEFAULT will be
+  // added to |enable_overrides| with a '*' character prefix. Must be called
+  // only after the instance has been initialized and registered.
+  void GetFeatureOverrides(std::string* enable_overrides,
+                           std::string* disable_overrides);
+
+  // Like GetFeatureOverrides(), but only returns overrides that were specified
+  // explicitly on the command-line, omitting the ones from field trials.
+  void GetCommandLineFeatureOverrides(std::string* enable_overrides,
+                                      std::string* disable_overrides);
+
+  // Returns whether the given |feature| is enabled. Must only be called after
+  // the singleton instance has been registered via SetInstance(). Additionally,
+  // a feature with a given name must only have a single corresponding Feature
+  // struct, which is checked in builds with DCHECKs enabled.
+  static bool IsEnabled(const Feature& feature);
+
+  // Returns the field trial associated with the given |feature|. Must only be
+  // called after the singleton instance has been registered via SetInstance().
+  static FieldTrial* GetFieldTrial(const Feature& feature);
+
+  // Splits a comma-separated string containing feature names into a vector. The
+  // resulting pieces point to parts of |input|.
+  static std::vector<base::StringPiece> SplitFeatureListString(
+      base::StringPiece input);
+
+  // Initializes and sets an instance of FeatureList with feature overrides via
+  // command-line flags |enable_features| and |disable_features| if one has not
+  // already been set from command-line flags. Returns true if an instance did
+  // not previously exist. See InitializeFromCommandLine() for more details
+  // about |enable_features| and |disable_features| parameters.
+  static bool InitializeInstance(const std::string& enable_features,
+                                 const std::string& disable_features);
+
+  // Returns the singleton instance of FeatureList. Will return null until an
+  // instance is registered via SetInstance().
+  static FeatureList* GetInstance();
+
+  // Registers the given |instance| to be the singleton feature list for this
+  // process. This should only be called once and |instance| must not be null.
+  // Note: If you are considering using this for the purposes of testing, take
+  // a look at using base/test/scoped_feature_list.h instead.
+  static void SetInstance(std::unique_ptr<FeatureList> instance);
+
+  // Clears the previously-registered singleton instance for tests and returns
+  // the old instance.
+  // Note: Most tests should never call this directly. Instead consider using
+  // base::test::ScopedFeatureList.
+  static std::unique_ptr<FeatureList> ClearInstanceForTesting();
+
+  // Sets a given (initialized) |instance| to be the singleton feature list,
+  // for testing. Existing instance must be null. This is primarily intended
+  // to support base::test::ScopedFeatureList helper class.
+  static void RestoreInstanceForTesting(std::unique_ptr<FeatureList> instance);
+
+ private:
+  FRIEND_TEST_ALL_PREFIXES(FeatureListTest, CheckFeatureIdentity);
+  FRIEND_TEST_ALL_PREFIXES(FeatureListTest,
+                           StoreAndRetrieveFeaturesFromSharedMemory);
+  FRIEND_TEST_ALL_PREFIXES(FeatureListTest,
+                           StoreAndRetrieveAssociatedFeaturesFromSharedMemory);
+
+  struct OverrideEntry {
+    // The overridden enable (on/off) state of the feature.
+    const OverrideState overridden_state;
+
+    // An optional associated field trial, which will be activated when the
+    // state of the feature is queried for the first time. Weak pointer to the
+    // FieldTrial object that is owned by the FieldTrialList singleton.
+    base::FieldTrial* field_trial;
+
+    // Specifies whether the feature's state is overridden by |field_trial|.
+    // If it's not, and |field_trial| is not null, it means it is simply an
+    // associated field trial for reporting purposes (and |overridden_state|
+    // came from the command-line).
+    const bool overridden_by_field_trial;
+
+    // TODO(asvitkine): Expand this as more support is added.
+
+    // Constructs an OverrideEntry for the given |overridden_state|. If
+    // |field_trial| is not null, it implies that |overridden_state| comes from
+    // the trial, so |overridden_by_field_trial| will be set to true.
+    OverrideEntry(OverrideState overridden_state, FieldTrial* field_trial);
+  };
+
+  // Finalizes the initialization state of the FeatureList, so that no further
+  // overrides can be registered. This is called by SetInstance() on the
+  // singleton feature list that is being registered.
+  void FinalizeInitialization();
+
+  // Returns whether the given |feature| is enabled. This is invoked by the
+  // public FeatureList::IsEnabled() static function on the global singleton.
+  // Requires the FeatureList to have already been fully initialized.
+  bool IsFeatureEnabled(const Feature& feature);
+
+  // Returns the field trial associated with the given |feature|. This is
+  // invoked by the public FeatureList::GetFieldTrial() static function on the
+  // global singleton. Requires the FeatureList to have already been fully
+  // initialized.
+  base::FieldTrial* GetAssociatedFieldTrial(const Feature& feature);
+
+  // For each feature name in comma-separated list of strings |feature_list|,
+  // registers an override with the specified |overridden_state|. Also, will
+  // associate an optional named field trial if the entry is of the format
+  // "FeatureName<TrialName".
+  void RegisterOverridesFromCommandLine(const std::string& feature_list,
+                                        OverrideState overridden_state);
+
+  // Registers an override for feature |feature_name|. The override specifies
+  // whether the feature should be on or off (via |overridden_state|), which
+  // will take precedence over the feature's default state. If |field_trial| is
+  // not null, registers the specified field trial object to be associated with
+  // the feature, which will activate the field trial when the feature state is
+  // queried. If an override is already registered for the given feature, it
+  // will not be changed.
+  void RegisterOverride(StringPiece feature_name,
+                        OverrideState overridden_state,
+                        FieldTrial* field_trial);
+
+  // Implementation of GetFeatureOverrides() with a parameter that specifies
+  // whether only command-line enabled overrides should be emitted. See that
+  // function's comments for more details.
+  void GetFeatureOverridesImpl(std::string* enable_overrides,
+                               std::string* disable_overrides,
+                               bool command_line_only);
+
+  // Verifies that there's only a single definition of a Feature struct for a
+  // given feature name. Keeps track of the first seen Feature struct for each
+  // feature. Returns false when called on a Feature struct with a different
+  // address than the first one it saw for that feature name. Used only from
+  // DCHECKs and tests.
+  bool CheckFeatureIdentity(const Feature& feature);
+
+  // Map from feature name to an OverrideEntry struct for the feature, if it
+  // exists.
+  std::map<std::string, OverrideEntry> overrides_;
+
+  // Locked map that keeps track of seen features, to ensure a single feature is
+  // only defined once. This verification is only done in builds with DCHECKs
+  // enabled.
+  Lock feature_identity_tracker_lock_;
+  std::map<std::string, const Feature*> feature_identity_tracker_;
+
+  // Whether this object has been fully initialized. This gets set to true as a
+  // result of FinalizeInitialization().
+  bool initialized_ = false;
+
+  // Whether this object has been initialized from command line.
+  bool initialized_from_command_line_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(FeatureList);
+};
+
+}  // namespace base
+
+#endif  // BASE_FEATURE_LIST_H_
diff --git a/native/zucchini/vendor/libchrome/base/file_descriptor_posix.h b/native/zucchini/vendor/libchrome/base/file_descriptor_posix.h
new file mode 100644
index 0000000..2a36611
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/file_descriptor_posix.h
@@ -0,0 +1,59 @@
+// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_FILE_DESCRIPTOR_POSIX_H_
+#define BASE_FILE_DESCRIPTOR_POSIX_H_
+
+#include "base/files/file.h"
+#include "base/files/scoped_file.h"
+
+namespace base {
+
+// -----------------------------------------------------------------------------
+// We introduct a special structure for file descriptors in order that we are
+// able to use template specialisation to special-case their handling.
+//
+// IMPORTANT: This is primarily intended for use when sending file descriptors
+// over IPC. Even if |auto_close| is true, base::FileDescriptor does NOT close()
+// |fd| when going out of scope. Instead, a consumer of a base::FileDescriptor
+// must invoke close() on |fd| if |auto_close| is true.
+//
+// In the case of IPC, the the IPC subsystem knows to close() |fd| after sending
+// a message that contains a base::FileDescriptor if auto_close == true. On the
+// other end, the receiver must make sure to close() |fd| after it has finished
+// processing the IPC message. See the IPC::ParamTraits<> specialization in
+// ipc/ipc_message_utils.h for all the details.
+// -----------------------------------------------------------------------------
+struct FileDescriptor {
+  FileDescriptor() : fd(-1), auto_close(false) {}
+
+  FileDescriptor(int ifd, bool iauto_close) : fd(ifd), auto_close(iauto_close) {
+  }
+
+  FileDescriptor(File file) : fd(file.TakePlatformFile()), auto_close(true) {}
+  explicit FileDescriptor(ScopedFD fd) : fd(fd.release()), auto_close(true) {}
+
+  bool operator==(const FileDescriptor& other) const {
+    return (fd == other.fd && auto_close == other.auto_close);
+  }
+
+  bool operator!=(const FileDescriptor& other) const {
+    return !operator==(other);
+  }
+
+  // A comparison operator so that we can use these as keys in a std::map.
+  bool operator<(const FileDescriptor& other) const {
+    return other.fd < fd;
+  }
+
+  int fd;
+  // If true, this file descriptor should be closed after it has been used. For
+  // example an IPC system might interpret this flag as indicating that the
+  // file descriptor it has been given should be closed after use.
+  bool auto_close;
+};
+
+}  // namespace base
+
+#endif  // BASE_FILE_DESCRIPTOR_POSIX_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/file.h b/native/zucchini/vendor/libchrome/base/files/file.h
new file mode 100644
index 0000000..30f4053
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/files/file.h
@@ -0,0 +1,381 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_FILES_FILE_H_
+#define BASE_FILES_FILE_H_
+
+#include <stdint.h>
+
+#include <string>
+
+#include "base/base_export.h"
+#include "base/files/file_path.h"
+#include "base/files/file_tracing.h"
+#include "base/files/platform_file.h"
+#include "base/files/scoped_file.h"
+#include "base/macros.h"
+#include "base/time/time.h"
+#include "build/build_config.h"
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+#include <sys/stat.h>
+#endif
+
+namespace base {
+
+#if defined(OS_BSD) || defined(OS_MACOSX) || defined(OS_NACL) || \
+  defined(OS_FUCHSIA) || (defined(OS_ANDROID) && __ANDROID_API__ < 21)
+typedef struct stat stat_wrapper_t;
+#elif defined(OS_POSIX)
+typedef struct stat64 stat_wrapper_t;
+#endif
+
+// Thin wrapper around an OS-level file.
+// Note that this class does not provide any support for asynchronous IO, other
+// than the ability to create asynchronous handles on Windows.
+//
+// Note about const: this class does not attempt to determine if the underlying
+// file system object is affected by a particular method in order to consider
+// that method const or not. Only methods that deal with member variables in an
+// obvious non-modifying way are marked as const. Any method that forward calls
+// to the OS is not considered const, even if there is no apparent change to
+// member variables.
+class BASE_EXPORT File {
+ public:
+  // FLAG_(OPEN|CREATE).* are mutually exclusive. You should specify exactly one
+  // of the five (possibly combining with other flags) when opening or creating
+  // a file.
+  // FLAG_(WRITE|APPEND) are mutually exclusive. This is so that APPEND behavior
+  // will be consistent with O_APPEND on POSIX.
+  // FLAG_EXCLUSIVE_(READ|WRITE) only grant exclusive access to the file on
+  // creation on POSIX; for existing files, consider using Lock().
+  enum Flags {
+    FLAG_OPEN = 1 << 0,            // Opens a file, only if it exists.
+    FLAG_CREATE = 1 << 1,          // Creates a new file, only if it does not
+                                   // already exist.
+    FLAG_OPEN_ALWAYS = 1 << 2,     // May create a new file.
+    FLAG_CREATE_ALWAYS = 1 << 3,   // May overwrite an old file.
+    FLAG_OPEN_TRUNCATED = 1 << 4,  // Opens a file and truncates it, only if it
+                                   // exists.
+    FLAG_READ = 1 << 5,
+    FLAG_WRITE = 1 << 6,
+    FLAG_APPEND = 1 << 7,
+    FLAG_EXCLUSIVE_READ = 1 << 8,  // EXCLUSIVE is opposite of Windows SHARE.
+    FLAG_EXCLUSIVE_WRITE = 1 << 9,
+    FLAG_ASYNC = 1 << 10,
+    FLAG_TEMPORARY = 1 << 11,  // Used on Windows only.
+    FLAG_HIDDEN = 1 << 12,     // Used on Windows only.
+    FLAG_DELETE_ON_CLOSE = 1 << 13,
+    FLAG_WRITE_ATTRIBUTES = 1 << 14,     // Used on Windows only.
+    FLAG_SHARE_DELETE = 1 << 15,         // Used on Windows only.
+    FLAG_TERMINAL_DEVICE = 1 << 16,      // Serial port flags.
+    FLAG_BACKUP_SEMANTICS = 1 << 17,     // Used on Windows only.
+    FLAG_EXECUTE = 1 << 18,              // Used on Windows only.
+    FLAG_SEQUENTIAL_SCAN = 1 << 19,      // Used on Windows only.
+    FLAG_CAN_DELETE_ON_CLOSE = 1 << 20,  // Requests permission to delete a file
+                                         // via DeleteOnClose() (Windows only).
+                                         // See DeleteOnClose() for details.
+  };
+
+  // This enum has been recorded in multiple histograms using PlatformFileError
+  // enum. If the order of the fields needs to change, please ensure that those
+  // histograms are obsolete or have been moved to a different enum.
+  //
+  // FILE_ERROR_ACCESS_DENIED is returned when a call fails because of a
+  // filesystem restriction. FILE_ERROR_SECURITY is returned when a browser
+  // policy doesn't allow the operation to be executed.
+  enum Error {
+    FILE_OK = 0,
+    FILE_ERROR_FAILED = -1,
+    FILE_ERROR_IN_USE = -2,
+    FILE_ERROR_EXISTS = -3,
+    FILE_ERROR_NOT_FOUND = -4,
+    FILE_ERROR_ACCESS_DENIED = -5,
+    FILE_ERROR_TOO_MANY_OPENED = -6,
+    FILE_ERROR_NO_MEMORY = -7,
+    FILE_ERROR_NO_SPACE = -8,
+    FILE_ERROR_NOT_A_DIRECTORY = -9,
+    FILE_ERROR_INVALID_OPERATION = -10,
+    FILE_ERROR_SECURITY = -11,
+    FILE_ERROR_ABORT = -12,
+    FILE_ERROR_NOT_A_FILE = -13,
+    FILE_ERROR_NOT_EMPTY = -14,
+    FILE_ERROR_INVALID_URL = -15,
+    FILE_ERROR_IO = -16,
+    // Put new entries here and increment FILE_ERROR_MAX.
+    FILE_ERROR_MAX = -17
+  };
+
+  // This explicit mapping matches both FILE_ on Windows and SEEK_ on Linux.
+  enum Whence {
+    FROM_BEGIN   = 0,
+    FROM_CURRENT = 1,
+    FROM_END     = 2
+  };
+
+  // Used to hold information about a given file.
+  // If you add more fields to this structure (platform-specific fields are OK),
+  // make sure to update all functions that use it in file_util_{win|posix}.cc,
+  // too, and the ParamTraits<base::File::Info> implementation in
+  // ipc/ipc_message_utils.cc.
+  struct BASE_EXPORT Info {
+    Info();
+    ~Info();
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+    // Fills this struct with values from |stat_info|.
+    void FromStat(const stat_wrapper_t& stat_info);
+#endif
+
+    // The size of the file in bytes.  Undefined when is_directory is true.
+    int64_t size;
+
+    // True if the file corresponds to a directory.
+    bool is_directory;
+
+    // True if the file corresponds to a symbolic link.  For Windows currently
+    // not supported and thus always false.
+    bool is_symbolic_link;
+
+    // The last modified time of a file.
+    Time last_modified;
+
+    // The last accessed time of a file.
+    Time last_accessed;
+
+    // The creation time of a file.
+    Time creation_time;
+  };
+
+  File();
+
+  // Creates or opens the given file. This will fail with 'access denied' if the
+  // |path| contains path traversal ('..') components.
+  File(const FilePath& path, uint32_t flags);
+
+  // Takes ownership of |platform_file| and sets async to false.
+  explicit File(PlatformFile platform_file);
+
+  // Takes ownership of |platform_file| and sets async to the given value.
+  // This constructor exists because on Windows you can't check if platform_file
+  // is async or not.
+  File(PlatformFile platform_file, bool async);
+
+  // Creates an object with a specific error_details code.
+  explicit File(Error error_details);
+
+  File(File&& other);
+
+  ~File();
+
+  File& operator=(File&& other);
+
+  // Creates or opens the given file.
+  void Initialize(const FilePath& path, uint32_t flags);
+
+  // Returns |true| if the handle / fd wrapped by this object is valid.  This
+  // method doesn't interact with the file system (and is safe to be called from
+  // ThreadRestrictions::SetIOAllowed(false) threads).
+  bool IsValid() const;
+
+  // Returns true if a new file was created (or an old one truncated to zero
+  // length to simulate a new file, which can happen with
+  // FLAG_CREATE_ALWAYS), and false otherwise.
+  bool created() const { return created_; }
+
+  // Returns the OS result of opening this file. Note that the way to verify
+  // the success of the operation is to use IsValid(), not this method:
+  //   File file(path, flags);
+  //   if (!file.IsValid())
+  //     return;
+  Error error_details() const { return error_details_; }
+
+  PlatformFile GetPlatformFile() const;
+  PlatformFile TakePlatformFile();
+
+  // Destroying this object closes the file automatically.
+  void Close();
+
+  // Changes current position in the file to an |offset| relative to an origin
+  // defined by |whence|. Returns the resultant current position in the file
+  // (relative to the start) or -1 in case of error.
+  int64_t Seek(Whence whence, int64_t offset);
+
+  // Reads the given number of bytes (or until EOF is reached) starting with the
+  // given offset. Returns the number of bytes read, or -1 on error. Note that
+  // this function makes a best effort to read all data on all platforms, so it
+  // is not intended for stream oriented files but instead for cases when the
+  // normal expectation is that actually |size| bytes are read unless there is
+  // an error.
+  int Read(int64_t offset, char* data, int size);
+
+  // Same as above but without seek.
+  int ReadAtCurrentPos(char* data, int size);
+
+  // Reads the given number of bytes (or until EOF is reached) starting with the
+  // given offset, but does not make any effort to read all data on all
+  // platforms. Returns the number of bytes read, or -1 on error.
+  int ReadNoBestEffort(int64_t offset, char* data, int size);
+
+  // Same as above but without seek.
+  int ReadAtCurrentPosNoBestEffort(char* data, int size);
+
+  // Writes the given buffer into the file at the given offset, overwritting any
+  // data that was previously there. Returns the number of bytes written, or -1
+  // on error. Note that this function makes a best effort to write all data on
+  // all platforms. |data| can be nullptr when |size| is 0.
+  // Ignores the offset and writes to the end of the file if the file was opened
+  // with FLAG_APPEND.
+  int Write(int64_t offset, const char* data, int size);
+
+  // Save as above but without seek.
+  int WriteAtCurrentPos(const char* data, int size);
+
+  // Save as above but does not make any effort to write all data on all
+  // platforms. Returns the number of bytes written, or -1 on error.
+  int WriteAtCurrentPosNoBestEffort(const char* data, int size);
+
+  // Returns the current size of this file, or a negative number on failure.
+  int64_t GetLength();
+
+  // Truncates the file to the given length. If |length| is greater than the
+  // current size of the file, the file is extended with zeros. If the file
+  // doesn't exist, |false| is returned.
+  bool SetLength(int64_t length);
+
+  // Instructs the filesystem to flush the file to disk. (POSIX: fsync, Windows:
+  // FlushFileBuffers).
+  // Calling Flush() does not guarantee file integrity and thus is not a valid
+  // substitute for file integrity checks and recovery codepaths for malformed
+  // files. It can also be *really* slow, so avoid blocking on Flush(),
+  // especially please don't block shutdown on Flush().
+  // Latency percentiles of Flush() across all platforms as of July 2016:
+  // 50 %     > 5 ms
+  // 10 %     > 58 ms
+  //  1 %     > 357 ms
+  //  0.1 %   > 1.8 seconds
+  //  0.01 %  > 7.6 seconds
+  bool Flush();
+
+  // Updates the file times.
+  bool SetTimes(Time last_access_time, Time last_modified_time);
+
+  // Returns some basic information for the given file.
+  bool GetInfo(Info* info);
+
+#if !defined(OS_FUCHSIA)  // Fuchsia's POSIX API does not support file locking.
+
+  // Attempts to take an exclusive write lock on the file. Returns immediately
+  // (i.e. does not wait for another process to unlock the file). If the lock
+  // was obtained, the result will be FILE_OK. A lock only guarantees
+  // that other processes may not also take a lock on the same file with the
+  // same API - it may still be opened, renamed, unlinked, etc.
+  //
+  // Common semantics:
+  //  * Locks are held by processes, but not inherited by child processes.
+  //  * Locks are released by the OS on file close or process termination.
+  //  * Locks are reliable only on local filesystems.
+  //  * Duplicated file handles may also write to locked files.
+  // Windows-specific semantics:
+  //  * Locks are mandatory for read/write APIs, advisory for mapping APIs.
+  //  * Within a process, locking the same file (by the same or new handle)
+  //    will fail.
+  // POSIX-specific semantics:
+  //  * Locks are advisory only.
+  //  * Within a process, locking the same file (by the same or new handle)
+  //    will succeed.
+  //  * Closing any descriptor on a given file releases the lock.
+  Error Lock();
+
+  // Unlock a file previously locked.
+  Error Unlock();
+
+#endif  // !defined(OS_FUCHSIA)
+
+  // Returns a new object referencing this file for use within the current
+  // process. Handling of FLAG_DELETE_ON_CLOSE varies by OS. On POSIX, the File
+  // object that was created or initialized with this flag will have unlinked
+  // the underlying file when it was created or opened. On Windows, the
+  // underlying file is deleted when the last handle to it is closed.
+  File Duplicate() const;
+
+  bool async() const { return async_; }
+
+#if defined(OS_WIN)
+  // Sets or clears the DeleteFile disposition on the file. Returns true if
+  // the disposition was set or cleared, as indicated by |delete_on_close|.
+  //
+  // Microsoft Windows deletes a file only when the DeleteFile disposition is
+  // set on a file when the last handle to the last underlying kernel File
+  // object is closed. This disposition is be set by:
+  // - Calling the Win32 DeleteFile function with the path to a file.
+  // - Opening/creating a file with FLAG_DELETE_ON_CLOSE and then closing all
+  //   handles to that File object.
+  // - Opening/creating a file with FLAG_CAN_DELETE_ON_CLOSE and subsequently
+  //   calling DeleteOnClose(true).
+  //
+  // In all cases, all pre-existing handles to the file must have been opened
+  // with FLAG_SHARE_DELETE. Once the disposition has been set by any of the
+  // above means, no new File objects can be created for the file.
+  //
+  // So:
+  // - Use FLAG_SHARE_DELETE when creating/opening a file to allow another
+  //   entity on the system to cause it to be deleted when it is closed. (Note:
+  //   another entity can delete the file the moment after it is closed, so not
+  //   using this permission doesn't provide any protections.)
+  // - Use FLAG_DELETE_ON_CLOSE for any file that is to be deleted after use.
+  //   The OS will ensure it is deleted even in the face of process termination.
+  //   Note that it's possible for deletion to be cancelled via another File
+  //   object referencing the same file using DeleteOnClose(false) to clear the
+  //   DeleteFile disposition after the original File is closed.
+  // - Use FLAG_CAN_DELETE_ON_CLOSE in conjunction with DeleteOnClose() to alter
+  //   the DeleteFile disposition on an open handle. This fine-grained control
+  //   allows for marking a file for deletion during processing so that it is
+  //   deleted in the event of untimely process termination, and then clearing
+  //   this state once the file is suitable for persistence.
+  bool DeleteOnClose(bool delete_on_close);
+#endif
+
+#if defined(OS_WIN)
+  static Error OSErrorToFileError(DWORD last_error);
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  static Error OSErrorToFileError(int saved_errno);
+#endif
+
+  // Gets the last global error (errno or GetLastError()) and converts it to the
+  // closest base::File::Error equivalent via OSErrorToFileError(). The returned
+  // value is only trustworthy immediately after another base::File method
+  // fails. base::File never resets the global error to zero.
+  static Error GetLastFileError();
+
+  // Converts an error value to a human-readable form. Used for logging.
+  static std::string ErrorToString(Error error);
+
+ private:
+  friend class FileTracing::ScopedTrace;
+
+  // Creates or opens the given file. Only called if |path| has no
+  // traversal ('..') components.
+  void DoInitialize(const FilePath& path, uint32_t flags);
+
+  void SetPlatformFile(PlatformFile file);
+
+  ScopedPlatformFile file_;
+
+  // A path to use for tracing purposes. Set if file tracing is enabled during
+  // |Initialize()|.
+  FilePath tracing_path_;
+
+  // Object tied to the lifetime of |this| that enables/disables tracing.
+  FileTracing::ScopedEnabler trace_enabler_;
+
+  Error error_details_;
+  bool created_;
+  bool async_;
+
+  DISALLOW_COPY_AND_ASSIGN(File);
+};
+
+}  // namespace base
+
+#endif  // BASE_FILES_FILE_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/file_path.h b/native/zucchini/vendor/libchrome/base/files/file_path.h
new file mode 100644
index 0000000..2dc15f9
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/files/file_path.h
@@ -0,0 +1,481 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// FilePath is a container for pathnames stored in a platform's native string
+// type, providing containers for manipulation in according with the
+// platform's conventions for pathnames.  It supports the following path
+// types:
+//
+//                   POSIX            Windows
+//                   ---------------  ----------------------------------
+// Fundamental type  char[]           wchar_t[]
+// Encoding          unspecified*     UTF-16
+// Separator         /                \, tolerant of /
+// Drive letters     no               case-insensitive A-Z followed by :
+// Alternate root    // (surprise!)   \\, for UNC paths
+//
+// * The encoding need not be specified on POSIX systems, although some
+//   POSIX-compliant systems do specify an encoding.  Mac OS X uses UTF-8.
+//   Chrome OS also uses UTF-8.
+//   Linux does not specify an encoding, but in practice, the locale's
+//   character set may be used.
+//
+// For more arcane bits of path trivia, see below.
+//
+// FilePath objects are intended to be used anywhere paths are.  An
+// application may pass FilePath objects around internally, masking the
+// underlying differences between systems, only differing in implementation
+// where interfacing directly with the system.  For example, a single
+// OpenFile(const FilePath &) function may be made available, allowing all
+// callers to operate without regard to the underlying implementation.  On
+// POSIX-like platforms, OpenFile might wrap fopen, and on Windows, it might
+// wrap _wfopen_s, perhaps both by calling file_path.value().c_str().  This
+// allows each platform to pass pathnames around without requiring conversions
+// between encodings, which has an impact on performance, but more imporantly,
+// has an impact on correctness on platforms that do not have well-defined
+// encodings for pathnames.
+//
+// Several methods are available to perform common operations on a FilePath
+// object, such as determining the parent directory (DirName), isolating the
+// final path component (BaseName), and appending a relative pathname string
+// to an existing FilePath object (Append).  These methods are highly
+// recommended over attempting to split and concatenate strings directly.
+// These methods are based purely on string manipulation and knowledge of
+// platform-specific pathname conventions, and do not consult the filesystem
+// at all, making them safe to use without fear of blocking on I/O operations.
+// These methods do not function as mutators but instead return distinct
+// instances of FilePath objects, and are therefore safe to use on const
+// objects.  The objects themselves are safe to share between threads.
+//
+// To aid in initialization of FilePath objects from string literals, a
+// FILE_PATH_LITERAL macro is provided, which accounts for the difference
+// between char[]-based pathnames on POSIX systems and wchar_t[]-based
+// pathnames on Windows.
+//
+// As a precaution against premature truncation, paths can't contain NULs.
+//
+// Because a FilePath object should not be instantiated at the global scope,
+// instead, use a FilePath::CharType[] and initialize it with
+// FILE_PATH_LITERAL.  At runtime, a FilePath object can be created from the
+// character array.  Example:
+//
+// | const FilePath::CharType kLogFileName[] = FILE_PATH_LITERAL("log.txt");
+// |
+// | void Function() {
+// |   FilePath log_file_path(kLogFileName);
+// |   [...]
+// | }
+//
+// WARNING: FilePaths should ALWAYS be displayed with LTR directionality, even
+// when the UI language is RTL. This means you always need to pass filepaths
+// through base::i18n::WrapPathWithLTRFormatting() before displaying it in the
+// RTL UI.
+//
+// This is a very common source of bugs, please try to keep this in mind.
+//
+// ARCANE BITS OF PATH TRIVIA
+//
+//  - A double leading slash is actually part of the POSIX standard.  Systems
+//    are allowed to treat // as an alternate root, as Windows does for UNC
+//    (network share) paths.  Most POSIX systems don't do anything special
+//    with two leading slashes, but FilePath handles this case properly
+//    in case it ever comes across such a system.  FilePath needs this support
+//    for Windows UNC paths, anyway.
+//    References:
+//    The Open Group Base Specifications Issue 7, sections 3.267 ("Pathname")
+//    and 4.12 ("Pathname Resolution"), available at:
+//    http://www.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_267
+//    http://www.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_12
+//
+//  - Windows treats c:\\ the same way it treats \\.  This was intended to
+//    allow older applications that require drive letters to support UNC paths
+//    like \\server\share\path, by permitting c:\\server\share\path as an
+//    equivalent.  Since the OS treats these paths specially, FilePath needs
+//    to do the same.  Since Windows can use either / or \ as the separator,
+//    FilePath treats c://, c:\\, //, and \\ all equivalently.
+//    Reference:
+//    The Old New Thing, "Why is a drive letter permitted in front of UNC
+//    paths (sometimes)?", available at:
+//    http://blogs.msdn.com/oldnewthing/archive/2005/11/22/495740.aspx
+
+#ifndef BASE_FILES_FILE_PATH_H_
+#define BASE_FILES_FILE_PATH_H_
+
+#include <stddef.h>
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_piece.h"
+#include "build/build_config.h"
+
+// Windows-style drive letter support and pathname separator characters can be
+// enabled and disabled independently, to aid testing.  These #defines are
+// here so that the same setting can be used in both the implementation and
+// in the unit test.
+#if defined(OS_WIN)
+#define FILE_PATH_USES_DRIVE_LETTERS
+#define FILE_PATH_USES_WIN_SEPARATORS
+#endif  // OS_WIN
+
+// To print path names portably use PRIsFP (based on PRIuS and friends from
+// C99 and format_macros.h) like this:
+// base::StringPrintf("Path is %" PRIsFP ".\n", path.value().c_str());
+#if defined(OS_WIN)
+#define PRIsFP "ls"
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+#define PRIsFP "s"
+#endif  // OS_WIN
+
+namespace base {
+
+class Pickle;
+class PickleIterator;
+
+// An abstraction to isolate users from the differences between native
+// pathnames on different platforms.
+class BASE_EXPORT FilePath {
+ public:
+#if defined(OS_WIN)
+  // On Windows, for Unicode-aware applications, native pathnames are wchar_t
+  // arrays encoded in UTF-16.
+  typedef std::wstring StringType;
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  // On most platforms, native pathnames are char arrays, and the encoding
+  // may or may not be specified.  On Mac OS X, native pathnames are encoded
+  // in UTF-8.
+  typedef std::string StringType;
+#endif  // OS_WIN
+
+  typedef BasicStringPiece<StringType> StringPieceType;
+  typedef StringType::value_type CharType;
+
+  // Null-terminated array of separators used to separate components in
+  // hierarchical paths.  Each character in this array is a valid separator,
+  // but kSeparators[0] is treated as the canonical separator and will be used
+  // when composing pathnames.
+  static const CharType kSeparators[];
+
+  // arraysize(kSeparators).
+  static const size_t kSeparatorsLength;
+
+  // A special path component meaning "this directory."
+  static const CharType kCurrentDirectory[];
+
+  // A special path component meaning "the parent directory."
+  static const CharType kParentDirectory[];
+
+  // The character used to identify a file extension.
+  static const CharType kExtensionSeparator;
+
+  FilePath();
+  FilePath(const FilePath& that);
+  explicit FilePath(StringPieceType path);
+  ~FilePath();
+  FilePath& operator=(const FilePath& that);
+
+  // Constructs FilePath with the contents of |that|, which is left in valid but
+  // unspecified state.
+  FilePath(FilePath&& that) noexcept;
+  // Replaces the contents with those of |that|, which is left in valid but
+  // unspecified state.
+  FilePath& operator=(FilePath&& that);
+
+  bool operator==(const FilePath& that) const;
+
+  bool operator!=(const FilePath& that) const;
+
+  // Required for some STL containers and operations
+  bool operator<(const FilePath& that) const {
+    return path_ < that.path_;
+  }
+
+  const StringType& value() const { return path_; }
+
+  bool empty() const { return path_.empty(); }
+
+  void clear() { path_.clear(); }
+
+  // Returns true if |character| is in kSeparators.
+  static bool IsSeparator(CharType character);
+
+  // Returns a vector of all of the components of the provided path. It is
+  // equivalent to calling DirName().value() on the path's root component,
+  // and BaseName().value() on each child component.
+  //
+  // To make sure this is lossless so we can differentiate absolute and
+  // relative paths, the root slash will be included even though no other
+  // slashes will be. The precise behavior is:
+  //
+  // Posix:  "/foo/bar"  ->  [ "/", "foo", "bar" ]
+  // Windows:  "C:\foo\bar"  ->  [ "C:", "\\", "foo", "bar" ]
+  void GetComponents(std::vector<FilePath::StringType>* components) const;
+
+  // Returns true if this FilePath is a strict parent of the |child|. Absolute
+  // and relative paths are accepted i.e. is /foo parent to /foo/bar and
+  // is foo parent to foo/bar. Does not convert paths to absolute, follow
+  // symlinks or directory navigation (e.g. ".."). A path is *NOT* its own
+  // parent.
+  bool IsParent(const FilePath& child) const;
+
+  // If IsParent(child) holds, appends to path (if non-NULL) the
+  // relative path to child and returns true.  For example, if parent
+  // holds "/Users/johndoe/Library/Application Support", child holds
+  // "/Users/johndoe/Library/Application Support/Google/Chrome/Default", and
+  // *path holds "/Users/johndoe/Library/Caches", then after
+  // parent.AppendRelativePath(child, path) is called *path will hold
+  // "/Users/johndoe/Library/Caches/Google/Chrome/Default".  Otherwise,
+  // returns false.
+  bool AppendRelativePath(const FilePath& child, FilePath* path) const;
+
+  // Returns a FilePath corresponding to the directory containing the path
+  // named by this object, stripping away the file component.  If this object
+  // only contains one component, returns a FilePath identifying
+  // kCurrentDirectory.  If this object already refers to the root directory,
+  // returns a FilePath identifying the root directory. Please note that this
+  // doesn't resolve directory navigation, e.g. the result for "../a" is "..".
+  FilePath DirName() const WARN_UNUSED_RESULT;
+
+  // Returns a FilePath corresponding to the last path component of this
+  // object, either a file or a directory.  If this object already refers to
+  // the root directory, returns a FilePath identifying the root directory;
+  // this is the only situation in which BaseName will return an absolute path.
+  FilePath BaseName() const WARN_UNUSED_RESULT;
+
+  // Returns ".jpg" for path "C:\pics\jojo.jpg", or an empty string if
+  // the file has no extension.  If non-empty, Extension() will always start
+  // with precisely one ".".  The following code should always work regardless
+  // of the value of path.  For common double-extensions like .tar.gz and
+  // .user.js, this method returns the combined extension.  For a single
+  // component, use FinalExtension().
+  // new_path = path.RemoveExtension().value().append(path.Extension());
+  // ASSERT(new_path == path.value());
+  // NOTE: this is different from the original file_util implementation which
+  // returned the extension without a leading "." ("jpg" instead of ".jpg")
+  StringType Extension() const WARN_UNUSED_RESULT;
+
+  // Returns the path's file extension, as in Extension(), but will
+  // never return a double extension.
+  //
+  // TODO(davidben): Check all our extension-sensitive code to see if
+  // we can rename this to Extension() and the other to something like
+  // LongExtension(), defaulting to short extensions and leaving the
+  // long "extensions" to logic like base::GetUniquePathNumber().
+  StringType FinalExtension() const WARN_UNUSED_RESULT;
+
+  // Returns "C:\pics\jojo" for path "C:\pics\jojo.jpg"
+  // NOTE: this is slightly different from the similar file_util implementation
+  // which returned simply 'jojo'.
+  FilePath RemoveExtension() const WARN_UNUSED_RESULT;
+
+  // Removes the path's file extension, as in RemoveExtension(), but
+  // ignores double extensions.
+  FilePath RemoveFinalExtension() const WARN_UNUSED_RESULT;
+
+  // Inserts |suffix| after the file name portion of |path| but before the
+  // extension.  Returns "" if BaseName() == "." or "..".
+  // Examples:
+  // path == "C:\pics\jojo.jpg" suffix == " (1)", returns "C:\pics\jojo (1).jpg"
+  // path == "jojo.jpg"         suffix == " (1)", returns "jojo (1).jpg"
+  // path == "C:\pics\jojo"     suffix == " (1)", returns "C:\pics\jojo (1)"
+  // path == "C:\pics.old\jojo" suffix == " (1)", returns "C:\pics.old\jojo (1)"
+  FilePath InsertBeforeExtension(
+      StringPieceType suffix) const WARN_UNUSED_RESULT;
+  FilePath InsertBeforeExtensionASCII(
+      StringPiece suffix) const WARN_UNUSED_RESULT;
+
+  // Adds |extension| to |file_name|. Returns the current FilePath if
+  // |extension| is empty. Returns "" if BaseName() == "." or "..".
+  FilePath AddExtension(StringPieceType extension) const WARN_UNUSED_RESULT;
+
+  // 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|.
+  // Returns "" if BaseName() == "." or "..".
+  FilePath ReplaceExtension(StringPieceType extension) const WARN_UNUSED_RESULT;
+
+  // Returns true if the file path matches the specified extension. The test is
+  // case insensitive. Don't forget the leading period if appropriate.
+  bool MatchesExtension(StringPieceType extension) const;
+
+  // Returns a FilePath by appending a separator and the supplied path
+  // component to this object's path.  Append takes care to avoid adding
+  // excessive separators if this object's path already ends with a separator.
+  // If this object's path is kCurrentDirectory, a new FilePath corresponding
+  // only to |component| is returned.  |component| must be a relative path;
+  // it is an error to pass an absolute path.
+  FilePath Append(StringPieceType component) const WARN_UNUSED_RESULT;
+  FilePath Append(const FilePath& component) const WARN_UNUSED_RESULT;
+
+  // Although Windows StringType is std::wstring, since the encoding it uses for
+  // paths is well defined, it can handle ASCII path components as well.
+  // Mac uses UTF8, and since ASCII is a subset of that, it works there as well.
+  // On Linux, although it can use any 8-bit encoding for paths, we assume that
+  // ASCII is a valid subset, regardless of the encoding, since many operating
+  // system paths will always be ASCII.
+  FilePath AppendASCII(StringPiece component) const WARN_UNUSED_RESULT;
+
+  // 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
+  // platforms, an absolute path begins with a separator character.
+  bool IsAbsolute() const;
+
+  // Returns true if the patch ends with a path separator character.
+  bool EndsWithSeparator() const WARN_UNUSED_RESULT;
+
+  // Returns a copy of this FilePath that ends with a trailing separator. If
+  // the input path is empty, an empty FilePath will be returned.
+  FilePath AsEndingWithSeparator() const WARN_UNUSED_RESULT;
+
+  // Returns a copy of this FilePath that does not end with a trailing
+  // separator.
+  FilePath StripTrailingSeparators() const WARN_UNUSED_RESULT;
+
+  // Returns true if this FilePath contains an attempt to reference a parent
+  // directory (e.g. has a path component that is "..").
+  bool ReferencesParent() const;
+
+  // Return a Unicode human-readable version of this path.
+  // Warning: you can *not*, in general, go from a display name back to a real
+  // path.  Only use this when displaying paths to users, not just when you
+  // want to stuff a string16 into some other API.
+  string16 LossyDisplayName() const;
+
+  // Return the path as ASCII, or the empty string if the path is not ASCII.
+  // This should only be used for cases where the FilePath is representing a
+  // known-ASCII filename.
+  std::string MaybeAsASCII() const;
+
+  // Return the path as UTF-8.
+  //
+  // This function is *unsafe* as there is no way to tell what encoding is
+  // used in file names on POSIX systems other than Mac and Chrome OS,
+  // although UTF-8 is practically used everywhere these days. To mitigate
+  // the encoding issue, this function internally calls
+  // SysNativeMBToWide() on POSIX systems other than Mac and Chrome OS,
+  // per assumption that the current locale's encoding is used in file
+  // names, but this isn't a perfect solution.
+  //
+  // Once it becomes safe to to stop caring about non-UTF-8 file names,
+  // the SysNativeMBToWide() hack will be removed from the code, along
+  // with "Unsafe" in the function name.
+  std::string AsUTF8Unsafe() const;
+
+  // Similar to AsUTF8Unsafe, but returns UTF-16 instead.
+  string16 AsUTF16Unsafe() const;
+
+  // Returns a FilePath object from a path name in UTF-8. This function
+  // should only be used for cases where you are sure that the input
+  // string is UTF-8.
+  //
+  // Like AsUTF8Unsafe(), this function is unsafe. This function
+  // internally calls SysWideToNativeMB() on POSIX systems other than Mac
+  // and Chrome OS, to mitigate the encoding issue. See the comment at
+  // AsUTF8Unsafe() for details.
+  static FilePath FromUTF8Unsafe(StringPiece utf8);
+
+  // Similar to FromUTF8Unsafe, but accepts UTF-16 instead.
+  static FilePath FromUTF16Unsafe(StringPiece16 utf16);
+
+  void WriteToPickle(Pickle* pickle) const;
+  bool ReadFromPickle(PickleIterator* iter);
+
+  // Normalize all path separators to backslash on Windows
+  // (if FILE_PATH_USES_WIN_SEPARATORS is true), or do nothing on POSIX systems.
+  FilePath NormalizePathSeparators() const;
+
+  // Normalize all path separattors to given type on Windows
+  // (if FILE_PATH_USES_WIN_SEPARATORS is true), or do nothing on POSIX systems.
+  FilePath NormalizePathSeparatorsTo(CharType separator) const;
+
+  // Compare two strings in the same way the file system does.
+  // Note that these always ignore case, even on file systems that are case-
+  // sensitive. If case-sensitive comparison is ever needed, add corresponding
+  // methods here.
+  // The methods are written as a static method so that they can also be used
+  // on parts of a file path, e.g., just the extension.
+  // CompareIgnoreCase() returns -1, 0 or 1 for less-than, equal-to and
+  // greater-than respectively.
+  static int CompareIgnoreCase(StringPieceType string1,
+                               StringPieceType string2);
+  static bool CompareEqualIgnoreCase(StringPieceType string1,
+                                     StringPieceType string2) {
+    return CompareIgnoreCase(string1, string2) == 0;
+  }
+  static bool CompareLessIgnoreCase(StringPieceType string1,
+                                    StringPieceType string2) {
+    return CompareIgnoreCase(string1, string2) < 0;
+  }
+
+#if defined(OS_MACOSX)
+  // Returns the string in the special canonical decomposed form as defined for
+  // HFS, which is close to, but not quite, decomposition form D. See
+  // http://developer.apple.com/mac/library/technotes/tn/tn1150.html#UnicodeSubtleties
+  // for further comments.
+  // Returns the epmty string if the conversion failed.
+  static StringType GetHFSDecomposedForm(StringPieceType string);
+
+  // Special UTF-8 version of FastUnicodeCompare. Cf:
+  // http://developer.apple.com/mac/library/technotes/tn/tn1150.html#StringComparisonAlgorithm
+  // IMPORTANT: The input strings must be in the special HFS decomposed form!
+  // (cf. above GetHFSDecomposedForm method)
+  static int HFSFastUnicodeCompare(StringPieceType string1,
+                                   StringPieceType string2);
+#endif
+
+#if defined(OS_ANDROID)
+  // On android, file selection dialog can return a file with content uri
+  // scheme(starting with content://). Content uri needs to be opened with
+  // ContentResolver to guarantee that the app has appropriate permissions
+  // to access it.
+  // Returns true if the path is a content uri, or false otherwise.
+  bool IsContentUri() const;
+#endif
+
+ private:
+  // Remove trailing separators from this object.  If the path is absolute, it
+  // will never be stripped any more than to refer to the absolute root
+  // directory, so "////" will become "/", not "".  A leading pair of
+  // separators is never stripped, to support alternate roots.  This is used to
+  // support UNC paths on Windows.
+  void StripTrailingSeparatorsInternal();
+
+  StringType path_;
+};
+
+BASE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                     const FilePath& file_path);
+
+}  // namespace base
+
+// Macros for string literal initialization of FilePath::CharType[], and for
+// using a FilePath::CharType[] in a printf-style format string.
+#if defined(OS_WIN)
+#define FILE_PATH_LITERAL(x) L ## x
+#define PRFilePath "ls"
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+#define FILE_PATH_LITERAL(x) x
+#define PRFilePath "s"
+#endif  // OS_WIN
+
+namespace std {
+
+template <>
+struct hash<base::FilePath> {
+  typedef base::FilePath argument_type;
+  typedef std::size_t result_type;
+  result_type operator()(argument_type const& f) const {
+    return hash<base::FilePath::StringType>()(f.value());
+  }
+};
+
+}  // namespace std
+
+#endif  // BASE_FILES_FILE_PATH_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/file_tracing.h b/native/zucchini/vendor/libchrome/base/files/file_tracing.h
new file mode 100644
index 0000000..1fbfcd4
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/files/file_tracing.h
@@ -0,0 +1,95 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_FILES_FILE_TRACING_H_
+#define BASE_FILES_FILE_TRACING_H_
+
+#include <stdint.h>
+
+#include "base/base_export.h"
+#include "base/macros.h"
+
+#define FILE_TRACING_PREFIX "File"
+
+#define SCOPED_FILE_TRACE_WITH_SIZE(name, size) \
+    FileTracing::ScopedTrace scoped_file_trace; \
+    if (FileTracing::IsCategoryEnabled()) \
+      scoped_file_trace.Initialize(FILE_TRACING_PREFIX "::" name, this, size)
+
+#define SCOPED_FILE_TRACE(name) SCOPED_FILE_TRACE_WITH_SIZE(name, 0)
+
+namespace base {
+
+class File;
+class FilePath;
+
+class BASE_EXPORT FileTracing {
+ public:
+  // Whether the file tracing category is enabled.
+  static bool IsCategoryEnabled();
+
+  class Provider {
+   public:
+    virtual ~Provider() = default;
+
+    // Whether the file tracing category is currently enabled.
+    virtual bool FileTracingCategoryIsEnabled() const = 0;
+
+    // Enables file tracing for |id|. Must be called before recording events.
+    virtual void FileTracingEnable(const void* id) = 0;
+
+    // Disables file tracing for |id|.
+    virtual void FileTracingDisable(const void* id) = 0;
+
+    // Begins an event for |id| with |name|. |path| tells where in the directory
+    // structure the event is happening (and may be blank). |size| is the number
+    // of bytes involved in the event.
+    virtual void FileTracingEventBegin(const char* name,
+                                       const void* id,
+                                       const FilePath& path,
+                                       int64_t size) = 0;
+
+    // Ends an event for |id| with |name|.
+    virtual void FileTracingEventEnd(const char* name, const void* id) = 0;
+  };
+
+  // Sets a global file tracing provider to query categories and record events.
+  static void SetProvider(Provider* provider);
+
+  // Enables file tracing while in scope.
+  class ScopedEnabler {
+   public:
+    ScopedEnabler();
+    ~ScopedEnabler();
+  };
+
+  class ScopedTrace {
+   public:
+    ScopedTrace();
+    ~ScopedTrace();
+
+    // Called only if the tracing category is enabled. |name| is the name of the
+    // event to trace (e.g. "Read", "Write") and must have an application
+    // lifetime (e.g. static or literal). |file| is the file being traced; must
+    // outlive this class. |size| is the size (in bytes) of this event.
+    void Initialize(const char* name, const File* file, int64_t size);
+
+   private:
+    // The ID of this trace. Based on the |file| passed to |Initialize()|. Must
+    // outlive this class.
+    const void* id_;
+
+    // The name of the event to trace (e.g. "Read", "Write"). Prefixed with
+    // "File".
+    const char* name_;
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedTrace);
+  };
+
+  DISALLOW_COPY_AND_ASSIGN(FileTracing);
+};
+
+}  // namespace base
+
+#endif  // BASE_FILES_FILE_TRACING_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/file_util.h b/native/zucchini/vendor/libchrome/base/files/file_util.h
new file mode 100644
index 0000000..456962a
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/files/file_util.h
@@ -0,0 +1,498 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file contains utility functions for dealing with the local
+// filesystem.
+
+#ifndef BASE_FILES_FILE_UTIL_H_
+#define BASE_FILES_FILE_UTIL_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include <set>
+#include <string>
+#include <vector>
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
+#include "base/base_export.h"
+#include "base/files/file.h"
+#include "base/files/file_path.h"
+#include "base/strings/string16.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include "base/win/windows_types.h"
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+#include "base/file_descriptor_posix.h"
+#include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
+#endif
+
+namespace base {
+
+class Environment;
+class Time;
+
+//-----------------------------------------------------------------------------
+// Functions that involve filesystem access or modification:
+
+// Returns an absolute version of a relative path. Returns an empty path on
+// error. On POSIX, this function fails if the path does not exist. This
+// function can result in I/O so it can be slow.
+BASE_EXPORT FilePath MakeAbsoluteFilePath(const FilePath& input);
+
+// Returns the total number of bytes used by all the files under |root_path|.
+// If the path does not exist the function returns 0.
+//
+// This function is implemented using the FileEnumerator class so it is not
+// particularly speedy in any platform.
+BASE_EXPORT int64_t ComputeDirectorySize(const FilePath& root_path);
+
+// Deletes the given path, whether it's a file or a directory.
+// If it's a directory, it's perfectly happy to delete all of the
+// directory's contents.  Passing true to recursive deletes
+// subdirectories and their contents as well.
+// Returns true if successful, false otherwise. It is considered successful
+// to attempt to delete a file that does not exist.
+//
+// In posix environment and if |path| is a symbolic link, this deletes only
+// the symlink. (even if the symlink points to a non-existent file)
+//
+// WARNING: USING THIS WITH recursive==true IS EQUIVALENT
+//          TO "rm -rf", SO USE WITH CAUTION.
+BASE_EXPORT bool DeleteFile(const FilePath& path, bool recursive);
+
+#if defined(OS_WIN)
+// Schedules to delete the given path, whether it's a file or a directory, until
+// the operating system is restarted.
+// Note:
+// 1) The file/directory to be deleted should exist in a temp folder.
+// 2) The directory to be deleted must be empty.
+BASE_EXPORT bool DeleteFileAfterReboot(const FilePath& path);
+#endif
+
+// Moves the given path, whether it's a file or a directory.
+// If a simple rename is not possible, such as in the case where the paths are
+// on different volumes, this will attempt to copy and delete. Returns
+// true for success.
+// This function fails if either path contains traversal components ('..').
+BASE_EXPORT bool Move(const FilePath& from_path, const FilePath& to_path);
+
+// Renames file |from_path| to |to_path|. Both paths must be on the same
+// volume, or the function will fail. Destination file will be created
+// if it doesn't exist. Prefer this function over Move when dealing with
+// temporary files. On Windows it preserves attributes of the target file.
+// Returns true on success, leaving *error unchanged.
+// Returns false on failure and sets *error appropriately, if it is non-NULL.
+BASE_EXPORT bool ReplaceFile(const FilePath& from_path,
+                             const FilePath& to_path,
+                             File::Error* error);
+
+// Copies a single file. Use CopyDirectory() to copy directories.
+// This function fails if either path contains traversal components ('..').
+// This function also fails if |to_path| is a directory.
+//
+// On POSIX, if |to_path| is a symlink, CopyFile() will follow the symlink. This
+// may have security implications. Use with care.
+//
+// If |to_path| already exists and is a regular file, it will be overwritten,
+// though its permissions will stay the same.
+//
+// If |to_path| does not exist, it will be created. The new file's permissions
+// varies per platform:
+//
+// - This function keeps the metadata on Windows. The read only bit is not kept.
+// - On Mac and iOS, |to_path| retains |from_path|'s permissions, except user
+//   read/write permissions are always set.
+// - On Linux and Android, |to_path| has user read/write permissions only. i.e.
+//   Always 0600.
+// - On ChromeOS, |to_path| has user read/write permissions and group/others
+//   read permissions. i.e. Always 0644.
+BASE_EXPORT bool CopyFile(const FilePath& from_path, const FilePath& to_path);
+
+// Copies the given path, and optionally all subdirectories and their contents
+// as well.
+//
+// If there are files existing under to_path, always overwrite. Returns true
+// if successful, false otherwise. Wildcards on the names are not supported.
+//
+// This function has the same metadata behavior as CopyFile().
+//
+// If you only need to copy a file use CopyFile, it's faster.
+BASE_EXPORT bool CopyDirectory(const FilePath& from_path,
+                               const FilePath& to_path,
+                               bool recursive);
+
+// Like CopyDirectory() except trying to overwrite an existing file will not
+// work and will return false.
+BASE_EXPORT bool CopyDirectoryExcl(const FilePath& from_path,
+                                   const FilePath& to_path,
+                                   bool recursive);
+
+// Returns true if the given path exists on the local filesystem,
+// false otherwise.
+BASE_EXPORT bool PathExists(const FilePath& path);
+
+// Returns true if the given path is writable by the user, false otherwise.
+BASE_EXPORT bool PathIsWritable(const FilePath& path);
+
+// Returns true if the given path exists and is a directory, false otherwise.
+BASE_EXPORT bool DirectoryExists(const FilePath& path);
+
+// Returns true if the contents of the two files given are equal, false
+// otherwise.  If either file can't be read, returns false.
+BASE_EXPORT bool ContentsEqual(const FilePath& filename1,
+                               const FilePath& filename2);
+
+// Returns true if the contents of the two text files given are equal, false
+// otherwise.  This routine treats "\r\n" and "\n" as equivalent.
+BASE_EXPORT bool TextContentsEqual(const FilePath& filename1,
+                                   const FilePath& filename2);
+
+// Reads the file at |path| into |contents| and returns true on success and
+// false on error.  For security reasons, a |path| containing path traversal
+// components ('..') is treated as a read error and |contents| is set to empty.
+// In case of I/O error, |contents| holds the data that could be read from the
+// file before the error occurred.
+// |contents| may be NULL, in which case this function is useful for its side
+// effect of priming the disk cache (could be used for unit tests).
+BASE_EXPORT bool ReadFileToString(const FilePath& path, std::string* contents);
+
+// Reads the file at |path| into |contents| and returns true on success and
+// false on error.  For security reasons, a |path| containing path traversal
+// components ('..') is treated as a read error and |contents| is set to empty.
+// In case of I/O error, |contents| holds the data that could be read from the
+// file before the error occurred.  When the file size exceeds |max_size|, the
+// function returns false with |contents| holding the file truncated to
+// |max_size|.
+// |contents| may be NULL, in which case this function is useful for its side
+// effect of priming the disk cache (could be used for unit tests).
+BASE_EXPORT bool ReadFileToStringWithMaxSize(const FilePath& path,
+                                             std::string* contents,
+                                             size_t max_size);
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+
+// Read exactly |bytes| bytes from file descriptor |fd|, storing the result
+// in |buffer|. This function is protected against EINTR and partial reads.
+// Returns true iff |bytes| bytes have been successfully read from |fd|.
+BASE_EXPORT bool ReadFromFD(int fd, char* buffer, size_t bytes);
+
+// Performs the same function as CreateAndOpenTemporaryFileInDir(), but returns
+// the file-descriptor directly, rather than wrapping it into a FILE. Returns
+// -1 on failure.
+BASE_EXPORT int CreateAndOpenFdForTemporaryFileInDir(const FilePath& dir,
+                                                     FilePath* path);
+
+#endif  // OS_POSIX || OS_FUCHSIA
+
+#if defined(OS_POSIX)
+
+// Creates a symbolic link at |symlink| pointing to |target|.  Returns
+// false on failure.
+BASE_EXPORT bool CreateSymbolicLink(const FilePath& target,
+                                    const FilePath& symlink);
+
+// Reads the given |symlink| and returns where it points to in |target|.
+// Returns false upon failure.
+BASE_EXPORT bool ReadSymbolicLink(const FilePath& symlink, FilePath* target);
+
+// Bits and masks of the file permission.
+enum FilePermissionBits {
+  FILE_PERMISSION_MASK              = S_IRWXU | S_IRWXG | S_IRWXO,
+  FILE_PERMISSION_USER_MASK         = S_IRWXU,
+  FILE_PERMISSION_GROUP_MASK        = S_IRWXG,
+  FILE_PERMISSION_OTHERS_MASK       = S_IRWXO,
+
+  FILE_PERMISSION_READ_BY_USER      = S_IRUSR,
+  FILE_PERMISSION_WRITE_BY_USER     = S_IWUSR,
+  FILE_PERMISSION_EXECUTE_BY_USER   = S_IXUSR,
+  FILE_PERMISSION_READ_BY_GROUP     = S_IRGRP,
+  FILE_PERMISSION_WRITE_BY_GROUP    = S_IWGRP,
+  FILE_PERMISSION_EXECUTE_BY_GROUP  = S_IXGRP,
+  FILE_PERMISSION_READ_BY_OTHERS    = S_IROTH,
+  FILE_PERMISSION_WRITE_BY_OTHERS   = S_IWOTH,
+  FILE_PERMISSION_EXECUTE_BY_OTHERS = S_IXOTH,
+};
+
+// Reads the permission of the given |path|, storing the file permission
+// bits in |mode|. If |path| is symbolic link, |mode| is the permission of
+// a file which the symlink points to.
+BASE_EXPORT bool GetPosixFilePermissions(const FilePath& path, int* mode);
+// Sets the permission of the given |path|. If |path| is symbolic link, sets
+// the permission of a file which the symlink points to.
+BASE_EXPORT bool SetPosixFilePermissions(const FilePath& path, int mode);
+
+// Returns true iff |executable| can be found in any directory specified by the
+// environment variable in |env|.
+BASE_EXPORT bool ExecutableExistsInPath(Environment* env,
+                                        const FilePath::StringType& executable);
+
+#if defined(OS_LINUX) || defined(OS_AIX)
+// Determine if files under a given |path| can be mapped and then mprotect'd
+// PROT_EXEC. This depends on the mount options used for |path|, which vary
+// among different Linux distributions and possibly local configuration. It also
+// depends on details of kernel--ChromeOS uses the noexec option for /dev/shm
+// but its kernel allows mprotect with PROT_EXEC anyway.
+BASE_EXPORT bool IsPathExecutable(const FilePath& path);
+#endif  // OS_LINUX || OS_AIX
+
+#endif  // OS_POSIX
+
+// Returns true if the given directory is empty
+BASE_EXPORT bool IsDirectoryEmpty(const FilePath& dir_path);
+
+// Get the temporary directory provided by the system.
+//
+// WARNING: In general, you should use CreateTemporaryFile variants below
+// instead of this function. Those variants will ensure that the proper
+// permissions are set so that other users on the system can't edit them while
+// they're open (which can lead to security issues).
+BASE_EXPORT bool GetTempDir(FilePath* path);
+
+// Get the home directory. This is more complicated than just getenv("HOME")
+// as it knows to fall back on getpwent() etc.
+//
+// You should not generally call this directly. Instead use DIR_HOME with the
+// path service which will use this function but cache the value.
+// Path service may also override DIR_HOME.
+BASE_EXPORT FilePath GetHomeDir();
+
+// Creates a temporary file. The full path is placed in |path|, and the
+// function returns true if was successful in creating the file. The file will
+// be empty and all handles closed after this function returns.
+BASE_EXPORT bool CreateTemporaryFile(FilePath* path);
+
+// Same as CreateTemporaryFile but the file is created in |dir|.
+BASE_EXPORT bool CreateTemporaryFileInDir(const FilePath& dir,
+                                          FilePath* temp_file);
+
+// Create and open a temporary file.  File is opened for read/write.
+// The full path is placed in |path|.
+// Returns a handle to the opened file or NULL if an error occurred.
+BASE_EXPORT FILE* CreateAndOpenTemporaryFile(FilePath* path);
+
+// Similar to CreateAndOpenTemporaryFile, but the file is created in |dir|.
+BASE_EXPORT FILE* CreateAndOpenTemporaryFileInDir(const FilePath& dir,
+                                                  FilePath* path);
+
+// Create a new directory. If prefix is provided, the new directory name is in
+// the format of prefixyyyy.
+// NOTE: prefix is ignored in the POSIX implementation.
+// If success, return true and output the full path of the directory created.
+BASE_EXPORT bool CreateNewTempDirectory(const FilePath::StringType& prefix,
+                                        FilePath* new_temp_path);
+
+// Create a directory within another directory.
+// 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,
+                                         const FilePath::StringType& prefix,
+                                         FilePath* new_dir);
+
+// Creates a directory, as well as creating any parent directories, if they
+// don't exist. Returns 'true' on successful creation, or if the directory
+// already exists.  The directory is only readable by the current user.
+// Returns true on success, leaving *error unchanged.
+// Returns false on failure and sets *error appropriately, if it is non-NULL.
+BASE_EXPORT bool CreateDirectoryAndGetError(const FilePath& full_path,
+                                            File::Error* error);
+
+// Backward-compatible convenience method for the above.
+BASE_EXPORT bool CreateDirectory(const FilePath& full_path);
+
+// Returns the file size. Returns true on success.
+BASE_EXPORT bool GetFileSize(const FilePath& file_path, int64_t* file_size);
+
+// Sets |real_path| to |path| with symbolic links and junctions expanded.
+// On windows, make sure the path starts with a lettered drive.
+// |path| must reference a file.  Function will fail if |path| points to
+// a directory or to a nonexistent path.  On windows, this function will
+// fail if |path| is a junction or symlink that points to an empty file,
+// or if |real_path| would be longer than MAX_PATH characters.
+BASE_EXPORT bool NormalizeFilePath(const FilePath& path, FilePath* real_path);
+
+#if defined(OS_WIN)
+
+// Given a path in NT native form ("\Device\HarddiskVolumeXX\..."),
+// return in |drive_letter_path| the equivalent path that starts with
+// a drive letter ("C:\...").  Return false if no such path exists.
+BASE_EXPORT bool DevicePathToDriveLetterPath(const FilePath& device_path,
+                                             FilePath* drive_letter_path);
+
+// Given an existing file in |path|, set |real_path| to the path
+// in native NT format, of the form "\Device\HarddiskVolumeXX\..".
+// Returns false if the path can not be found. Empty files cannot
+// be resolved with this function.
+BASE_EXPORT bool NormalizeToNativeFilePath(const FilePath& path,
+                                           FilePath* nt_path);
+#endif
+
+// This function will return if the given file is a symlink or not.
+BASE_EXPORT bool IsLink(const FilePath& file_path);
+
+// Returns information about the given file path.
+BASE_EXPORT bool GetFileInfo(const FilePath& file_path, File::Info* info);
+
+// Sets the time of the last access and the time of the last modification.
+BASE_EXPORT bool TouchFile(const FilePath& path,
+                           const Time& last_accessed,
+                           const Time& last_modified);
+
+// Wrapper for fopen-like calls. Returns non-NULL FILE* on success. The
+// underlying file descriptor (POSIX) or handle (Windows) is unconditionally
+// configured to not be propagated to child processes.
+BASE_EXPORT FILE* OpenFile(const FilePath& filename, const char* mode);
+
+// Closes file opened by OpenFile. Returns true on success.
+BASE_EXPORT bool CloseFile(FILE* file);
+
+// Associates a standard FILE stream with an existing File. Note that this
+// functions take ownership of the existing File.
+BASE_EXPORT FILE* FileToFILE(File file, const char* mode);
+
+// Truncates an open file to end at the location of the current file pointer.
+// This is a cross-platform analog to Windows' SetEndOfFile() function.
+BASE_EXPORT bool TruncateFile(FILE* file);
+
+// Reads at most the given number of bytes from the file into the buffer.
+// Returns the number of read bytes, or -1 on error.
+BASE_EXPORT int ReadFile(const FilePath& filename, char* data, int max_size);
+
+// Writes the given buffer into the file, overwriting any data that was
+// previously there.  Returns the number of bytes written, or -1 on error.
+BASE_EXPORT int WriteFile(const FilePath& filename, const char* data,
+                          int size);
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+// Appends |data| to |fd|. Does not close |fd| when done.  Returns true iff
+// |size| bytes of |data| were written to |fd|.
+BASE_EXPORT bool WriteFileDescriptor(const int fd, const char* data, int size);
+#endif
+
+// Appends |data| to |filename|.  Returns true iff |size| bytes of |data| were
+// written to |filename|.
+BASE_EXPORT bool AppendToFile(const FilePath& filename,
+                              const char* data,
+                              int size);
+
+// Gets the current working directory for the process.
+BASE_EXPORT bool GetCurrentDirectory(FilePath* path);
+
+// Sets the current working directory for the process.
+BASE_EXPORT bool SetCurrentDirectory(const FilePath& path);
+
+// Attempts to find a number that can be appended to the |path| to make it
+// unique. If |path| does not exist, 0 is returned.  If it fails to find such
+// a number, -1 is returned. If |suffix| is not empty, also checks the
+// existence of it with the given suffix.
+BASE_EXPORT int GetUniquePathNumber(const FilePath& path,
+                                    const FilePath::StringType& suffix);
+
+// Sets the given |fd| to non-blocking mode.
+// Returns true if it was able to set it in the non-blocking mode, otherwise
+// false.
+BASE_EXPORT bool SetNonBlocking(int fd);
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+// Creates a non-blocking, close-on-exec pipe.
+// This creates a non-blocking pipe that is not intended to be shared with any
+// child process. This will be done atomically if the operating system supports
+// it. Returns true if it was able to create the pipe, otherwise false.
+BASE_EXPORT bool CreateLocalNonBlockingPipe(int fds[2]);
+
+// Sets the given |fd| to close-on-exec mode.
+// Returns true if it was able to set it in the close-on-exec mode, otherwise
+// false.
+BASE_EXPORT bool SetCloseOnExec(int fd);
+
+// Test that |path| can only be changed by a given user and members of
+// a given set of groups.
+// Specifically, test that all parts of |path| under (and including) |base|:
+// * Exist.
+// * Are owned by a specific user.
+// * Are not writable by all users.
+// * Are owned by a member of a given set of groups, or are not writable by
+//   their group.
+// * Are not symbolic links.
+// This is useful for checking that a config file is administrator-controlled.
+// |base| must contain |path|.
+BASE_EXPORT bool VerifyPathControlledByUser(const base::FilePath& base,
+                                            const base::FilePath& path,
+                                            uid_t owner_uid,
+                                            const std::set<gid_t>& group_gids);
+#endif  // defined(OS_POSIX) || defined(OS_FUCHSIA)
+
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+// Is |path| writable only by a user with administrator privileges?
+// This function uses Mac OS conventions.  The super user is assumed to have
+// uid 0, and the administrator group is assumed to be named "admin".
+// Testing that |path|, and every parent directory including the root of
+// the filesystem, are owned by the superuser, controlled by the group
+// "admin", are not writable by all users, and contain no symbolic links.
+// Will return false if |path| does not exist.
+BASE_EXPORT bool VerifyPathControlledByAdmin(const base::FilePath& path);
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+
+// Returns the maximum length of path component on the volume containing
+// the directory |path|, in the number of FilePath::CharType, or -1 on failure.
+BASE_EXPORT int GetMaximumPathComponentLength(const base::FilePath& path);
+
+#if defined(OS_LINUX) || defined(OS_AIX)
+// Broad categories of file systems as returned by statfs() on Linux.
+enum FileSystemType {
+  FILE_SYSTEM_UNKNOWN,  // statfs failed.
+  FILE_SYSTEM_0,        // statfs.f_type == 0 means unknown, may indicate AFS.
+  FILE_SYSTEM_ORDINARY,       // on-disk filesystem like ext2
+  FILE_SYSTEM_NFS,
+  FILE_SYSTEM_SMB,
+  FILE_SYSTEM_CODA,
+  FILE_SYSTEM_MEMORY,         // in-memory file system
+  FILE_SYSTEM_CGROUP,         // cgroup control.
+  FILE_SYSTEM_OTHER,          // any other value.
+  FILE_SYSTEM_TYPE_COUNT
+};
+
+// Attempts determine the FileSystemType for |path|.
+// Returns false if |path| doesn't exist.
+BASE_EXPORT bool GetFileSystemType(const FilePath& path, FileSystemType* type);
+#endif
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+// Get a temporary directory for shared memory files. The directory may depend
+// on whether the destination is intended for executable files, which in turn
+// depends on how /dev/shmem was mounted. As a result, you must supply whether
+// you intend to create executable shmem segments so this function can find
+// an appropriate location.
+BASE_EXPORT bool GetShmemTempDir(bool executable, FilePath* path);
+#endif
+
+// Internal --------------------------------------------------------------------
+
+namespace internal {
+
+// Same as Move but allows paths with traversal components.
+// Use only with extreme care.
+BASE_EXPORT bool MoveUnsafe(const FilePath& from_path,
+                            const FilePath& to_path);
+
+#if defined(OS_WIN)
+// Copy from_path to to_path recursively and then delete from_path recursively.
+// Returns true if all operations succeed.
+// This function simulates Move(), but unlike Move() it works across volumes.
+// This function is not transactional.
+BASE_EXPORT bool CopyAndDeleteDirectory(const FilePath& from_path,
+                                        const FilePath& to_path);
+#endif  // defined(OS_WIN)
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_FILES_FILE_UTIL_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/memory_mapped_file.h b/native/zucchini/vendor/libchrome/base/files/memory_mapped_file.h
new file mode 100644
index 0000000..04f4336
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/files/memory_mapped_file.h
@@ -0,0 +1,136 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_FILES_MEMORY_MAPPED_FILE_H_
+#define BASE_FILES_MEMORY_MAPPED_FILE_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base/base_export.h"
+#include "base/files/file.h"
+#include "base/macros.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
+
+namespace base {
+
+class FilePath;
+
+class BASE_EXPORT MemoryMappedFile {
+ public:
+  enum Access {
+    // Mapping a file into memory effectively allows for file I/O on any thread.
+    // The accessing thread could be paused while data from the file is paged
+    // into memory. Worse, a corrupted filesystem could cause a SEGV within the
+    // program instead of just an I/O error.
+    READ_ONLY,
+
+    // This provides read/write access to a file and must be used with care of
+    // the additional subtleties involved in doing so. Though the OS will do
+    // the writing of data on its own time, too many dirty pages can cause
+    // the OS to pause the thread while it writes them out. The pause can
+    // be as much as 1s on some systems.
+    READ_WRITE,
+
+    // This provides read/write access but with the ability to write beyond
+    // the end of the existing file up to a maximum size specified as the
+    // "region". Depending on the OS, the file may or may not be immediately
+    // extended to the maximum size though it won't be loaded in RAM until
+    // needed. Note, however, that the maximum size will still be reserved
+    // in the process address space.
+    READ_WRITE_EXTEND,
+  };
+
+  // The default constructor sets all members to invalid/null values.
+  MemoryMappedFile();
+  ~MemoryMappedFile();
+
+  // Used to hold information about a region [offset + size] of a file.
+  struct BASE_EXPORT Region {
+    static const Region kWholeFile;
+
+    bool operator==(const Region& other) const;
+    bool operator!=(const Region& other) const;
+
+    // Start of the region (measured in bytes from the beginning of the file).
+    int64_t offset;
+
+    // Length of the region in bytes.
+    size_t size;
+  };
+
+  // Opens an existing file and maps it into memory. |access| can be read-only
+  // or read/write but not read/write+extend. If this object already points
+  // to a valid memory mapped file then this method will fail and return
+  // false. If it cannot open the file, the file does not exist, or the
+  // memory mapping fails, it will return false.
+  bool Initialize(const FilePath& file_name, Access access);
+  bool Initialize(const FilePath& file_name) {
+    return Initialize(file_name, READ_ONLY);
+  }
+
+  // As above, but works with an already-opened file. |access| can be read-only
+  // or read/write but not read/write+extend. MemoryMappedFile takes ownership
+  // of |file| and closes it when done. |file| must have been opened with
+  // permissions suitable for |access|. If the memory mapping fails, it will
+  // return false.
+  bool Initialize(File file, Access access);
+  bool Initialize(File file) {
+    return Initialize(std::move(file), READ_ONLY);
+  }
+
+  // As above, but works with a region of an already-opened file. All forms of
+  // |access| are allowed. If READ_WRITE_EXTEND is specified then |region|
+  // provides the maximum size of the file. If the memory mapping fails, it
+  // return false.
+  bool Initialize(File file, const Region& region, Access access);
+  bool Initialize(File file, const Region& region) {
+    return Initialize(std::move(file), region, READ_ONLY);
+  }
+
+  const uint8_t* data() const { return data_; }
+  uint8_t* data() { return data_; }
+  size_t length() const { return length_; }
+
+  // Is file_ a valid file handle that points to an open, memory mapped file?
+  bool IsValid() const;
+
+ private:
+  // Given the arbitrarily aligned memory region [start, size], returns the
+  // boundaries of the region aligned to the granularity specified by the OS,
+  // (a page on Linux, ~32k on Windows) as follows:
+  // - |aligned_start| is page aligned and <= |start|.
+  // - |aligned_size| is a multiple of the VM granularity and >= |size|.
+  // - |offset| is the displacement of |start| w.r.t |aligned_start|.
+  static void CalculateVMAlignedBoundaries(int64_t start,
+                                           size_t size,
+                                           int64_t* aligned_start,
+                                           size_t* aligned_size,
+                                           int32_t* offset);
+
+  // Map the file to memory, set data_ to that memory address. Return true on
+  // success, false on any kind of failure. This is a helper for Initialize().
+  bool MapFileRegionToMemory(const Region& region, Access access);
+
+  // Closes all open handles.
+  void CloseHandles();
+
+  File file_;
+  uint8_t* data_;
+  size_t length_;
+
+#if defined(OS_WIN)
+  win::ScopedHandle file_mapping_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(MemoryMappedFile);
+};
+
+}  // namespace base
+
+#endif  // BASE_FILES_MEMORY_MAPPED_FILE_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/platform_file.h b/native/zucchini/vendor/libchrome/base/files/platform_file.h
new file mode 100644
index 0000000..3929a0d
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/files/platform_file.h
@@ -0,0 +1,43 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_FILES_PLATFORM_FILE_H_
+#define BASE_FILES_PLATFORM_FILE_H_
+
+#include "base/files/scoped_file.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include "base/win/scoped_handle.h"
+#include "base/win/windows_types.h"
+#endif
+
+// This file defines platform-independent types for dealing with
+// platform-dependent files. If possible, use the higher-level base::File class
+// rather than these primitives.
+
+namespace base {
+
+#if defined(OS_WIN)
+
+using PlatformFile = HANDLE;
+using ScopedPlatformFile = ::base::win::ScopedHandle;
+
+// It would be nice to make this constexpr but INVALID_HANDLE_VALUE is a
+// ((void*)(-1)) which Clang rejects since reinterpret_cast is technically
+// disallowed in constexpr. Visual Studio accepts this, however.
+const PlatformFile kInvalidPlatformFile = INVALID_HANDLE_VALUE;
+
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+
+using PlatformFile = int;
+using ScopedPlatformFile = ::base::ScopedFD;
+
+constexpr PlatformFile kInvalidPlatformFile = -1;
+
+#endif
+
+}  // namespace
+
+#endif  // BASE_FILES_PLATFORM_FILE_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/scoped_file.h b/native/zucchini/vendor/libchrome/base/files/scoped_file.h
new file mode 100644
index 0000000..e32a603
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/files/scoped_file.h
@@ -0,0 +1,62 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_FILES_SCOPED_FILE_H_
+#define BASE_FILES_SCOPED_FILE_H_
+
+#include <stdio.h>
+
+#include <memory>
+
+#include "base/base_export.h"
+#include "base/logging.h"
+#include "base/scoped_generic.h"
+#include "build/build_config.h"
+
+namespace base {
+
+namespace internal {
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+struct BASE_EXPORT ScopedFDCloseTraits {
+  static int InvalidValue() {
+    return -1;
+  }
+  static void Free(int fd);
+};
+#endif
+
+// Functor for |ScopedFILE| (below).
+struct ScopedFILECloser {
+  inline void operator()(FILE* x) const {
+    if (x)
+      fclose(x);
+  }
+};
+
+}  // namespace internal
+
+// -----------------------------------------------------------------------------
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+// A low-level Posix file descriptor closer class. Use this when writing
+// platform-specific code, especially that does non-file-like things with the
+// FD (like sockets).
+//
+// If you're writing low-level Windows code, see base/win/scoped_handle.h
+// which provides some additional functionality.
+//
+// If you're writing cross-platform code that deals with actual files, you
+// should generally use base::File instead which can be constructed with a
+// handle, and in addition to handling ownership, has convenient cross-platform
+// file manipulation functions on it.
+typedef ScopedGeneric<int, internal::ScopedFDCloseTraits> ScopedFD;
+#endif
+
+// Automatically closes |FILE*|s.
+typedef std::unique_ptr<FILE, internal::ScopedFILECloser> ScopedFILE;
+
+}  // namespace base
+
+#endif  // BASE_FILES_SCOPED_FILE_H_
diff --git a/native/zucchini/vendor/libchrome/base/format_macros.h b/native/zucchini/vendor/libchrome/base/format_macros.h
new file mode 100644
index 0000000..1279ff7
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/format_macros.h
@@ -0,0 +1,97 @@
+// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_FORMAT_MACROS_H_
+#define BASE_FORMAT_MACROS_H_
+
+// This file defines the format macros for some integer types.
+
+// To print a 64-bit value in a portable way:
+//   int64_t value;
+//   printf("xyz:%" PRId64, value);
+// The "d" in the macro corresponds to %d; you can also use PRIu64 etc.
+//
+// For wide strings, prepend "Wide" to the macro:
+//   int64_t value;
+//   StringPrintf(L"xyz: %" WidePRId64, value);
+//
+// To print a size_t value in a portable way:
+//   size_t size;
+//   printf("xyz: %" PRIuS, size);
+// The "u" in the macro corresponds to %u, and S is for "size".
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "build/build_config.h"
+
+#if (defined(OS_POSIX) || defined(OS_FUCHSIA)) && \
+    (defined(_INTTYPES_H) || defined(_INTTYPES_H_)) && !defined(PRId64)
+#error "inttypes.h has already been included before this header file, but "
+#error "without __STDC_FORMAT_MACROS defined."
+#endif
+
+#if (defined(OS_POSIX) || defined(OS_FUCHSIA)) && !defined(__STDC_FORMAT_MACROS)
+#define __STDC_FORMAT_MACROS
+#endif
+
+#include <inttypes.h>
+
+#if defined(OS_WIN)
+
+#if !defined(PRId64) || !defined(PRIu64) || !defined(PRIx64)
+#error "inttypes.h provided by win toolchain should define these."
+#endif
+
+#define WidePRId64 L"I64d"
+#define WidePRIu64 L"I64u"
+#define WidePRIx64 L"I64x"
+
+#if !defined(PRIuS)
+#define PRIuS "Iu"
+#endif
+
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+
+// GCC will concatenate wide and narrow strings correctly, so nothing needs to
+// be done here.
+#define WidePRId64 PRId64
+#define WidePRIu64 PRIu64
+#define WidePRIx64 PRIx64
+
+#if !defined(PRIuS)
+#define PRIuS "zu"
+#endif
+
+#endif  // defined(OS_WIN)
+
+// The size of NSInteger and NSUInteger varies between 32-bit and 64-bit
+// architectures and Apple does not provides standard format macros and
+// recommends casting. This has many drawbacks, so instead define macros
+// for formatting those types.
+#if defined(OS_MACOSX)
+#if defined(ARCH_CPU_64_BITS)
+#if !defined(PRIdNS)
+#define PRIdNS "ld"
+#endif
+#if !defined(PRIuNS)
+#define PRIuNS "lu"
+#endif
+#if !defined(PRIxNS)
+#define PRIxNS "lx"
+#endif
+#else  // defined(ARCH_CPU_64_BITS)
+#if !defined(PRIdNS)
+#define PRIdNS "d"
+#endif
+#if !defined(PRIuNS)
+#define PRIuNS "u"
+#endif
+#if !defined(PRIxNS)
+#define PRIxNS "x"
+#endif
+#endif
+#endif  // defined(OS_MACOSX)
+
+#endif  // BASE_FORMAT_MACROS_H_
diff --git a/native/zucchini/vendor/libchrome/base/gtest_prod_util.h b/native/zucchini/vendor/libchrome/base/gtest_prod_util.h
new file mode 100644
index 0000000..2ca267e
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/gtest_prod_util.h
@@ -0,0 +1,66 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_GTEST_PROD_UTIL_H_
+#define BASE_GTEST_PROD_UTIL_H_
+
+#include "testing/gtest/include/gtest/gtest_prod.h"  // nogncheck
+
+// This is a wrapper for gtest's FRIEND_TEST macro that friends
+// test with all possible prefixes. This is very helpful when changing the test
+// prefix, because the friend declarations don't need to be updated.
+//
+// Example usage:
+//
+// class MyClass {
+//  private:
+//   void MyMethod();
+//   FRIEND_TEST_ALL_PREFIXES(MyClassTest, MyMethod);
+// };
+#define FRIEND_TEST_ALL_PREFIXES(test_case_name, test_name) \
+  FRIEND_TEST(test_case_name, test_name); \
+  FRIEND_TEST(test_case_name, DISABLED_##test_name); \
+  FRIEND_TEST(test_case_name, FLAKY_##test_name)
+
+// C++ compilers will refuse to compile the following code:
+//
+// namespace foo {
+// class MyClass {
+//  private:
+//   FRIEND_TEST_ALL_PREFIXES(MyClassTest, TestMethod);
+//   bool private_var;
+// };
+// }  // namespace foo
+//
+// class MyClassTest::TestMethod() {
+//   foo::MyClass foo_class;
+//   foo_class.private_var = true;
+// }
+//
+// Unless you forward declare MyClassTest::TestMethod outside of namespace foo.
+// Use FORWARD_DECLARE_TEST to do so for all possible prefixes.
+//
+// Example usage:
+//
+// FORWARD_DECLARE_TEST(MyClassTest, TestMethod);
+//
+// namespace foo {
+// class MyClass {
+//  private:
+//   FRIEND_TEST_ALL_PREFIXES(::MyClassTest, TestMethod);  // NOTE use of ::
+//   bool private_var;
+// };
+// }  // namespace foo
+//
+// class MyClassTest::TestMethod() {
+//   foo::MyClass foo_class;
+//   foo_class.private_var = true;
+// }
+
+#define FORWARD_DECLARE_TEST(test_case_name, test_name) \
+  class test_case_name##_##test_name##_Test; \
+  class test_case_name##_##DISABLED_##test_name##_Test; \
+  class test_case_name##_##FLAKY_##test_name##_Test
+
+#endif  // BASE_GTEST_PROD_UTIL_H_
diff --git a/native/zucchini/vendor/libchrome/base/hash.h b/native/zucchini/vendor/libchrome/base/hash.h
new file mode 100644
index 0000000..165899e
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/hash.h
@@ -0,0 +1,69 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_HASH_H_
+#define BASE_HASH_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <limits>
+#include <string>
+#include <utility>
+
+#include "base/base_export.h"
+#include "base/logging.h"
+#include "base/strings/string16.h"
+
+namespace base {
+
+// Computes a hash of a memory buffer. This hash function is subject to change
+// in the future, so use only for temporary in-memory structures. If you need
+// to persist a change on disk or between computers, use PersistentHash().
+//
+// WARNING: This hash function should not be used for any cryptographic purpose.
+BASE_EXPORT uint32_t Hash(const void* data, size_t length);
+BASE_EXPORT uint32_t Hash(const std::string& str);
+BASE_EXPORT uint32_t Hash(const string16& str);
+
+// Computes a hash of a memory buffer. This hash function must not change so
+// that code can use the hashed values for persistent storage purposes or
+// sending across the network. If a new persistent hash function is desired, a
+// new version will have to be added in addition.
+//
+// WARNING: This hash function should not be used for any cryptographic purpose.
+BASE_EXPORT uint32_t PersistentHash(const void* data, size_t length);
+BASE_EXPORT uint32_t PersistentHash(const std::string& str);
+
+// Hash pairs of 32-bit or 64-bit numbers.
+BASE_EXPORT size_t HashInts32(uint32_t value1, uint32_t value2);
+BASE_EXPORT size_t HashInts64(uint64_t value1, uint64_t value2);
+
+template <typename T1, typename T2>
+inline size_t HashInts(T1 value1, T2 value2) {
+  // This condition is expected to be compile-time evaluated and optimised away
+  // in release builds.
+  if (sizeof(T1) > sizeof(uint32_t) || (sizeof(T2) > sizeof(uint32_t)))
+    return HashInts64(value1, value2);
+
+  return HashInts32(value1, value2);
+}
+
+// A templated hasher for pairs of integer types. Example:
+//
+//   using MyPair = std::pair<int32_t, int32_t>;
+//   std::unordered_set<MyPair, base::IntPairHash<MyPair>> set;
+template <typename T>
+struct IntPairHash;
+
+template <typename Type1, typename Type2>
+struct IntPairHash<std::pair<Type1, Type2>> {
+  size_t operator()(std::pair<Type1, Type2> value) const {
+    return HashInts(value.first, value.second);
+  }
+};
+
+}  // namespace base
+
+#endif  // BASE_HASH_H_
diff --git a/native/zucchini/vendor/libchrome/base/lazy_instance.h b/native/zucchini/vendor/libchrome/base/lazy_instance.h
new file mode 100644
index 0000000..4449373
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/lazy_instance.h
@@ -0,0 +1,210 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DEPRECATED !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// Please don't introduce new instances of LazyInstance<T>. Use a function-local
+// static of type base::NoDestructor<T> instead:
+//
+// Factory& Factory::GetInstance() {
+//   static base::NoDestructor<Factory> instance;
+//   return *instance;
+// }
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+//
+// The LazyInstance<Type, Traits> class manages a single instance of Type,
+// which will be lazily created on the first time it's accessed.  This class is
+// useful for places you would normally use a function-level static, but you
+// need to have guaranteed thread-safety.  The Type constructor will only ever
+// be called once, even if two threads are racing to create the object.  Get()
+// and Pointer() will always return the same, completely initialized instance.
+// When the instance is constructed it is registered with AtExitManager.  The
+// destructor will be called on program exit.
+//
+// LazyInstance is completely thread safe, assuming that you create it safely.
+// The class was designed to be POD initialized, so it shouldn't require a
+// static constructor.  It really only makes sense to declare a LazyInstance as
+// a global variable using the LAZY_INSTANCE_INITIALIZER initializer.
+//
+// LazyInstance is similar to Singleton, except it does not have the singleton
+// property.  You can have multiple LazyInstance's of the same type, and each
+// will manage a unique instance.  It also preallocates the space for Type, as
+// to avoid allocating the Type instance on the heap.  This may help with the
+// performance of creating the instance, and reducing heap fragmentation.  This
+// requires that Type be a complete type so we can determine the size.
+//
+// Example usage:
+//   static LazyInstance<MyClass>::Leaky inst = LAZY_INSTANCE_INITIALIZER;
+//   void SomeMethod() {
+//     inst.Get().SomeMethod();  // MyClass::SomeMethod()
+//
+//     MyClass* ptr = inst.Pointer();
+//     ptr->DoDoDo();  // MyClass::DoDoDo
+//   }
+
+#ifndef BASE_LAZY_INSTANCE_H_
+#define BASE_LAZY_INSTANCE_H_
+
+#include <new>  // For placement new.
+
+#include "base/atomicops.h"
+#include "base/debug/leak_annotations.h"
+#include "base/lazy_instance_helpers.h"
+#include "base/logging.h"
+#include "base/threading/thread_restrictions.h"
+
+// LazyInstance uses its own struct initializer-list style static
+// initialization, which does not require a constructor.
+#define LAZY_INSTANCE_INITIALIZER {}
+
+namespace base {
+
+template <typename Type>
+struct LazyInstanceTraitsBase {
+  static Type* New(void* instance) {
+    DCHECK_EQ(reinterpret_cast<uintptr_t>(instance) & (alignof(Type) - 1), 0u);
+    // Use placement new to initialize our instance in our preallocated space.
+    // The parenthesis is very important here to force POD type initialization.
+    return new (instance) Type();
+  }
+
+  static void CallDestructor(Type* instance) {
+    // Explicitly call the destructor.
+    instance->~Type();
+  }
+};
+
+// We pull out some of the functionality into non-templated functions, so we
+// can implement the more complicated pieces out of line in the .cc file.
+namespace internal {
+
+// This traits class causes destruction the contained Type at process exit via
+// AtExitManager. This is probably generally not what you want. Instead, prefer
+// Leaky below.
+template <typename Type>
+struct DestructorAtExitLazyInstanceTraits {
+  static const bool kRegisterOnExit = true;
+#if DCHECK_IS_ON()
+  static const bool kAllowedToAccessOnNonjoinableThread = false;
+#endif
+
+  static Type* New(void* instance) {
+    return LazyInstanceTraitsBase<Type>::New(instance);
+  }
+
+  static void Delete(Type* instance) {
+    LazyInstanceTraitsBase<Type>::CallDestructor(instance);
+  }
+};
+
+// Use LazyInstance<T>::Leaky for a less-verbose call-site typedef; e.g.:
+// base::LazyInstance<T>::Leaky my_leaky_lazy_instance;
+// instead of:
+// base::LazyInstance<T, base::internal::LeakyLazyInstanceTraits<T> >
+// my_leaky_lazy_instance;
+// (especially when T is MyLongTypeNameImplClientHolderFactory).
+// Only use this internal::-qualified verbose form to extend this traits class
+// (depending on its implementation details).
+template <typename Type>
+struct LeakyLazyInstanceTraits {
+  static const bool kRegisterOnExit = false;
+#if DCHECK_IS_ON()
+  static const bool kAllowedToAccessOnNonjoinableThread = true;
+#endif
+
+  static Type* New(void* instance) {
+    ANNOTATE_SCOPED_MEMORY_LEAK;
+    return LazyInstanceTraitsBase<Type>::New(instance);
+  }
+  static void Delete(Type* instance) {
+  }
+};
+
+template <typename Type>
+struct ErrorMustSelectLazyOrDestructorAtExitForLazyInstance {};
+
+}  // namespace internal
+
+template <
+    typename Type,
+    typename Traits =
+        internal::ErrorMustSelectLazyOrDestructorAtExitForLazyInstance<Type>>
+class LazyInstance {
+ public:
+  // Do not define a destructor, as doing so makes LazyInstance a
+  // non-POD-struct. We don't want that because then a static initializer will
+  // be created to register the (empty) destructor with atexit() under MSVC, for
+  // example. We handle destruction of the contained Type class explicitly via
+  // the OnExit member function, where needed.
+  // ~LazyInstance() {}
+
+  // Convenience typedef to avoid having to repeat Type for leaky lazy
+  // instances.
+  typedef LazyInstance<Type, internal::LeakyLazyInstanceTraits<Type>> Leaky;
+  typedef LazyInstance<Type, internal::DestructorAtExitLazyInstanceTraits<Type>>
+      DestructorAtExit;
+
+  Type& Get() {
+    return *Pointer();
+  }
+
+  Type* Pointer() {
+#if DCHECK_IS_ON()
+    if (!Traits::kAllowedToAccessOnNonjoinableThread)
+      ThreadRestrictions::AssertSingletonAllowed();
+#endif
+
+    return subtle::GetOrCreateLazyPointer(
+        &private_instance_, &Traits::New, private_buf_,
+        Traits::kRegisterOnExit ? OnExit : nullptr, this);
+  }
+
+  // Returns true if the lazy instance has been created.  Unlike Get() and
+  // Pointer(), calling IsCreated() will not instantiate the object of Type.
+  bool IsCreated() {
+    // Return true (i.e. "created") if |private_instance_| is either being
+    // created right now (i.e. |private_instance_| has value of
+    // internal::kLazyInstanceStateCreating) or was already created (i.e.
+    // |private_instance_| has any other non-zero value).
+    return 0 != subtle::NoBarrier_Load(&private_instance_);
+  }
+
+  // MSVC gives a warning that the alignment expands the size of the
+  // LazyInstance struct to make the size a multiple of the alignment. This
+  // is expected in this case.
+#if defined(OS_WIN)
+#pragma warning(push)
+#pragma warning(disable: 4324)
+#endif
+
+  // Effectively private: member data is only public to allow the linker to
+  // statically initialize it and to maintain a POD class. DO NOT USE FROM
+  // OUTSIDE THIS CLASS.
+  subtle::AtomicWord private_instance_;
+
+  // Preallocated space for the Type instance.
+  alignas(Type) char private_buf_[sizeof(Type)];
+
+#if defined(OS_WIN)
+#pragma warning(pop)
+#endif
+
+ private:
+  Type* instance() {
+    return reinterpret_cast<Type*>(subtle::NoBarrier_Load(&private_instance_));
+  }
+
+  // Adapter function for use with AtExit.  This should be called single
+  // threaded, so don't synchronize across threads.
+  // Calling OnExit while the instance is in use by other threads is a mistake.
+  static void OnExit(void* lazy_instance) {
+    LazyInstance<Type, Traits>* me =
+        reinterpret_cast<LazyInstance<Type, Traits>*>(lazy_instance);
+    Traits::Delete(me->instance());
+    subtle::NoBarrier_Store(&me->private_instance_, 0);
+  }
+};
+
+}  // namespace base
+
+#endif  // BASE_LAZY_INSTANCE_H_
diff --git a/native/zucchini/vendor/libchrome/base/lazy_instance_helpers.cc b/native/zucchini/vendor/libchrome/base/lazy_instance_helpers.cc
new file mode 100644
index 0000000..7b9e0de
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/lazy_instance_helpers.cc
@@ -0,0 +1,64 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/lazy_instance_helpers.h"
+
+#include "base/at_exit.h"
+#include "base/atomicops.h"
+#include "base/threading/platform_thread.h"
+
+namespace base {
+namespace internal {
+
+bool NeedsLazyInstance(subtle::AtomicWord* state) {
+  // Try to create the instance, if we're the first, will go from 0 to
+  // kLazyInstanceStateCreating, otherwise we've already been beaten here.
+  // The memory access has no memory ordering as state 0 and
+  // kLazyInstanceStateCreating have no associated data (memory barriers are
+  // all about ordering of memory accesses to *associated* data).
+  if (subtle::NoBarrier_CompareAndSwap(state, 0, kLazyInstanceStateCreating) ==
+      0) {
+    // Caller must create instance
+    return true;
+  }
+
+  // It's either in the process of being created, or already created. Spin.
+  // The load has acquire memory ordering as a thread which sees
+  // state_ == STATE_CREATED needs to acquire visibility over
+  // the associated data (buf_). Pairing Release_Store is in
+  // CompleteLazyInstance().
+  if (subtle::Acquire_Load(state) == kLazyInstanceStateCreating) {
+    const base::TimeTicks start = base::TimeTicks::Now();
+    do {
+      const base::TimeDelta elapsed = base::TimeTicks::Now() - start;
+      // Spin with YieldCurrentThread for at most one ms - this ensures maximum
+      // responsiveness. After that spin with Sleep(1ms) so that we don't burn
+      // excessive CPU time - this also avoids infinite loops due to priority
+      // inversions (https://crbug.com/797129).
+      if (elapsed < TimeDelta::FromMilliseconds(1))
+        PlatformThread::YieldCurrentThread();
+      else
+        PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
+    } while (subtle::Acquire_Load(state) == kLazyInstanceStateCreating);
+  }
+  // Someone else created the instance.
+  return false;
+}
+
+void CompleteLazyInstance(subtle::AtomicWord* state,
+                          subtle::AtomicWord new_instance,
+                          void (*destructor)(void*),
+                          void* destructor_arg) {
+  // Instance is created, go from CREATING to CREATED (or reset it if
+  // |new_instance| is null). Releases visibility over |private_buf_| to
+  // readers. Pairing Acquire_Load is in NeedsLazyInstance().
+  subtle::Release_Store(state, new_instance);
+
+  // Make sure that the lazily instantiated object will get destroyed at exit.
+  if (new_instance && destructor)
+    AtExitManager::RegisterCallback(destructor, destructor_arg);
+}
+
+}  // namespace internal
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/lazy_instance_helpers.h b/native/zucchini/vendor/libchrome/base/lazy_instance_helpers.h
new file mode 100644
index 0000000..5a43d8b
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/lazy_instance_helpers.h
@@ -0,0 +1,101 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_LAZY_INSTANCE_INTERNAL_H_
+#define BASE_LAZY_INSTANCE_INTERNAL_H_
+
+#include "base/atomicops.h"
+#include "base/base_export.h"
+#include "base/logging.h"
+
+// Helper methods used by LazyInstance and a few other base APIs for thread-safe
+// lazy construction.
+
+namespace base {
+namespace internal {
+
+// Our AtomicWord doubles as a spinlock, where a value of
+// kLazyInstanceStateCreating means the spinlock is being held for creation.
+constexpr subtle::AtomicWord kLazyInstanceStateCreating = 1;
+
+// Helper for GetOrCreateLazyPointer(). Checks if instance needs to be created.
+// If so returns true otherwise if another thread has beat us, waits for
+// instance to be created and returns false.
+BASE_EXPORT bool NeedsLazyInstance(subtle::AtomicWord* state);
+
+// Helper for GetOrCreateLazyPointer(). After creating an instance, this is
+// called to register the dtor to be called at program exit and to update the
+// atomic state to hold the |new_instance|
+BASE_EXPORT void CompleteLazyInstance(subtle::AtomicWord* state,
+                                      subtle::AtomicWord new_instance,
+                                      void (*destructor)(void*),
+                                      void* destructor_arg);
+
+}  // namespace internal
+
+namespace subtle {
+
+// If |state| is uninitialized (zero), constructs a value using
+// |creator_func(creator_arg)|, stores it into |state| and registers
+// |destructor(destructor_arg)| to be called when the current AtExitManager goes
+// out of scope. Then, returns the value stored in |state|. It is safe to have
+// concurrent calls to this function with the same |state|. |creator_func| may
+// return nullptr if it doesn't want to create an instance anymore (e.g. on
+// shutdown), it is from then on required to return nullptr to all callers (ref.
+// StaticMemorySingletonTraits). In that case, callers need to synchronize
+// before |creator_func| may return a non-null instance again (ref.
+// StaticMemorySingletonTraits::ResurectForTesting()).
+// Implementation note on |creator_func/creator_arg|. It makes for ugly adapters
+// but it avoids redundant template instantiations (e.g. saves 27KB in
+// chrome.dll) because linker is able to fold these for multiple Types but
+// couldn't with the more advanced CreatorFunc template type which in turn
+// improves code locality (and application startup) -- ref.
+// https://chromium-review.googlesource.com/c/chromium/src/+/530984/5/base/lazy_instance.h#140,
+// worsened by https://chromium-review.googlesource.com/c/chromium/src/+/868013
+// and caught then as https://crbug.com/804034.
+template <typename Type>
+Type* GetOrCreateLazyPointer(subtle::AtomicWord* state,
+                             Type* (*creator_func)(void*),
+                             void* creator_arg,
+                             void (*destructor)(void*),
+                             void* destructor_arg) {
+  DCHECK(state);
+  DCHECK(creator_func);
+
+  // If any bit in the created mask is true, the instance has already been
+  // fully constructed.
+  constexpr subtle::AtomicWord kLazyInstanceCreatedMask =
+      ~internal::kLazyInstanceStateCreating;
+
+  // We will hopefully have fast access when the instance is already created.
+  // Since a thread sees |state| == 0 or kLazyInstanceStateCreating at most
+  // once, the load is taken out of NeedsLazyInstance() as a fast-path. The load
+  // has acquire memory ordering as a thread which sees |state| > creating needs
+  // to acquire visibility over the associated data. Pairing Release_Store is in
+  // CompleteLazyInstance().
+  subtle::AtomicWord instance = subtle::Acquire_Load(state);
+  if (!(instance & kLazyInstanceCreatedMask)) {
+    if (internal::NeedsLazyInstance(state)) {
+      // This thread won the race and is now responsible for creating the
+      // instance and storing it back into |state|.
+      instance =
+          reinterpret_cast<subtle::AtomicWord>((*creator_func)(creator_arg));
+      internal::CompleteLazyInstance(state, instance, destructor,
+                                     destructor_arg);
+    } else {
+      // This thread lost the race but now has visibility over the constructed
+      // instance (NeedsLazyInstance() doesn't return until the constructing
+      // thread releases the instance via CompleteLazyInstance()).
+      instance = subtle::Acquire_Load(state);
+      DCHECK(instance & kLazyInstanceCreatedMask);
+    }
+  }
+  return reinterpret_cast<Type*>(instance);
+}
+
+}  // namespace subtle
+
+}  // namespace base
+
+#endif  // BASE_LAZY_INSTANCE_INTERNAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/location.cc b/native/zucchini/vendor/libchrome/base/location.cc
new file mode 100644
index 0000000..8bbf6ed
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/location.cc
@@ -0,0 +1,77 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/location.h"
+
+#if defined(COMPILER_MSVC)
+#include <intrin.h>
+#endif
+
+#include "base/compiler_specific.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
+#include "build/build_config.h"
+
+namespace base {
+
+Location::Location() = default;
+Location::Location(const Location& other) = default;
+
+Location::Location(const char* file_name, const void* program_counter)
+    : file_name_(file_name), program_counter_(program_counter) {}
+
+Location::Location(const char* function_name,
+                   const char* file_name,
+                   int line_number,
+                   const void* program_counter)
+    : function_name_(function_name),
+      file_name_(file_name),
+      line_number_(line_number),
+      program_counter_(program_counter) {
+#if !defined(OS_NACL)
+  // The program counter should not be null except in a default constructed
+  // (empty) Location object. This value is used for identity, so if it doesn't
+  // uniquely identify a location, things will break.
+  //
+  // The program counter isn't supported in NaCl so location objects won't work
+  // properly in that context.
+  DCHECK(program_counter);
+#endif
+}
+
+std::string Location::ToString() const {
+  if (has_source_info()) {
+    return std::string(function_name_) + "@" + file_name_ + ":" +
+           IntToString(line_number_);
+  }
+  return StringPrintf("pc:%p", program_counter_);
+}
+
+#if defined(COMPILER_MSVC)
+#define RETURN_ADDRESS() _ReturnAddress()
+#elif defined(COMPILER_GCC) && !defined(OS_NACL)
+#define RETURN_ADDRESS() \
+  __builtin_extract_return_addr(__builtin_return_address(0))
+#else
+#define RETURN_ADDRESS() nullptr
+#endif
+
+// static
+NOINLINE Location Location::CreateFromHere(const char* file_name) {
+  return Location(file_name, RETURN_ADDRESS());
+}
+
+// static
+NOINLINE Location Location::CreateFromHere(const char* function_name,
+                                           const char* file_name,
+                                           int line_number) {
+  return Location(function_name, file_name, line_number, RETURN_ADDRESS());
+}
+
+//------------------------------------------------------------------------------
+NOINLINE const void* GetProgramCounter() {
+  return RETURN_ADDRESS();
+}
+
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/location.h b/native/zucchini/vendor/libchrome/base/location.h
new file mode 100644
index 0000000..14fe2fa
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/location.h
@@ -0,0 +1,117 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_LOCATION_H_
+#define BASE_LOCATION_H_
+
+#include <stddef.h>
+
+#include <cassert>
+#include <string>
+
+#include "base/base_export.h"
+#include "base/debug/debugging_buildflags.h"
+#include "base/hash.h"
+
+namespace base {
+
+// Location provides basic info where of an object was constructed, or was
+// significantly brought to life.
+class BASE_EXPORT Location {
+ public:
+  Location();
+  Location(const Location& other);
+
+  // Only initializes the file name and program counter, the source information
+  // will be null for the strings, and -1 for the line number.
+  // TODO(http://crbug.com/760702) remove file name from this constructor.
+  Location(const char* file_name, const void* program_counter);
+
+  // Constructor should be called with a long-lived char*, such as __FILE__.
+  // It assumes the provided value will persist as a global constant, and it
+  // will not make a copy of it.
+  Location(const char* function_name,
+           const char* file_name,
+           int line_number,
+           const void* program_counter);
+
+  // Comparator for hash map insertion. The program counter should uniquely
+  // identify a location.
+  bool operator==(const Location& other) const {
+    return program_counter_ == other.program_counter_;
+  }
+
+  // Returns true if there is source code location info. If this is false,
+  // the Location object only contains a program counter or is
+  // default-initialized (the program counter is also null).
+  bool has_source_info() const { return function_name_ && file_name_; }
+
+  // Will be nullptr for default initialized Location objects and when source
+  // names are disabled.
+  const char* function_name() const { return function_name_; }
+
+  // Will be nullptr for default initialized Location objects and when source
+  // names are disabled.
+  const char* file_name() const { return file_name_; }
+
+  // Will be -1 for default initialized Location objects and when source names
+  // are disabled.
+  int line_number() const { return line_number_; }
+
+  // The address of the code generating this Location object. Should always be
+  // valid except for default initialized Location objects, which will be
+  // nullptr.
+  const void* program_counter() const { return program_counter_; }
+
+  // Converts to the most user-readable form possible. If function and filename
+  // are not available, this will return "pc:<hex address>".
+  std::string ToString() const;
+
+  static Location CreateFromHere(const char* file_name);
+  static Location CreateFromHere(const char* function_name,
+                                 const char* file_name,
+                                 int line_number);
+
+ private:
+  const char* function_name_ = nullptr;
+  const char* file_name_ = nullptr;
+  int line_number_ = -1;
+  const void* program_counter_ = nullptr;
+};
+
+BASE_EXPORT const void* GetProgramCounter();
+
+// The macros defined here will expand to the current function.
+#if BUILDFLAG(ENABLE_LOCATION_SOURCE)
+
+// Full source information should be included.
+#define FROM_HERE FROM_HERE_WITH_EXPLICIT_FUNCTION(__func__)
+#define FROM_HERE_WITH_EXPLICIT_FUNCTION(function_name) \
+  ::base::Location::CreateFromHere(function_name, __FILE__, __LINE__)
+
+#else
+
+// TODO(http://crbug.com/760702) remove the __FILE__ argument from these calls.
+#define FROM_HERE ::base::Location::CreateFromHere(__FILE__)
+#define FROM_HERE_WITH_EXPLICIT_FUNCTION(function_name) \
+  ::base::Location::CreateFromHere(function_name, __FILE__, -1)
+
+#endif
+
+}  // namespace base
+
+namespace std {
+
+// Specialization for using Location in hash tables.
+template <>
+struct hash<::base::Location> {
+  std::size_t operator()(const ::base::Location& loc) const {
+    const void* program_counter = loc.program_counter();
+    return base::Hash(&program_counter, sizeof(void*));
+  }
+};
+
+}  // namespace std
+
+#endif  // BASE_LOCATION_H_
diff --git a/native/zucchini/vendor/libchrome/base/logging.cc b/native/zucchini/vendor/libchrome/base/logging.cc
new file mode 100644
index 0000000..5781c63
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/logging.cc
@@ -0,0 +1,1065 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/logging.h"
+
+#include <limits.h>
+#include <stdint.h>
+
+#include "base/macros.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include <io.h>
+#include <windows.h>
+typedef HANDLE FileHandle;
+typedef HANDLE MutexHandle;
+// Windows warns on using write().  It prefers _write().
+#define write(fd, buf, count) _write(fd, buf, static_cast<unsigned int>(count))
+// Windows doesn't define STDERR_FILENO.  Define it here.
+#define STDERR_FILENO 2
+
+#elif defined(OS_MACOSX)
+// In MacOS 10.12 and iOS 10.0 and later ASL (Apple System Log) was deprecated
+// in favor of OS_LOG (Unified Logging).
+#include <AvailabilityMacros.h>
+#if defined(OS_IOS)
+#if !defined(__IPHONE_10_0) || __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_10_0
+#define USE_ASL
+#endif
+#else  // !defined(OS_IOS)
+#if !defined(MAC_OS_X_VERSION_10_12) || \
+    MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_12
+#define USE_ASL
+#endif
+#endif  // defined(OS_IOS)
+
+#if defined(USE_ASL)
+#include <asl.h>
+#else
+#include <os/log.h>
+#endif
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+#include <mach-o/dyld.h>
+
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+#if defined(OS_NACL)
+#include <sys/time.h>  // timespec doesn't seem to be in <time.h>
+#endif
+#include <time.h>
+#endif
+
+#if defined(OS_FUCHSIA)
+#include <zircon/process.h>
+#include <zircon/syscalls.h>
+#endif
+
+#if defined(OS_ANDROID)
+#include <android/log.h>
+#endif
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+#include <errno.h>
+#include <paths.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#define MAX_PATH PATH_MAX
+typedef FILE* FileHandle;
+typedef pthread_mutex_t* MutexHandle;
+#endif
+
+#include <algorithm>
+#include <cstring>
+#include <ctime>
+#include <iomanip>
+#include <ostream>
+#include <string>
+#include <utility>
+
+#include "base/base_switches.h"
+#include "base/callback.h"
+#include "base/command_line.h"
+#include "base/containers/stack.h"
+#include "base/debug/activity_tracker.h"
+#include "base/debug/alias.h"
+#include "base/debug/debugger.h"
+#include "base/debug/stack_trace.h"
+#include "base/lazy_instance.h"
+#include "base/posix/eintr_wrapper.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/synchronization/lock_impl.h"
+#include "base/threading/platform_thread.h"
+#include "base/vlog.h"
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+#include "base/posix/safe_strerror.h"
+#endif
+
+namespace logging {
+
+namespace {
+
+VlogInfo* g_vlog_info = nullptr;
+VlogInfo* g_vlog_info_prev = nullptr;
+
+const char* const log_severity_names[] = {"INFO", "WARNING", "ERROR", "FATAL"};
+static_assert(LOG_NUM_SEVERITIES == arraysize(log_severity_names),
+              "Incorrect number of log_severity_names");
+
+const char* log_severity_name(int severity) {
+  if (severity >= 0 && severity < LOG_NUM_SEVERITIES)
+    return log_severity_names[severity];
+  return "UNKNOWN";
+}
+
+int g_min_log_level = 0;
+
+LoggingDestination g_logging_destination = LOG_DEFAULT;
+
+// For LOG_ERROR and above, always print to stderr.
+const int kAlwaysPrintErrorLevel = LOG_ERROR;
+
+// Which log file to use? This is initialized by InitLogging or
+// will be lazily initialized to the default value when it is
+// first needed.
+#if defined(OS_WIN)
+typedef std::wstring PathString;
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+typedef std::string PathString;
+#endif
+PathString* g_log_file_name = nullptr;
+
+// This file is lazily opened and the handle may be nullptr
+FileHandle g_log_file = nullptr;
+
+// What should be prepended to each message?
+bool g_log_process_id = false;
+bool g_log_thread_id = false;
+bool g_log_timestamp = true;
+bool g_log_tickcount = false;
+
+// Should we pop up fatal debug messages in a dialog?
+bool show_error_dialogs = false;
+
+// An assert handler override specified by the client to be called instead of
+// the debug message dialog and process termination. Assert handlers are stored
+// in stack to allow overriding and restoring.
+base::LazyInstance<base::stack<LogAssertHandlerFunction>>::Leaky
+    log_assert_handler_stack = LAZY_INSTANCE_INITIALIZER;
+
+// A log message handler that gets notified of every log message we process.
+LogMessageHandlerFunction log_message_handler = nullptr;
+
+// Helper functions to wrap platform differences.
+
+int32_t CurrentProcessId() {
+#if defined(OS_WIN)
+  return GetCurrentProcessId();
+#elif defined(OS_FUCHSIA)
+  zx_info_handle_basic_t basic = {};
+  zx_object_get_info(zx_process_self(), ZX_INFO_HANDLE_BASIC, &basic,
+                     sizeof(basic), nullptr, nullptr);
+  return basic.koid;
+#elif defined(OS_POSIX)
+  return getpid();
+#endif
+}
+
+uint64_t TickCount() {
+#if defined(OS_WIN)
+  return GetTickCount();
+#elif defined(OS_FUCHSIA)
+  return zx_clock_get(ZX_CLOCK_MONOTONIC) /
+         static_cast<zx_time_t>(base::Time::kNanosecondsPerMicrosecond);
+#elif defined(OS_MACOSX)
+  return mach_absolute_time();
+#elif defined(OS_NACL)
+  // NaCl sadly does not have _POSIX_TIMERS enabled in sys/features.h
+  // So we have to use clock() for now.
+  return clock();
+#elif defined(OS_POSIX)
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+
+  uint64_t absolute_micro = static_cast<int64_t>(ts.tv_sec) * 1000000 +
+                            static_cast<int64_t>(ts.tv_nsec) / 1000;
+
+  return absolute_micro;
+#endif
+}
+
+void DeleteFilePath(const PathString& log_name) {
+#if defined(OS_WIN)
+  DeleteFile(log_name.c_str());
+#elif defined(OS_NACL)
+  // Do nothing; unlink() isn't supported on NaCl.
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  unlink(log_name.c_str());
+#else
+#error Unsupported platform
+#endif
+}
+
+PathString GetDefaultLogFile() {
+#if defined(OS_WIN)
+  // On Windows we use the same path as the exe.
+  wchar_t module_name[MAX_PATH];
+  GetModuleFileName(nullptr, module_name, MAX_PATH);
+
+  PathString log_name = module_name;
+  PathString::size_type last_backslash = log_name.rfind('\\', log_name.size());
+  if (last_backslash != PathString::npos)
+    log_name.erase(last_backslash + 1);
+  log_name += L"debug.log";
+  return log_name;
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  // On other platforms we just use the current directory.
+  return PathString("debug.log");
+#endif
+}
+
+// We don't need locks on Windows for atomically appending to files. The OS
+// provides this functionality.
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+// This class acts as a wrapper for locking the logging files.
+// LoggingLock::Init() should be called from the main thread before any logging
+// is done. Then whenever logging, be sure to have a local LoggingLock
+// instance on the stack. This will ensure that the lock is unlocked upon
+// exiting the frame.
+// LoggingLocks can not be nested.
+class LoggingLock {
+ public:
+  LoggingLock() {
+    LockLogging();
+  }
+
+  ~LoggingLock() {
+    UnlockLogging();
+  }
+
+  static void Init(LogLockingState lock_log, const PathChar* new_log_file) {
+    if (initialized)
+      return;
+    lock_log_file = lock_log;
+
+    if (lock_log_file != LOCK_LOG_FILE)
+      log_lock = new base::internal::LockImpl();
+
+    initialized = true;
+  }
+
+ private:
+  static void LockLogging() {
+    if (lock_log_file == LOCK_LOG_FILE) {
+      pthread_mutex_lock(&log_mutex);
+    } else {
+      // use the lock
+      log_lock->Lock();
+    }
+  }
+
+  static void UnlockLogging() {
+    if (lock_log_file == LOCK_LOG_FILE) {
+      pthread_mutex_unlock(&log_mutex);
+    } else {
+      log_lock->Unlock();
+    }
+  }
+
+  // The lock is used if log file locking is false. It helps us avoid problems
+  // with multiple threads writing to the log file at the same time.  Use
+  // LockImpl directly instead of using Lock, because Lock makes logging calls.
+  static base::internal::LockImpl* log_lock;
+
+  // When we don't use a lock, we are using a global mutex. We need to do this
+  // because LockFileEx is not thread safe.
+  static pthread_mutex_t log_mutex;
+
+  static bool initialized;
+  static LogLockingState lock_log_file;
+};
+
+// static
+bool LoggingLock::initialized = false;
+// static
+base::internal::LockImpl* LoggingLock::log_lock = nullptr;
+// static
+LogLockingState LoggingLock::lock_log_file = LOCK_LOG_FILE;
+
+pthread_mutex_t LoggingLock::log_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+#endif  // OS_POSIX || OS_FUCHSIA
+
+// Called by logging functions to ensure that |g_log_file| is initialized
+// and can be used for writing. Returns false if the file could not be
+// initialized. |g_log_file| will be nullptr in this case.
+bool InitializeLogFileHandle() {
+  if (g_log_file)
+    return true;
+
+  if (!g_log_file_name) {
+    // Nobody has called InitLogging to specify a debug log file, so here we
+    // initialize the log file name to a default.
+    g_log_file_name = new PathString(GetDefaultLogFile());
+  }
+
+  if ((g_logging_destination & LOG_TO_FILE) != 0) {
+#if defined(OS_WIN)
+    // The FILE_APPEND_DATA access mask ensures that the file is atomically
+    // appended to across accesses from multiple threads.
+    // https://msdn.microsoft.com/en-us/library/windows/desktop/aa364399(v=vs.85).aspx
+    // https://msdn.microsoft.com/en-us/library/windows/desktop/aa363858(v=vs.85).aspx
+    g_log_file = CreateFile(g_log_file_name->c_str(), FILE_APPEND_DATA,
+                            FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
+                            OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (g_log_file == INVALID_HANDLE_VALUE || g_log_file == nullptr) {
+      // We are intentionally not using FilePath or FileUtil here to reduce the
+      // dependencies of the logging implementation. For e.g. FilePath and
+      // FileUtil depend on shell32 and user32.dll. This is not acceptable for
+      // some consumers of base logging like chrome_elf, etc.
+      // Please don't change the code below to use FilePath.
+      // try the current directory
+      wchar_t system_buffer[MAX_PATH];
+      system_buffer[0] = 0;
+      DWORD len = ::GetCurrentDirectory(arraysize(system_buffer),
+                                        system_buffer);
+      if (len == 0 || len > arraysize(system_buffer))
+        return false;
+
+      *g_log_file_name = system_buffer;
+      // Append a trailing backslash if needed.
+      if (g_log_file_name->back() != L'\\')
+        *g_log_file_name += L"\\";
+      *g_log_file_name += L"debug.log";
+
+      g_log_file = CreateFile(g_log_file_name->c_str(), FILE_APPEND_DATA,
+                              FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
+                              OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
+      if (g_log_file == INVALID_HANDLE_VALUE || g_log_file == nullptr) {
+        g_log_file = nullptr;
+        return false;
+      }
+    }
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+    g_log_file = fopen(g_log_file_name->c_str(), "a");
+    if (g_log_file == nullptr)
+      return false;
+#else
+#error Unsupported platform
+#endif
+  }
+
+  return true;
+}
+
+void CloseFile(FileHandle log) {
+#if defined(OS_WIN)
+  CloseHandle(log);
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  fclose(log);
+#else
+#error Unsupported platform
+#endif
+}
+
+void CloseLogFileUnlocked() {
+  if (!g_log_file)
+    return;
+
+  CloseFile(g_log_file);
+  g_log_file = nullptr;
+}
+
+}  // namespace
+
+#if DCHECK_IS_CONFIGURABLE
+// In DCHECK-enabled Chrome builds, allow the meaning of LOG_DCHECK to be
+// determined at run-time. We default it to INFO, to avoid it triggering
+// crashes before the run-time has explicitly chosen the behaviour.
+BASE_EXPORT logging::LogSeverity LOG_DCHECK = LOG_INFO;
+#endif  // DCHECK_IS_CONFIGURABLE
+
+// This is never instantiated, it's just used for EAT_STREAM_PARAMETERS to have
+// an object of the correct type on the LHS of the unused part of the ternary
+// operator.
+std::ostream* g_swallow_stream;
+
+LoggingSettings::LoggingSettings()
+    : logging_dest(LOG_DEFAULT),
+      log_file(nullptr),
+      lock_log(LOCK_LOG_FILE),
+      delete_old(APPEND_TO_OLD_LOG_FILE) {}
+
+bool BaseInitLoggingImpl(const LoggingSettings& settings) {
+#if defined(OS_NACL)
+  // Can log only to the system debug log.
+  CHECK_EQ(settings.logging_dest & ~LOG_TO_SYSTEM_DEBUG_LOG, 0);
+#endif
+  if (base::CommandLine::InitializedForCurrentProcess()) {
+    base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+    // Don't bother initializing |g_vlog_info| unless we use one of the
+    // vlog switches.
+    if (command_line->HasSwitch(switches::kV) ||
+        command_line->HasSwitch(switches::kVModule)) {
+      // NOTE: If |g_vlog_info| has already been initialized, it might be in use
+      // by another thread. Don't delete the old VLogInfo, just create a second
+      // one. We keep track of both to avoid memory leak warnings.
+      CHECK(!g_vlog_info_prev);
+      g_vlog_info_prev = g_vlog_info;
+
+      g_vlog_info =
+          new VlogInfo(command_line->GetSwitchValueASCII(switches::kV),
+                       command_line->GetSwitchValueASCII(switches::kVModule),
+                       &g_min_log_level);
+    }
+  }
+
+  g_logging_destination = settings.logging_dest;
+
+  // ignore file options unless logging to file is set.
+  if ((g_logging_destination & LOG_TO_FILE) == 0)
+    return true;
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+  LoggingLock::Init(settings.lock_log, settings.log_file);
+  LoggingLock logging_lock;
+#endif
+
+  // Calling InitLogging twice or after some log call has already opened the
+  // default log file will re-initialize to the new options.
+  CloseLogFileUnlocked();
+
+  if (!g_log_file_name)
+    g_log_file_name = new PathString();
+  *g_log_file_name = settings.log_file;
+  if (settings.delete_old == DELETE_OLD_LOG_FILE)
+    DeleteFilePath(*g_log_file_name);
+
+  return InitializeLogFileHandle();
+}
+
+void SetMinLogLevel(int level) {
+  g_min_log_level = std::min(LOG_FATAL, level);
+}
+
+int GetMinLogLevel() {
+  return g_min_log_level;
+}
+
+bool ShouldCreateLogMessage(int severity) {
+  if (severity < g_min_log_level)
+    return false;
+
+  // Return true here unless we know ~LogMessage won't do anything. Note that
+  // ~LogMessage writes to stderr if severity_ >= kAlwaysPrintErrorLevel, even
+  // when g_logging_destination is LOG_NONE.
+  return g_logging_destination != LOG_NONE || log_message_handler ||
+         severity >= kAlwaysPrintErrorLevel;
+}
+
+int GetVlogVerbosity() {
+  return std::max(-1, LOG_INFO - GetMinLogLevel());
+}
+
+int GetVlogLevelHelper(const char* file, size_t N) {
+  DCHECK_GT(N, 0U);
+  // Note: |g_vlog_info| may change on a different thread during startup
+  // (but will always be valid or nullptr).
+  VlogInfo* vlog_info = g_vlog_info;
+  return vlog_info ?
+      vlog_info->GetVlogLevel(base::StringPiece(file, N - 1)) :
+      GetVlogVerbosity();
+}
+
+void SetLogItems(bool enable_process_id, bool enable_thread_id,
+                 bool enable_timestamp, bool enable_tickcount) {
+  g_log_process_id = enable_process_id;
+  g_log_thread_id = enable_thread_id;
+  g_log_timestamp = enable_timestamp;
+  g_log_tickcount = enable_tickcount;
+}
+
+void SetShowErrorDialogs(bool enable_dialogs) {
+  show_error_dialogs = enable_dialogs;
+}
+
+ScopedLogAssertHandler::ScopedLogAssertHandler(
+    LogAssertHandlerFunction handler) {
+  log_assert_handler_stack.Get().push(std::move(handler));
+}
+
+ScopedLogAssertHandler::~ScopedLogAssertHandler() {
+  log_assert_handler_stack.Get().pop();
+}
+
+void SetLogMessageHandler(LogMessageHandlerFunction handler) {
+  log_message_handler = handler;
+}
+
+LogMessageHandlerFunction GetLogMessageHandler() {
+  return log_message_handler;
+}
+
+// Explicit instantiations for commonly used comparisons.
+template std::string* MakeCheckOpString<int, int>(
+    const int&, const int&, const char* names);
+template std::string* MakeCheckOpString<unsigned long, unsigned long>(
+    const unsigned long&, const unsigned long&, const char* names);
+template std::string* MakeCheckOpString<unsigned long, unsigned int>(
+    const unsigned long&, const unsigned int&, const char* names);
+template std::string* MakeCheckOpString<unsigned int, unsigned long>(
+    const unsigned int&, const unsigned long&, const char* names);
+template std::string* MakeCheckOpString<std::string, std::string>(
+    const std::string&, const std::string&, const char* name);
+
+void MakeCheckOpValueString(std::ostream* os, std::nullptr_t p) {
+  (*os) << "nullptr";
+}
+
+#if !defined(NDEBUG)
+// Displays a message box to the user with the error message in it.
+// Used for fatal messages, where we close the app simultaneously.
+// This is for developers only; we don't use this in circumstances
+// (like release builds) where users could see it, since users don't
+// understand these messages anyway.
+void DisplayDebugMessageInDialog(const std::string& str) {
+  if (str.empty())
+    return;
+
+  if (!show_error_dialogs)
+    return;
+
+#if defined(OS_WIN)
+  // We intentionally don't implement a dialog on other platforms.
+  // You can just look at stderr.
+  MessageBoxW(nullptr, base::UTF8ToUTF16(str).c_str(), L"Fatal error",
+              MB_OK | MB_ICONHAND | MB_TOPMOST);
+#endif  // defined(OS_WIN)
+}
+#endif  // !defined(NDEBUG)
+
+#if defined(OS_WIN)
+LogMessage::SaveLastError::SaveLastError() : last_error_(::GetLastError()) {
+}
+
+LogMessage::SaveLastError::~SaveLastError() {
+  ::SetLastError(last_error_);
+}
+#endif  // defined(OS_WIN)
+
+LogMessage::LogMessage(const char* file, int line, LogSeverity severity)
+    : severity_(severity), file_(file), line_(line) {
+  Init(file, line);
+}
+
+LogMessage::LogMessage(const char* file, int line, const char* condition)
+    : severity_(LOG_FATAL), file_(file), line_(line) {
+  Init(file, line);
+  stream_ << "Check failed: " << condition << ". ";
+}
+
+LogMessage::LogMessage(const char* file, int line, std::string* result)
+    : severity_(LOG_FATAL), file_(file), line_(line) {
+  Init(file, line);
+  stream_ << "Check failed: " << *result;
+  delete result;
+}
+
+LogMessage::LogMessage(const char* file, int line, LogSeverity severity,
+                       std::string* result)
+    : severity_(severity), file_(file), line_(line) {
+  Init(file, line);
+  stream_ << "Check failed: " << *result;
+  delete result;
+}
+
+LogMessage::~LogMessage() {
+  size_t stack_start = stream_.tellp();
+#if !defined(OFFICIAL_BUILD) && !defined(OS_NACL) && !defined(__UCLIBC__) && \
+    !defined(OS_AIX)
+  if (severity_ == LOG_FATAL && !base::debug::BeingDebugged()) {
+    // Include a stack trace on a fatal, unless a debugger is attached.
+    base::debug::StackTrace trace;
+    stream_ << std::endl;  // Newline to separate from log message.
+    trace.OutputToStream(&stream_);
+  }
+#endif
+  stream_ << std::endl;
+  std::string str_newline(stream_.str());
+
+  // Give any log message handler first dibs on the message.
+  if (log_message_handler &&
+      log_message_handler(severity_, file_, line_,
+                          message_start_, str_newline)) {
+    // The handler took care of it, no further processing.
+    return;
+  }
+
+  if ((g_logging_destination & LOG_TO_SYSTEM_DEBUG_LOG) != 0) {
+#if defined(OS_WIN)
+    OutputDebugStringA(str_newline.c_str());
+#elif defined(OS_MACOSX)
+    // In LOG_TO_SYSTEM_DEBUG_LOG mode, log messages are always written to
+    // stderr. If stderr is /dev/null, also log via ASL (Apple System Log) or
+    // its successor OS_LOG. If there's something weird about stderr, assume
+    // that log messages are going nowhere and log via ASL/OS_LOG too.
+    // Messages logged via ASL/OS_LOG show up in Console.app.
+    //
+    // Programs started by launchd, as UI applications normally are, have had
+    // stderr connected to /dev/null since OS X 10.8. Prior to that, stderr was
+    // a pipe to launchd, which logged what it received (see log_redirect_fd in
+    // 10.7.5 launchd-392.39/launchd/src/launchd_core_logic.c).
+    //
+    // Another alternative would be to determine whether stderr is a pipe to
+    // launchd and avoid logging via ASL only in that case. See 10.7.5
+    // CF-635.21/CFUtilities.c also_do_stderr(). This would result in logging to
+    // both stderr and ASL/OS_LOG even in tests, where it's undesirable to log
+    // to the system log at all.
+    //
+    // Note that the ASL client by default discards messages whose levels are
+    // below ASL_LEVEL_NOTICE. It's possible to change that with
+    // asl_set_filter(), but this is pointless because syslogd normally applies
+    // the same filter.
+    const bool log_to_system = []() {
+      struct stat stderr_stat;
+      if (fstat(fileno(stderr), &stderr_stat) == -1) {
+        return true;
+      }
+      if (!S_ISCHR(stderr_stat.st_mode)) {
+        return false;
+      }
+
+      struct stat dev_null_stat;
+      if (stat(_PATH_DEVNULL, &dev_null_stat) == -1) {
+        return true;
+      }
+
+      return !S_ISCHR(dev_null_stat.st_mode) ||
+             stderr_stat.st_rdev == dev_null_stat.st_rdev;
+    }();
+
+    if (log_to_system) {
+      // Log roughly the same way that CFLog() and NSLog() would. See 10.10.5
+      // CF-1153.18/CFUtilities.c __CFLogCString().
+      CFBundleRef main_bundle = CFBundleGetMainBundle();
+      CFStringRef main_bundle_id_cf =
+          main_bundle ? CFBundleGetIdentifier(main_bundle) : nullptr;
+      std::string main_bundle_id =
+          main_bundle_id_cf ? base::SysCFStringRefToUTF8(main_bundle_id_cf)
+                            : std::string("");
+#if defined(USE_ASL)
+      // The facility is set to the main bundle ID if available. Otherwise,
+      // "com.apple.console" is used.
+      const class ASLClient {
+       public:
+        explicit ASLClient(const std::string& facility)
+            : client_(asl_open(nullptr, facility.c_str(), ASL_OPT_NO_DELAY)) {}
+        ~ASLClient() { asl_close(client_); }
+
+        aslclient get() const { return client_; }
+
+       private:
+        aslclient client_;
+        DISALLOW_COPY_AND_ASSIGN(ASLClient);
+      } asl_client(main_bundle_id.empty() ? main_bundle_id
+                                          : "com.apple.console");
+
+      const class ASLMessage {
+       public:
+        ASLMessage() : message_(asl_new(ASL_TYPE_MSG)) {}
+        ~ASLMessage() { asl_free(message_); }
+
+        aslmsg get() const { return message_; }
+
+       private:
+        aslmsg message_;
+        DISALLOW_COPY_AND_ASSIGN(ASLMessage);
+      } asl_message;
+
+      // By default, messages are only readable by the admin group. Explicitly
+      // make them readable by the user generating the messages.
+      char euid_string[12];
+      snprintf(euid_string, arraysize(euid_string), "%d", geteuid());
+      asl_set(asl_message.get(), ASL_KEY_READ_UID, euid_string);
+
+      // Map Chrome log severities to ASL log levels.
+      const char* const asl_level_string = [](LogSeverity severity) {
+        // ASL_LEVEL_* are ints, but ASL needs equivalent strings. This
+        // non-obvious two-step macro trick achieves what's needed.
+        // https://gcc.gnu.org/onlinedocs/cpp/Stringification.html
+#define ASL_LEVEL_STR(level) ASL_LEVEL_STR_X(level)
+#define ASL_LEVEL_STR_X(level) #level
+        switch (severity) {
+          case LOG_INFO:
+            return ASL_LEVEL_STR(ASL_LEVEL_INFO);
+          case LOG_WARNING:
+            return ASL_LEVEL_STR(ASL_LEVEL_WARNING);
+          case LOG_ERROR:
+            return ASL_LEVEL_STR(ASL_LEVEL_ERR);
+          case LOG_FATAL:
+            return ASL_LEVEL_STR(ASL_LEVEL_CRIT);
+          default:
+            return severity < 0 ? ASL_LEVEL_STR(ASL_LEVEL_DEBUG)
+                                : ASL_LEVEL_STR(ASL_LEVEL_NOTICE);
+        }
+#undef ASL_LEVEL_STR
+#undef ASL_LEVEL_STR_X
+      }(severity_);
+      asl_set(asl_message.get(), ASL_KEY_LEVEL, asl_level_string);
+
+      asl_set(asl_message.get(), ASL_KEY_MSG, str_newline.c_str());
+
+      asl_send(asl_client.get(), asl_message.get());
+#else   // !defined(USE_ASL)
+      const class OSLog {
+       public:
+        explicit OSLog(const char* subsystem)
+            : os_log_(subsystem ? os_log_create(subsystem, "chromium_logging")
+                                : OS_LOG_DEFAULT) {}
+        ~OSLog() {
+          if (os_log_ != OS_LOG_DEFAULT) {
+            os_release(os_log_);
+          }
+        }
+        os_log_t get() const { return os_log_; }
+
+       private:
+        os_log_t os_log_;
+        DISALLOW_COPY_AND_ASSIGN(OSLog);
+      } log(main_bundle_id.empty() ? nullptr : main_bundle_id.c_str());
+      const os_log_type_t os_log_type = [](LogSeverity severity) {
+        switch (severity) {
+          case LOG_INFO:
+            return OS_LOG_TYPE_INFO;
+          case LOG_WARNING:
+            return OS_LOG_TYPE_DEFAULT;
+          case LOG_ERROR:
+            return OS_LOG_TYPE_ERROR;
+          case LOG_FATAL:
+            return OS_LOG_TYPE_FAULT;
+          default:
+            return severity < 0 ? OS_LOG_TYPE_DEBUG : OS_LOG_TYPE_DEFAULT;
+        }
+      }(severity_);
+      os_log_with_type(log.get(), os_log_type, "%{public}s",
+                       str_newline.c_str());
+#endif  // defined(USE_ASL)
+    }
+#elif defined(OS_ANDROID)
+    android_LogPriority priority =
+        (severity_ < 0) ? ANDROID_LOG_VERBOSE : ANDROID_LOG_UNKNOWN;
+    switch (severity_) {
+      case LOG_INFO:
+        priority = ANDROID_LOG_INFO;
+        break;
+      case LOG_WARNING:
+        priority = ANDROID_LOG_WARN;
+        break;
+      case LOG_ERROR:
+        priority = ANDROID_LOG_ERROR;
+        break;
+      case LOG_FATAL:
+        priority = ANDROID_LOG_FATAL;
+        break;
+    }
+#if 0 // This is for building Chromium browser on Android.
+    __android_log_write(priority, "chromium", str_newline.c_str());
+#else
+    __android_log_write(
+        priority,
+        base::CommandLine::InitializedForCurrentProcess() ?
+            base::CommandLine::ForCurrentProcess()->
+                GetProgram().BaseName().value().c_str() : nullptr,
+        str_newline.c_str());
+#endif  // 0
+#endif  // defined(OS_ANDROID)
+    ignore_result(fwrite(str_newline.data(), str_newline.size(), 1, stderr));
+    fflush(stderr);
+  } else if (severity_ >= kAlwaysPrintErrorLevel) {
+    // When we're only outputting to a log file, above a certain log level, we
+    // should still output to stderr so that we can better detect and diagnose
+    // problems with unit tests, especially on the buildbots.
+    ignore_result(fwrite(str_newline.data(), str_newline.size(), 1, stderr));
+    fflush(stderr);
+  }
+
+  // write to log file
+  if ((g_logging_destination & LOG_TO_FILE) != 0) {
+    // We can have multiple threads and/or processes, so try to prevent them
+    // from clobbering each other's writes.
+    // If the client app did not call InitLogging, and the lock has not
+    // been created do it now. We do this on demand, but if two threads try
+    // to do this at the same time, there will be a race condition to create
+    // the lock. This is why InitLogging should be called from the main
+    // thread at the beginning of execution.
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+    LoggingLock::Init(LOCK_LOG_FILE, nullptr);
+    LoggingLock logging_lock;
+#endif
+    if (InitializeLogFileHandle()) {
+#if defined(OS_WIN)
+      DWORD num_written;
+      WriteFile(g_log_file,
+                static_cast<const void*>(str_newline.c_str()),
+                static_cast<DWORD>(str_newline.length()),
+                &num_written,
+                nullptr);
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+      ignore_result(fwrite(
+          str_newline.data(), str_newline.size(), 1, g_log_file));
+      fflush(g_log_file);
+#else
+#error Unsupported platform
+#endif
+    }
+  }
+
+  if (severity_ == LOG_FATAL) {
+    // Write the log message to the global activity tracker, if running.
+    base::debug::GlobalActivityTracker* tracker =
+        base::debug::GlobalActivityTracker::Get();
+    if (tracker)
+      tracker->RecordLogMessage(str_newline);
+
+    // Ensure the first characters of the string are on the stack so they
+    // are contained in minidumps for diagnostic purposes.
+    DEBUG_ALIAS_FOR_CSTR(str_stack, str_newline.c_str(), 1024);
+
+    if (log_assert_handler_stack.IsCreated() &&
+        !log_assert_handler_stack.Get().empty()) {
+      LogAssertHandlerFunction log_assert_handler =
+          log_assert_handler_stack.Get().top();
+
+      if (log_assert_handler) {
+        log_assert_handler.Run(
+            file_, line_,
+            base::StringPiece(str_newline.c_str() + message_start_,
+                              stack_start - message_start_),
+            base::StringPiece(str_newline.c_str() + stack_start));
+      }
+    } else {
+      // Don't use the string with the newline, get a fresh version to send to
+      // the debug message process. We also don't display assertions to the
+      // user in release mode. The enduser can't do anything with this
+      // information, and displaying message boxes when the application is
+      // hosed can cause additional problems.
+#ifndef NDEBUG
+      if (!base::debug::BeingDebugged()) {
+        // Displaying a dialog is unnecessary when debugging and can complicate
+        // debugging.
+        DisplayDebugMessageInDialog(stream_.str());
+      }
+#endif
+      // Crash the process to generate a dump.
+      base::debug::BreakDebugger();
+    }
+  }
+}
+
+// writes the common header info to the stream
+void LogMessage::Init(const char* file, int line) {
+  base::StringPiece filename(file);
+  size_t last_slash_pos = filename.find_last_of("\\/");
+  if (last_slash_pos != base::StringPiece::npos)
+    filename.remove_prefix(last_slash_pos + 1);
+
+  // TODO(darin): It might be nice if the columns were fixed width.
+
+  stream_ <<  '[';
+  if (g_log_process_id)
+    stream_ << CurrentProcessId() << ':';
+  if (g_log_thread_id)
+    stream_ << base::PlatformThread::CurrentId() << ':';
+  if (g_log_timestamp) {
+#if defined(OS_WIN)
+    SYSTEMTIME local_time;
+    GetLocalTime(&local_time);
+    stream_ << std::setfill('0')
+            << std::setw(2) << local_time.wMonth
+            << std::setw(2) << local_time.wDay
+            << '/'
+            << std::setw(2) << local_time.wHour
+            << std::setw(2) << local_time.wMinute
+            << std::setw(2) << local_time.wSecond
+            << '.'
+            << std::setw(3)
+            << local_time.wMilliseconds
+            << ':';
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+    timeval tv;
+    gettimeofday(&tv, nullptr);
+    time_t t = tv.tv_sec;
+    struct tm local_time;
+    localtime_r(&t, &local_time);
+    struct tm* tm_time = &local_time;
+    stream_ << std::setfill('0')
+            << std::setw(2) << 1 + tm_time->tm_mon
+            << std::setw(2) << tm_time->tm_mday
+            << '/'
+            << std::setw(2) << tm_time->tm_hour
+            << std::setw(2) << tm_time->tm_min
+            << std::setw(2) << tm_time->tm_sec
+            << '.'
+            << std::setw(6) << tv.tv_usec
+            << ':';
+#else
+#error Unsupported platform
+#endif
+  }
+  if (g_log_tickcount)
+    stream_ << TickCount() << ':';
+  if (severity_ >= 0)
+    stream_ << log_severity_name(severity_);
+  else
+    stream_ << "VERBOSE" << -severity_;
+
+  stream_ << ":" << filename << "(" << line << ")] ";
+
+  message_start_ = stream_.str().length();
+}
+
+#if defined(OS_WIN)
+// This has already been defined in the header, but defining it again as DWORD
+// ensures that the type used in the header is equivalent to DWORD. If not,
+// the redefinition is a compile error.
+typedef DWORD SystemErrorCode;
+#endif
+
+SystemErrorCode GetLastSystemErrorCode() {
+#if defined(OS_WIN)
+  return ::GetLastError();
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  return errno;
+#endif
+}
+
+BASE_EXPORT std::string SystemErrorCodeToString(SystemErrorCode error_code) {
+#if defined(OS_WIN)
+  const int kErrorMessageBufferSize = 256;
+  char msgbuf[kErrorMessageBufferSize];
+  DWORD flags = FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS;
+  DWORD len = FormatMessageA(flags, nullptr, error_code, 0, msgbuf,
+                             arraysize(msgbuf), nullptr);
+  if (len) {
+    // Messages returned by system end with line breaks.
+    return base::CollapseWhitespaceASCII(msgbuf, true) +
+           base::StringPrintf(" (0x%lX)", error_code);
+  }
+  return base::StringPrintf("Error (0x%lX) while retrieving error. (0x%lX)",
+                            GetLastError(), error_code);
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  return base::safe_strerror(error_code) +
+         base::StringPrintf(" (%d)", error_code);
+#endif  // defined(OS_WIN)
+}
+
+
+#if defined(OS_WIN)
+Win32ErrorLogMessage::Win32ErrorLogMessage(const char* file,
+                                           int line,
+                                           LogSeverity severity,
+                                           SystemErrorCode err)
+    : err_(err),
+      log_message_(file, line, severity) {
+}
+
+Win32ErrorLogMessage::~Win32ErrorLogMessage() {
+  stream() << ": " << SystemErrorCodeToString(err_);
+  // We're about to crash (CHECK). Put |err_| on the stack (by placing it in a
+  // field) and use Alias in hopes that it makes it into crash dumps.
+  DWORD last_error = err_;
+  base::debug::Alias(&last_error);
+}
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+ErrnoLogMessage::ErrnoLogMessage(const char* file,
+                                 int line,
+                                 LogSeverity severity,
+                                 SystemErrorCode err)
+    : err_(err),
+      log_message_(file, line, severity) {
+}
+
+ErrnoLogMessage::~ErrnoLogMessage() {
+  stream() << ": " << SystemErrorCodeToString(err_);
+  // We're about to crash (CHECK). Put |err_| on the stack (by placing it in a
+  // field) and use Alias in hopes that it makes it into crash dumps.
+  int last_error = err_;
+  base::debug::Alias(&last_error);
+}
+#endif  // defined(OS_WIN)
+
+void CloseLogFile() {
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+  LoggingLock logging_lock;
+#endif
+  CloseLogFileUnlocked();
+}
+
+void RawLog(int level, const char* message) {
+  if (level >= g_min_log_level && message) {
+    size_t bytes_written = 0;
+    const size_t message_len = strlen(message);
+    int rv;
+    while (bytes_written < message_len) {
+      rv = HANDLE_EINTR(
+          write(STDERR_FILENO, message + bytes_written,
+                message_len - bytes_written));
+      if (rv < 0) {
+        // Give up, nothing we can do now.
+        break;
+      }
+      bytes_written += rv;
+    }
+
+    if (message_len > 0 && message[message_len - 1] != '\n') {
+      do {
+        rv = HANDLE_EINTR(write(STDERR_FILENO, "\n", 1));
+        if (rv < 0) {
+          // Give up, nothing we can do now.
+          break;
+        }
+      } while (rv != 1);
+    }
+  }
+
+  if (level == LOG_FATAL)
+    base::debug::BreakDebugger();
+}
+
+// This was defined at the beginning of this file.
+#undef write
+
+#if defined(OS_WIN)
+bool IsLoggingToFileEnabled() {
+  return g_logging_destination & LOG_TO_FILE;
+}
+
+std::wstring GetLogFileFullPath() {
+  if (g_log_file_name)
+    return *g_log_file_name;
+  return std::wstring();
+}
+#endif
+
+BASE_EXPORT void LogErrorNotReached(const char* file, int line) {
+  LogMessage(file, line, LOG_ERROR).stream()
+      << "NOTREACHED() hit.";
+}
+
+}  // namespace logging
+
+std::ostream& std::operator<<(std::ostream& out, const wchar_t* wstr) {
+  return out << (wstr ? base::WideToUTF8(wstr) : std::string());
+}
diff --git a/native/zucchini/vendor/libchrome/base/logging.h b/native/zucchini/vendor/libchrome/base/logging.h
new file mode 100644
index 0000000..08c1f0f
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/logging.h
@@ -0,0 +1,1179 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_LOGGING_H_
+#define BASE_LOGGING_H_
+
+#include <stddef.h>
+
+#include <cassert>
+#include <cstring>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "base/base_export.h"
+#include "base/callback_forward.h"
+#include "base/compiler_specific.h"
+#include "base/debug/debugger.h"
+#include "base/macros.h"
+#include "base/strings/string_piece_forward.h"
+#include "base/template_util.h"
+#include "build/build_config.h"
+
+//
+// Optional message capabilities
+// -----------------------------
+// Assertion failed messages and fatal errors are displayed in a dialog box
+// before the application exits. However, running this UI creates a message
+// loop, which causes application messages to be processed and potentially
+// dispatched to existing application windows. Since the application is in a
+// bad state when this assertion dialog is displayed, these messages may not
+// get processed and hang the dialog, or the application might go crazy.
+//
+// Therefore, it can be beneficial to display the error dialog in a separate
+// process from the main application. When the logging system needs to display
+// a fatal error dialog box, it will look for a program called
+// "DebugMessage.exe" in the same directory as the application executable. It
+// will run this application with the message as the command line, and will
+// not include the name of the application as is traditional for easier
+// parsing.
+//
+// The code for DebugMessage.exe is only one line. In WinMain, do:
+//   MessageBox(NULL, GetCommandLineW(), L"Fatal Error", 0);
+//
+// If DebugMessage.exe is not found, the logging code will use a normal
+// MessageBox, potentially causing the problems discussed above.
+
+
+// Instructions
+// ------------
+//
+// Make a bunch of macros for logging.  The way to log things is to stream
+// things to LOG(<a particular severity level>).  E.g.,
+//
+//   LOG(INFO) << "Found " << num_cookies << " cookies";
+//
+// You can also do conditional logging:
+//
+//   LOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
+//
+// The CHECK(condition) macro is active in both debug and release builds and
+// effectively performs a LOG(FATAL) which terminates the process and
+// generates a crashdump unless a debugger is attached.
+//
+// There are also "debug mode" logging macros like the ones above:
+//
+//   DLOG(INFO) << "Found cookies";
+//
+//   DLOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
+//
+// All "debug mode" logging is compiled away to nothing for non-debug mode
+// compiles.  LOG_IF and development flags also work well together
+// because the code can be compiled away sometimes.
+//
+// We also have
+//
+//   LOG_ASSERT(assertion);
+//   DLOG_ASSERT(assertion);
+//
+// which is syntactic sugar for {,D}LOG_IF(FATAL, assert fails) << assertion;
+//
+// There are "verbose level" logging macros.  They look like
+//
+//   VLOG(1) << "I'm printed when you run the program with --v=1 or more";
+//   VLOG(2) << "I'm printed when you run the program with --v=2 or more";
+//
+// These always log at the INFO log level (when they log at all).
+// The verbose logging can also be turned on module-by-module.  For instance,
+//    --vmodule=profile=2,icon_loader=1,browser_*=3,*/chromeos/*=4 --v=0
+// will cause:
+//   a. VLOG(2) and lower messages to be printed from profile.{h,cc}
+//   b. VLOG(1) and lower messages to be printed from icon_loader.{h,cc}
+//   c. VLOG(3) and lower messages to be printed from files prefixed with
+//      "browser"
+//   d. VLOG(4) and lower messages to be printed from files under a
+//     "chromeos" directory.
+//   e. VLOG(0) and lower messages to be printed from elsewhere
+//
+// The wildcarding functionality shown by (c) supports both '*' (match
+// 0 or more characters) and '?' (match any single character)
+// wildcards.  Any pattern containing a forward or backward slash will
+// be tested against the whole pathname and not just the module.
+// E.g., "*/foo/bar/*=2" would change the logging level for all code
+// in source files under a "foo/bar" directory.
+//
+// There's also VLOG_IS_ON(n) "verbose level" condition macro. To be used as
+//
+//   if (VLOG_IS_ON(2)) {
+//     // do some logging preparation and logging
+//     // that can't be accomplished with just VLOG(2) << ...;
+//   }
+//
+// There is also a VLOG_IF "verbose level" condition macro for sample
+// cases, when some extra computation and preparation for logs is not
+// needed.
+//
+//   VLOG_IF(1, (size > 1024))
+//      << "I'm printed when size is more than 1024 and when you run the "
+//         "program with --v=1 or more";
+//
+// We also override the standard 'assert' to use 'DLOG_ASSERT'.
+//
+// Lastly, there is:
+//
+//   PLOG(ERROR) << "Couldn't do foo";
+//   DPLOG(ERROR) << "Couldn't do foo";
+//   PLOG_IF(ERROR, cond) << "Couldn't do foo";
+//   DPLOG_IF(ERROR, cond) << "Couldn't do foo";
+//   PCHECK(condition) << "Couldn't do foo";
+//   DPCHECK(condition) << "Couldn't do foo";
+//
+// which append the last system error to the message in string form (taken from
+// GetLastError() on Windows and errno on POSIX).
+//
+// The supported severity levels for macros that allow you to specify one
+// are (in increasing order of severity) INFO, WARNING, ERROR, and FATAL.
+//
+// Very important: logging a message at the FATAL severity level causes
+// the program to terminate (after the message is logged).
+//
+// There is the special severity of DFATAL, which logs FATAL in debug mode,
+// ERROR in normal mode.
+
+namespace logging {
+
+// TODO(avi): do we want to do a unification of character types here?
+#if defined(OS_WIN)
+typedef wchar_t PathChar;
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+typedef char PathChar;
+#endif
+
+// Where to record logging output? A flat file and/or system debug log
+// via OutputDebugString.
+enum LoggingDestination {
+  LOG_NONE                = 0,
+  LOG_TO_FILE             = 1 << 0,
+  LOG_TO_SYSTEM_DEBUG_LOG = 1 << 1,
+
+  LOG_TO_ALL = LOG_TO_FILE | LOG_TO_SYSTEM_DEBUG_LOG,
+
+  // On Windows, use a file next to the exe; on POSIX platforms, where
+  // it may not even be possible to locate the executable on disk, use
+  // stderr.
+#if defined(OS_WIN)
+  LOG_DEFAULT = LOG_TO_FILE,
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  LOG_DEFAULT = LOG_TO_SYSTEM_DEBUG_LOG,
+#endif
+};
+
+// Indicates that the log file should be locked when being written to.
+// Unless there is only one single-threaded process that is logging to
+// the log file, the file should be locked during writes to make each
+// log output atomic. Other writers will block.
+//
+// All processes writing to the log file must have their locking set for it to
+// work properly. Defaults to LOCK_LOG_FILE.
+enum LogLockingState { LOCK_LOG_FILE, DONT_LOCK_LOG_FILE };
+
+// On startup, should we delete or append to an existing log file (if any)?
+// Defaults to APPEND_TO_OLD_LOG_FILE.
+enum OldFileDeletionState { DELETE_OLD_LOG_FILE, APPEND_TO_OLD_LOG_FILE };
+
+struct BASE_EXPORT LoggingSettings {
+  // The defaults values are:
+  //
+  //  logging_dest: LOG_DEFAULT
+  //  log_file:     NULL
+  //  lock_log:     LOCK_LOG_FILE
+  //  delete_old:   APPEND_TO_OLD_LOG_FILE
+  LoggingSettings();
+
+  LoggingDestination logging_dest;
+
+  // The three settings below have an effect only when LOG_TO_FILE is
+  // set in |logging_dest|.
+  const PathChar* log_file;
+  LogLockingState lock_log;
+  OldFileDeletionState delete_old;
+};
+
+// Define different names for the BaseInitLoggingImpl() function depending on
+// whether NDEBUG is defined or not so that we'll fail to link if someone tries
+// to compile logging.cc with NDEBUG but includes logging.h without defining it,
+// or vice versa.
+#if defined(NDEBUG)
+#define BaseInitLoggingImpl BaseInitLoggingImpl_built_with_NDEBUG
+#else
+#define BaseInitLoggingImpl BaseInitLoggingImpl_built_without_NDEBUG
+#endif
+
+// Implementation of the InitLogging() method declared below.  We use a
+// more-specific name so we can #define it above without affecting other code
+// that has named stuff "InitLogging".
+BASE_EXPORT bool BaseInitLoggingImpl(const LoggingSettings& settings);
+
+// Sets the log file name and other global logging state. Calling this function
+// is recommended, and is normally done at the beginning of application init.
+// If you don't call it, all the flags will be initialized to their default
+// values, and there is a race condition that may leak a critical section
+// object if two threads try to do the first log at the same time.
+// See the definition of the enums above for descriptions and default values.
+//
+// The default log file is initialized to "debug.log" in the application
+// directory. You probably don't want this, especially since the program
+// directory may not be writable on an enduser's system.
+//
+// This function may be called a second time to re-direct logging (e.g after
+// loging in to a user partition), however it should never be called more than
+// twice.
+inline bool InitLogging(const LoggingSettings& settings) {
+  return BaseInitLoggingImpl(settings);
+}
+
+// Sets the log level. Anything at or above this level will be written to the
+// log file/displayed to the user (if applicable). Anything below this level
+// will be silently ignored. The log level defaults to 0 (everything is logged
+// up to level INFO) if this function is not called.
+// Note that log messages for VLOG(x) are logged at level -x, so setting
+// the min log level to negative values enables verbose logging.
+BASE_EXPORT void SetMinLogLevel(int level);
+
+// Gets the current log level.
+BASE_EXPORT int GetMinLogLevel();
+
+// Used by LOG_IS_ON to lazy-evaluate stream arguments.
+BASE_EXPORT bool ShouldCreateLogMessage(int severity);
+
+// Gets the VLOG default verbosity level.
+BASE_EXPORT int GetVlogVerbosity();
+
+// Note that |N| is the size *with* the null terminator.
+BASE_EXPORT int GetVlogLevelHelper(const char* file_start, size_t N);
+
+// Gets the current vlog level for the given file (usually taken from __FILE__).
+template <size_t N>
+int GetVlogLevel(const char (&file)[N]) {
+  return GetVlogLevelHelper(file, N);
+}
+
+// Sets the common items you want to be prepended to each log message.
+// process and thread IDs default to off, the timestamp defaults to on.
+// If this function is not called, logging defaults to writing the timestamp
+// only.
+BASE_EXPORT void SetLogItems(bool enable_process_id, bool enable_thread_id,
+                             bool enable_timestamp, bool enable_tickcount);
+
+// Sets whether or not you'd like to see fatal debug messages popped up in
+// a dialog box or not.
+// Dialogs are not shown by default.
+BASE_EXPORT void SetShowErrorDialogs(bool enable_dialogs);
+
+// Sets the Log Assert Handler that will be used to notify of check failures.
+// Resets Log Assert Handler on object destruction.
+// The default handler shows a dialog box and then terminate the process,
+// however clients can use this function to override with their own handling
+// (e.g. a silent one for Unit Tests)
+using LogAssertHandlerFunction =
+    base::Callback<void(const char* file,
+                        int line,
+                        const base::StringPiece message,
+                        const base::StringPiece stack_trace)>;
+
+class BASE_EXPORT ScopedLogAssertHandler {
+ public:
+  explicit ScopedLogAssertHandler(LogAssertHandlerFunction handler);
+  ~ScopedLogAssertHandler();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScopedLogAssertHandler);
+};
+
+// Sets the Log Message Handler that gets passed every log message before
+// it's sent to other log destinations (if any).
+// Returns true to signal that it handled the message and the message
+// should not be sent to other log destinations.
+typedef bool (*LogMessageHandlerFunction)(int severity,
+    const char* file, int line, size_t message_start, const std::string& str);
+BASE_EXPORT void SetLogMessageHandler(LogMessageHandlerFunction handler);
+BASE_EXPORT LogMessageHandlerFunction GetLogMessageHandler();
+
+// The ANALYZER_ASSUME_TRUE(bool arg) macro adds compiler-specific hints
+// to Clang which control what code paths are statically analyzed,
+// and is meant to be used in conjunction with assert & assert-like functions.
+// The expression is passed straight through if analysis isn't enabled.
+//
+// ANALYZER_SKIP_THIS_PATH() suppresses static analysis for the current
+// codepath and any other branching codepaths that might follow.
+#if defined(__clang_analyzer__)
+
+inline constexpr bool AnalyzerNoReturn() __attribute__((analyzer_noreturn)) {
+  return false;
+}
+
+inline constexpr bool AnalyzerAssumeTrue(bool arg) {
+  // AnalyzerNoReturn() is invoked and analysis is terminated if |arg| is
+  // false.
+  return arg || AnalyzerNoReturn();
+}
+
+#define ANALYZER_ASSUME_TRUE(arg) logging::AnalyzerAssumeTrue(!!(arg))
+#define ANALYZER_SKIP_THIS_PATH() \
+  static_cast<void>(::logging::AnalyzerNoReturn())
+#define ANALYZER_ALLOW_UNUSED(var) static_cast<void>(var);
+
+#else  // !defined(__clang_analyzer__)
+
+#define ANALYZER_ASSUME_TRUE(arg) (arg)
+#define ANALYZER_SKIP_THIS_PATH()
+#define ANALYZER_ALLOW_UNUSED(var) static_cast<void>(var);
+
+#endif  // defined(__clang_analyzer__)
+
+typedef int LogSeverity;
+const LogSeverity LOG_VERBOSE = -1;  // This is level 1 verbosity
+// Note: the log severities are used to index into the array of names,
+// see log_severity_names.
+const LogSeverity LOG_INFO = 0;
+const LogSeverity LOG_WARNING = 1;
+const LogSeverity LOG_ERROR = 2;
+const LogSeverity LOG_FATAL = 3;
+const LogSeverity LOG_NUM_SEVERITIES = 4;
+
+// LOG_DFATAL is LOG_FATAL in debug mode, ERROR in normal mode
+#if defined(NDEBUG)
+const LogSeverity LOG_DFATAL = LOG_ERROR;
+#else
+const LogSeverity LOG_DFATAL = LOG_FATAL;
+#endif
+
+// A few definitions of macros that don't generate much code. These are used
+// by LOG() and LOG_IF, etc. Since these are used all over our code, it's
+// better to have compact code for these operations.
+#define COMPACT_GOOGLE_LOG_EX_INFO(ClassName, ...) \
+  ::logging::ClassName(__FILE__, __LINE__, ::logging::LOG_INFO, ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_EX_WARNING(ClassName, ...)              \
+  ::logging::ClassName(__FILE__, __LINE__, ::logging::LOG_WARNING, \
+                       ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ...) \
+  ::logging::ClassName(__FILE__, __LINE__, ::logging::LOG_ERROR, ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ...) \
+  ::logging::ClassName(__FILE__, __LINE__, ::logging::LOG_FATAL, ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_EX_DFATAL(ClassName, ...) \
+  ::logging::ClassName(__FILE__, __LINE__, ::logging::LOG_DFATAL, ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
+  ::logging::ClassName(__FILE__, __LINE__, ::logging::LOG_DCHECK, ##__VA_ARGS__)
+
+#define COMPACT_GOOGLE_LOG_INFO COMPACT_GOOGLE_LOG_EX_INFO(LogMessage)
+#define COMPACT_GOOGLE_LOG_WARNING COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage)
+#define COMPACT_GOOGLE_LOG_ERROR COMPACT_GOOGLE_LOG_EX_ERROR(LogMessage)
+#define COMPACT_GOOGLE_LOG_FATAL COMPACT_GOOGLE_LOG_EX_FATAL(LogMessage)
+#define COMPACT_GOOGLE_LOG_DFATAL COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage)
+#define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_EX_DCHECK(LogMessage)
+
+#if defined(OS_WIN)
+// wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets
+// substituted with 0, and it expands to COMPACT_GOOGLE_LOG_0. To allow us
+// to keep using this syntax, we define this macro to do the same thing
+// as COMPACT_GOOGLE_LOG_ERROR, and also define ERROR the same way that
+// the Windows SDK does for consistency.
+#define ERROR 0
+#define COMPACT_GOOGLE_LOG_EX_0(ClassName, ...) \
+  COMPACT_GOOGLE_LOG_EX_ERROR(ClassName , ##__VA_ARGS__)
+#define COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR
+// Needed for LOG_IS_ON(ERROR).
+const LogSeverity LOG_0 = LOG_ERROR;
+#endif
+
+// As special cases, we can assume that LOG_IS_ON(FATAL) always holds. Also,
+// LOG_IS_ON(DFATAL) always holds in debug mode. In particular, CHECK()s will
+// always fire if they fail.
+#define LOG_IS_ON(severity) \
+  (::logging::ShouldCreateLogMessage(::logging::LOG_##severity))
+
+// We can't do any caching tricks with VLOG_IS_ON() like the
+// google-glog version since it requires GCC extensions.  This means
+// that using the v-logging functions in conjunction with --vmodule
+// may be slow.
+#define VLOG_IS_ON(verboselevel) \
+  ((verboselevel) <= ::logging::GetVlogLevel(__FILE__))
+
+// Helper macro which avoids evaluating the arguments to a stream if
+// the condition doesn't hold. Condition is evaluated once and only once.
+#define LAZY_STREAM(stream, condition)                                  \
+  !(condition) ? (void) 0 : ::logging::LogMessageVoidify() & (stream)
+
+// We use the preprocessor's merging operator, "##", so that, e.g.,
+// LOG(INFO) becomes the token COMPACT_GOOGLE_LOG_INFO.  There's some funny
+// subtle difference between ostream member streaming functions (e.g.,
+// ostream::operator<<(int) and ostream non-member streaming functions
+// (e.g., ::operator<<(ostream&, string&): it turns out that it's
+// impossible to stream something like a string directly to an unnamed
+// ostream. We employ a neat hack by calling the stream() member
+// function of LogMessage which seems to avoid the problem.
+#define LOG_STREAM(severity) COMPACT_GOOGLE_LOG_ ## severity.stream()
+
+#define LOG(severity) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity))
+#define LOG_IF(severity, condition) \
+  LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
+
+// The VLOG macros log with negative verbosities.
+#define VLOG_STREAM(verbose_level) \
+  ::logging::LogMessage(__FILE__, __LINE__, -verbose_level).stream()
+
+#define VLOG(verbose_level) \
+  LAZY_STREAM(VLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))
+
+#define VLOG_IF(verbose_level, condition) \
+  LAZY_STREAM(VLOG_STREAM(verbose_level), \
+      VLOG_IS_ON(verbose_level) && (condition))
+
+#if defined (OS_WIN)
+#define VPLOG_STREAM(verbose_level) \
+  ::logging::Win32ErrorLogMessage(__FILE__, __LINE__, -verbose_level, \
+    ::logging::GetLastSystemErrorCode()).stream()
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+#define VPLOG_STREAM(verbose_level) \
+  ::logging::ErrnoLogMessage(__FILE__, __LINE__, -verbose_level, \
+    ::logging::GetLastSystemErrorCode()).stream()
+#endif
+
+#define VPLOG(verbose_level) \
+  LAZY_STREAM(VPLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))
+
+#define VPLOG_IF(verbose_level, condition) \
+  LAZY_STREAM(VPLOG_STREAM(verbose_level), \
+    VLOG_IS_ON(verbose_level) && (condition))
+
+// TODO(akalin): Add more VLOG variants, e.g. VPLOG.
+
+#define LOG_ASSERT(condition)                       \
+  LOG_IF(FATAL, !(ANALYZER_ASSUME_TRUE(condition))) \
+      << "Assert failed: " #condition ". "
+
+#if defined(OS_WIN)
+#define PLOG_STREAM(severity) \
+  COMPACT_GOOGLE_LOG_EX_ ## severity(Win32ErrorLogMessage, \
+      ::logging::GetLastSystemErrorCode()).stream()
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+#define PLOG_STREAM(severity) \
+  COMPACT_GOOGLE_LOG_EX_ ## severity(ErrnoLogMessage, \
+      ::logging::GetLastSystemErrorCode()).stream()
+#endif
+
+#define PLOG(severity)                                          \
+  LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
+
+#define PLOG_IF(severity, condition) \
+  LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
+
+BASE_EXPORT extern std::ostream* g_swallow_stream;
+
+// Note that g_swallow_stream is used instead of an arbitrary LOG() stream to
+// avoid the creation of an object with a non-trivial destructor (LogMessage).
+// On MSVC x86 (checked on 2015 Update 3), this causes a few additional
+// pointless instructions to be emitted even at full optimization level, even
+// though the : arm of the ternary operator is clearly never executed. Using a
+// simpler object to be &'d with Voidify() avoids these extra instructions.
+// Using a simpler POD object with a templated operator<< also works to avoid
+// these instructions. However, this causes warnings on statically defined
+// implementations of operator<<(std::ostream, ...) in some .cc files, because
+// they become defined-but-unreferenced functions. A reinterpret_cast of 0 to an
+// ostream* also is not suitable, because some compilers warn of undefined
+// behavior.
+#define EAT_STREAM_PARAMETERS \
+  true ? (void)0              \
+       : ::logging::LogMessageVoidify() & (*::logging::g_swallow_stream)
+
+// Captures the result of a CHECK_EQ (for example) and facilitates testing as a
+// boolean.
+class CheckOpResult {
+ public:
+  // |message| must be non-null if and only if the check failed.
+  CheckOpResult(std::string* message) : message_(message) {}
+  // Returns true if the check succeeded.
+  operator bool() const { return !message_; }
+  // Returns the message.
+  std::string* message() { return message_; }
+
+ private:
+  std::string* message_;
+};
+
+// Crashes in the fastest possible way with no attempt at logging.
+// There are different constraints to satisfy here, see http://crbug.com/664209
+// for more context:
+// - The trap instructions, and hence the PC value at crash time, have to be
+//   distinct and not get folded into the same opcode by the compiler.
+//   On Linux/Android this is tricky because GCC still folds identical
+//   asm volatile blocks. The workaround is generating distinct opcodes for
+//   each CHECK using the __COUNTER__ macro.
+// - The debug info for the trap instruction has to be attributed to the source
+//   line that has the CHECK(), to make crash reports actionable. This rules
+//   out the ability of using a inline function, at least as long as clang
+//   doesn't support attribute(artificial).
+// - Failed CHECKs should produce a signal that is distinguishable from an
+//   invalid memory access, to improve the actionability of crash reports.
+// - The compiler should treat the CHECK as no-return instructions, so that the
+//   trap code can be efficiently packed in the prologue of the function and
+//   doesn't interfere with the main execution flow.
+// - When debugging, developers shouldn't be able to accidentally step over a
+//   CHECK. This is achieved by putting opcodes that will cause a non
+//   continuable exception after the actual trap instruction.
+// - Don't cause too much binary bloat.
+#if defined(COMPILER_GCC)
+
+#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_NACL)
+// int 3 will generate a SIGTRAP.
+#define TRAP_SEQUENCE() \
+  asm volatile(         \
+      "int3; ud2; push %0;" ::"i"(static_cast<unsigned char>(__COUNTER__)))
+
+#elif defined(ARCH_CPU_ARMEL) && !defined(OS_NACL)
+// bkpt will generate a SIGBUS when running on armv7 and a SIGTRAP when running
+// as a 32 bit userspace app on arm64. There doesn't seem to be any way to
+// cause a SIGTRAP from userspace without using a syscall (which would be a
+// problem for sandboxing).
+#define TRAP_SEQUENCE() \
+  asm volatile("bkpt #0; udf %0;" ::"i"(__COUNTER__ % 256))
+
+#elif defined(ARCH_CPU_ARM64) && !defined(OS_NACL)
+// This will always generate a SIGTRAP on arm64.
+#define TRAP_SEQUENCE() \
+  asm volatile("brk #0; hlt %0;" ::"i"(__COUNTER__ % 65536))
+
+#else
+// Crash report accuracy will not be guaranteed on other architectures, but at
+// least this will crash as expected.
+#define TRAP_SEQUENCE() __builtin_trap()
+#endif  // ARCH_CPU_*
+
+// CHECK() and the trap sequence can be invoked from a constexpr function.
+// This could make compilation fail on GCC, as it forbids directly using inline
+// asm inside a constexpr function. However, it allows calling a lambda
+// expression including the same asm.
+// The side effect is that the top of the stacktrace will not point to the
+// calling function, but to this anonymous lambda. This is still useful as the
+// full name of the lambda will typically include the name of the function that
+// calls CHECK() and the debugger will still break at the right line of code.
+#if !defined(__clang__)
+#define WRAPPED_TRAP_SEQUENCE() \
+  do {                          \
+    [] { TRAP_SEQUENCE(); }();  \
+  } while (false)
+#else
+#define WRAPPED_TRAP_SEQUENCE() TRAP_SEQUENCE()
+#endif
+
+#define IMMEDIATE_CRASH()    \
+  ({                         \
+    WRAPPED_TRAP_SEQUENCE(); \
+    __builtin_unreachable(); \
+  })
+
+#elif defined(COMPILER_MSVC)
+
+// Clang is cleverer about coalescing int3s, so we need to add a unique-ish
+// instruction following the __debugbreak() to have it emit distinct locations
+// for CHECKs rather than collapsing them all together. It would be nice to use
+// a short intrinsic to do this (and perhaps have only one implementation for
+// both clang and MSVC), however clang-cl currently does not support intrinsics.
+// On the flip side, MSVC x64 doesn't support inline asm. So, we have to have
+// two implementations. Normally clang-cl's version will be 5 bytes (1 for
+// `int3`, 2 for `ud2`, 2 for `push byte imm`, however, TODO(scottmg):
+// https://crbug.com/694670 clang-cl doesn't currently support %'ing
+// __COUNTER__, so eventually it will emit the dword form of push.
+// TODO(scottmg): Reinvestigate a short sequence that will work on both
+// compilers once clang supports more intrinsics. See https://crbug.com/693713.
+#if defined(__clang__)
+#define IMMEDIATE_CRASH()                           \
+  ({                                                \
+    {__asm int 3 __asm ud2 __asm push __COUNTER__}; \
+    __builtin_unreachable();                        \
+  })
+#else
+#define IMMEDIATE_CRASH() __debugbreak()
+#endif  // __clang__
+
+#else
+#error Port
+#endif
+
+// CHECK dies with a fatal error if condition is not true.  It is *not*
+// controlled by NDEBUG, so the check will be executed regardless of
+// compilation mode.
+//
+// We make sure CHECK et al. always evaluates their arguments, as
+// doing CHECK(FunctionWithSideEffect()) is a common idiom.
+
+#if defined(OFFICIAL_BUILD) && defined(NDEBUG)
+
+// Make all CHECK functions discard their log strings to reduce code bloat, and
+// improve performance, for official release builds.
+//
+// This is not calling BreakDebugger since this is called frequently, and
+// calling an out-of-line function instead of a noreturn inline macro prevents
+// compiler optimizations.
+#define CHECK(condition) \
+  UNLIKELY(!(condition)) ? IMMEDIATE_CRASH() : EAT_STREAM_PARAMETERS
+
+// PCHECK includes the system error code, which is useful for determining
+// why the condition failed. In official builds, preserve only the error code
+// message so that it is available in crash reports. The stringified
+// condition and any additional stream parameters are dropped.
+#define PCHECK(condition)                                  \
+  LAZY_STREAM(PLOG_STREAM(FATAL), UNLIKELY(!(condition))); \
+  EAT_STREAM_PARAMETERS
+
+#define CHECK_OP(name, op, val1, val2) CHECK((val1) op (val2))
+
+#else  // !(OFFICIAL_BUILD && NDEBUG)
+
+#if defined(_PREFAST_) && defined(OS_WIN)
+// Use __analysis_assume to tell the VC++ static analysis engine that
+// assert conditions are true, to suppress warnings.  The LAZY_STREAM
+// parameter doesn't reference 'condition' in /analyze builds because
+// this evaluation confuses /analyze. The !! before condition is because
+// __analysis_assume gets confused on some conditions:
+// http://randomascii.wordpress.com/2011/09/13/analyze-for-visual-studio-the-ugly-part-5/
+
+#define CHECK(condition)                    \
+  __analysis_assume(!!(condition)),         \
+      LAZY_STREAM(LOG_STREAM(FATAL), false) \
+          << "Check failed: " #condition ". "
+
+#define PCHECK(condition)                    \
+  __analysis_assume(!!(condition)),          \
+      LAZY_STREAM(PLOG_STREAM(FATAL), false) \
+          << "Check failed: " #condition ". "
+
+#else  // _PREFAST_
+
+// Do as much work as possible out of line to reduce inline code size.
+#define CHECK(condition)                                                      \
+  LAZY_STREAM(::logging::LogMessage(__FILE__, __LINE__, #condition).stream(), \
+              !ANALYZER_ASSUME_TRUE(condition))
+
+#define PCHECK(condition)                                           \
+  LAZY_STREAM(PLOG_STREAM(FATAL), !ANALYZER_ASSUME_TRUE(condition)) \
+      << "Check failed: " #condition ". "
+
+#endif  // _PREFAST_
+
+// Helper macro for binary operators.
+// Don't use this macro directly in your code, use CHECK_EQ et al below.
+// The 'switch' is used to prevent the 'else' from being ambiguous when the
+// macro is used in an 'if' clause such as:
+// if (a == 1)
+//   CHECK_EQ(2, a);
+#define CHECK_OP(name, op, val1, val2)                                         \
+  switch (0) case 0: default:                                                  \
+  if (::logging::CheckOpResult true_if_passed =                                \
+      ::logging::Check##name##Impl((val1), (val2),                             \
+                                   #val1 " " #op " " #val2))                   \
+   ;                                                                           \
+  else                                                                         \
+    ::logging::LogMessage(__FILE__, __LINE__, true_if_passed.message()).stream()
+
+#endif  // !(OFFICIAL_BUILD && NDEBUG)
+
+// This formats a value for a failing CHECK_XX statement.  Ordinarily,
+// it uses the definition for operator<<, with a few special cases below.
+template <typename T>
+inline typename std::enable_if<
+    base::internal::SupportsOstreamOperator<const T&>::value &&
+        !std::is_function<typename std::remove_pointer<T>::type>::value,
+    void>::type
+MakeCheckOpValueString(std::ostream* os, const T& v) {
+  (*os) << v;
+}
+
+// Provide an overload for functions and function pointers. Function pointers
+// don't implicitly convert to void* but do implicitly convert to bool, so
+// without this function pointers are always printed as 1 or 0. (MSVC isn't
+// standards-conforming here and converts function pointers to regular
+// pointers, so this is a no-op for MSVC.)
+template <typename T>
+inline typename std::enable_if<
+    std::is_function<typename std::remove_pointer<T>::type>::value,
+    void>::type
+MakeCheckOpValueString(std::ostream* os, const T& v) {
+  (*os) << reinterpret_cast<const void*>(v);
+}
+
+// We need overloads for enums that don't support operator<<.
+// (i.e. scoped enums where no operator<< overload was declared).
+template <typename T>
+inline typename std::enable_if<
+    !base::internal::SupportsOstreamOperator<const T&>::value &&
+        std::is_enum<T>::value,
+    void>::type
+MakeCheckOpValueString(std::ostream* os, const T& v) {
+  (*os) << static_cast<typename std::underlying_type<T>::type>(v);
+}
+
+// We need an explicit overload for std::nullptr_t.
+BASE_EXPORT void MakeCheckOpValueString(std::ostream* os, std::nullptr_t p);
+
+// Build the error message string.  This is separate from the "Impl"
+// function template because it is not performance critical and so can
+// be out of line, while the "Impl" code should be inline.  Caller
+// takes ownership of the returned string.
+template<class t1, class t2>
+std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) {
+  std::ostringstream ss;
+  ss << names << " (";
+  MakeCheckOpValueString(&ss, v1);
+  ss << " vs. ";
+  MakeCheckOpValueString(&ss, v2);
+  ss << ")";
+  std::string* msg = new std::string(ss.str());
+  return msg;
+}
+
+// Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
+// in logging.cc.
+extern template BASE_EXPORT std::string* MakeCheckOpString<int, int>(
+    const int&, const int&, const char* names);
+extern template BASE_EXPORT
+std::string* MakeCheckOpString<unsigned long, unsigned long>(
+    const unsigned long&, const unsigned long&, const char* names);
+extern template BASE_EXPORT
+std::string* MakeCheckOpString<unsigned long, unsigned int>(
+    const unsigned long&, const unsigned int&, const char* names);
+extern template BASE_EXPORT
+std::string* MakeCheckOpString<unsigned int, unsigned long>(
+    const unsigned int&, const unsigned long&, const char* names);
+extern template BASE_EXPORT
+std::string* MakeCheckOpString<std::string, std::string>(
+    const std::string&, const std::string&, const char* name);
+
+// Helper functions for CHECK_OP macro.
+// The (int, int) specialization works around the issue that the compiler
+// will not instantiate the template version of the function on values of
+// unnamed enum type - see comment below.
+//
+// The checked condition is wrapped with ANALYZER_ASSUME_TRUE, which under
+// static analysis builds, blocks analysis of the current path if the
+// condition is false.
+#define DEFINE_CHECK_OP_IMPL(name, op)                                       \
+  template <class t1, class t2>                                              \
+  inline std::string* Check##name##Impl(const t1& v1, const t2& v2,          \
+                                        const char* names) {                 \
+    if (ANALYZER_ASSUME_TRUE(v1 op v2))                                      \
+      return NULL;                                                           \
+    else                                                                     \
+      return ::logging::MakeCheckOpString(v1, v2, names);                    \
+  }                                                                          \
+  inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
+    if (ANALYZER_ASSUME_TRUE(v1 op v2))                                      \
+      return NULL;                                                           \
+    else                                                                     \
+      return ::logging::MakeCheckOpString(v1, v2, names);                    \
+  }
+DEFINE_CHECK_OP_IMPL(EQ, ==)
+DEFINE_CHECK_OP_IMPL(NE, !=)
+DEFINE_CHECK_OP_IMPL(LE, <=)
+DEFINE_CHECK_OP_IMPL(LT, < )
+DEFINE_CHECK_OP_IMPL(GE, >=)
+DEFINE_CHECK_OP_IMPL(GT, > )
+#undef DEFINE_CHECK_OP_IMPL
+
+#define CHECK_EQ(val1, val2) CHECK_OP(EQ, ==, val1, val2)
+#define CHECK_NE(val1, val2) CHECK_OP(NE, !=, val1, val2)
+#define CHECK_LE(val1, val2) CHECK_OP(LE, <=, val1, val2)
+#define CHECK_LT(val1, val2) CHECK_OP(LT, < , val1, val2)
+#define CHECK_GE(val1, val2) CHECK_OP(GE, >=, val1, val2)
+#define CHECK_GT(val1, val2) CHECK_OP(GT, > , val1, val2)
+
+#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
+#define DCHECK_IS_ON() 0
+#else
+#define DCHECK_IS_ON() 1
+#endif
+
+// Definitions for DLOG et al.
+
+#if DCHECK_IS_ON()
+
+#define DLOG_IS_ON(severity) LOG_IS_ON(severity)
+#define DLOG_IF(severity, condition) LOG_IF(severity, condition)
+#define DLOG_ASSERT(condition) LOG_ASSERT(condition)
+#define DPLOG_IF(severity, condition) PLOG_IF(severity, condition)
+#define DVLOG_IF(verboselevel, condition) VLOG_IF(verboselevel, condition)
+#define DVPLOG_IF(verboselevel, condition) VPLOG_IF(verboselevel, condition)
+
+#else  // DCHECK_IS_ON()
+
+// If !DCHECK_IS_ON(), we want to avoid emitting any references to |condition|
+// (which may reference a variable defined only if DCHECK_IS_ON()).
+// Contrast this with DCHECK et al., which has different behavior.
+
+#define DLOG_IS_ON(severity) false
+#define DLOG_IF(severity, condition) EAT_STREAM_PARAMETERS
+#define DLOG_ASSERT(condition) EAT_STREAM_PARAMETERS
+#define DPLOG_IF(severity, condition) EAT_STREAM_PARAMETERS
+#define DVLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS
+#define DVPLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS
+
+#endif  // DCHECK_IS_ON()
+
+#define DLOG(severity)                                          \
+  LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
+
+#define DPLOG(severity)                                         \
+  LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
+
+#define DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
+
+#define DVPLOG(verboselevel) DVPLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
+
+// Definitions for DCHECK et al.
+
+#if DCHECK_IS_ON()
+
+#if DCHECK_IS_CONFIGURABLE
+BASE_EXPORT extern LogSeverity LOG_DCHECK;
+#else
+const LogSeverity LOG_DCHECK = LOG_FATAL;
+#endif
+
+#else  // DCHECK_IS_ON()
+
+// There may be users of LOG_DCHECK that are enabled independently
+// of DCHECK_IS_ON(), so default to FATAL logging for those.
+const LogSeverity LOG_DCHECK = LOG_FATAL;
+
+#endif  // DCHECK_IS_ON()
+
+// DCHECK et al. make sure to reference |condition| regardless of
+// whether DCHECKs are enabled; this is so that we don't get unused
+// variable warnings if the only use of a variable is in a DCHECK.
+// This behavior is different from DLOG_IF et al.
+//
+// Note that the definition of the DCHECK macros depends on whether or not
+// DCHECK_IS_ON() is true. When DCHECK_IS_ON() is false, the macros use
+// EAT_STREAM_PARAMETERS to avoid expressions that would create temporaries.
+
+#if defined(_PREFAST_) && defined(OS_WIN)
+// See comments on the previous use of __analysis_assume.
+
+#define DCHECK(condition)                    \
+  __analysis_assume(!!(condition)),          \
+      LAZY_STREAM(LOG_STREAM(DCHECK), false) \
+          << "Check failed: " #condition ". "
+
+#define DPCHECK(condition)                    \
+  __analysis_assume(!!(condition)),           \
+      LAZY_STREAM(PLOG_STREAM(DCHECK), false) \
+          << "Check failed: " #condition ". "
+
+#else  // !(defined(_PREFAST_) && defined(OS_WIN))
+
+#if DCHECK_IS_ON()
+
+#define DCHECK(condition)                                           \
+  LAZY_STREAM(LOG_STREAM(DCHECK), !ANALYZER_ASSUME_TRUE(condition)) \
+      << "Check failed: " #condition ". "
+#define DPCHECK(condition)                                           \
+  LAZY_STREAM(PLOG_STREAM(DCHECK), !ANALYZER_ASSUME_TRUE(condition)) \
+      << "Check failed: " #condition ". "
+
+#else  // DCHECK_IS_ON()
+
+#define DCHECK(condition) EAT_STREAM_PARAMETERS << !(condition)
+#define DPCHECK(condition) EAT_STREAM_PARAMETERS << !(condition)
+
+#endif  // DCHECK_IS_ON()
+
+#endif  // defined(_PREFAST_) && defined(OS_WIN)
+
+// Helper macro for binary operators.
+// Don't use this macro directly in your code, use DCHECK_EQ et al below.
+// The 'switch' is used to prevent the 'else' from being ambiguous when the
+// macro is used in an 'if' clause such as:
+// if (a == 1)
+//   DCHECK_EQ(2, a);
+#if DCHECK_IS_ON()
+
+#define DCHECK_OP(name, op, val1, val2)                                \
+  switch (0) case 0: default:                                          \
+  if (::logging::CheckOpResult true_if_passed =                        \
+      ::logging::Check##name##Impl((val1), (val2),                     \
+                                   #val1 " " #op " " #val2))           \
+   ;                                                                   \
+  else                                                                 \
+    ::logging::LogMessage(__FILE__, __LINE__, ::logging::LOG_DCHECK,   \
+                          true_if_passed.message()).stream()
+
+#else  // DCHECK_IS_ON()
+
+// When DCHECKs aren't enabled, DCHECK_OP still needs to reference operator<<
+// overloads for |val1| and |val2| to avoid potential compiler warnings about
+// unused functions. For the same reason, it also compares |val1| and |val2|
+// using |op|.
+//
+// Note that the contract of DCHECK_EQ, etc is that arguments are only evaluated
+// once. Even though |val1| and |val2| appear twice in this version of the macro
+// expansion, this is OK, since the expression is never actually evaluated.
+#define DCHECK_OP(name, op, val1, val2)                             \
+  EAT_STREAM_PARAMETERS << (::logging::MakeCheckOpValueString(      \
+                                ::logging::g_swallow_stream, val1), \
+                            ::logging::MakeCheckOpValueString(      \
+                                ::logging::g_swallow_stream, val2), \
+                            (val1)op(val2))
+
+#endif  // DCHECK_IS_ON()
+
+// Equality/Inequality checks - compare two values, and log a
+// LOG_DCHECK message including the two values when the result is not
+// as expected.  The values must have operator<<(ostream, ...)
+// defined.
+//
+// You may append to the error message like so:
+//   DCHECK_NE(1, 2) << "The world must be ending!";
+//
+// We are very careful to ensure that each argument is evaluated exactly
+// once, and that anything which is legal to pass as a function argument is
+// legal here.  In particular, the arguments may be temporary expressions
+// which will end up being destroyed at the end of the apparent statement,
+// for example:
+//   DCHECK_EQ(string("abc")[1], 'b');
+//
+// WARNING: These don't compile correctly if one of the arguments is a pointer
+// and the other is NULL.  In new code, prefer nullptr instead.  To
+// work around this for C++98, simply static_cast NULL to the type of the
+// desired pointer.
+
+#define DCHECK_EQ(val1, val2) DCHECK_OP(EQ, ==, val1, val2)
+#define DCHECK_NE(val1, val2) DCHECK_OP(NE, !=, val1, val2)
+#define DCHECK_LE(val1, val2) DCHECK_OP(LE, <=, val1, val2)
+#define DCHECK_LT(val1, val2) DCHECK_OP(LT, < , val1, val2)
+#define DCHECK_GE(val1, val2) DCHECK_OP(GE, >=, val1, val2)
+#define DCHECK_GT(val1, val2) DCHECK_OP(GT, > , val1, val2)
+
+#if !DCHECK_IS_ON() && defined(OS_CHROMEOS)
+// Implement logging of NOTREACHED() as a dedicated function to get function
+// call overhead down to a minimum.
+void LogErrorNotReached(const char* file, int line);
+#define NOTREACHED()                                       \
+  true ? ::logging::LogErrorNotReached(__FILE__, __LINE__) \
+       : EAT_STREAM_PARAMETERS
+#else
+#define NOTREACHED() DCHECK(false)
+#endif
+
+// Redefine the standard assert to use our nice log files
+#undef assert
+#define assert(x) DLOG_ASSERT(x)
+
+// This class more or less represents a particular log message.  You
+// create an instance of LogMessage and then stream stuff to it.
+// When you finish streaming to it, ~LogMessage is called and the
+// full message gets streamed to the appropriate destination.
+//
+// You shouldn't actually use LogMessage's constructor to log things,
+// though.  You should use the LOG() macro (and variants thereof)
+// above.
+class BASE_EXPORT LogMessage {
+ public:
+  // Used for LOG(severity).
+  LogMessage(const char* file, int line, LogSeverity severity);
+
+  // Used for CHECK().  Implied severity = LOG_FATAL.
+  LogMessage(const char* file, int line, const char* condition);
+
+  // Used for CHECK_EQ(), etc. Takes ownership of the given string.
+  // Implied severity = LOG_FATAL.
+  LogMessage(const char* file, int line, std::string* result);
+
+  // Used for DCHECK_EQ(), etc. Takes ownership of the given string.
+  LogMessage(const char* file, int line, LogSeverity severity,
+             std::string* result);
+
+  ~LogMessage();
+
+  std::ostream& stream() { return stream_; }
+
+  LogSeverity severity() { return severity_; }
+  std::string str() { return stream_.str(); }
+
+ private:
+  void Init(const char* file, int line);
+
+  LogSeverity severity_;
+  std::ostringstream stream_;
+  size_t message_start_;  // Offset of the start of the message (past prefix
+                          // info).
+  // The file and line information passed in to the constructor.
+  const char* file_;
+  const int line_;
+
+#if defined(OS_WIN)
+  // Stores the current value of GetLastError in the constructor and restores
+  // it in the destructor by calling SetLastError.
+  // This is useful since the LogMessage class uses a lot of Win32 calls
+  // that will lose the value of GLE and the code that called the log function
+  // will have lost the thread error value when the log call returns.
+  class SaveLastError {
+   public:
+    SaveLastError();
+    ~SaveLastError();
+
+    unsigned long get_error() const { return last_error_; }
+
+   protected:
+    unsigned long last_error_;
+  };
+
+  SaveLastError last_error_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(LogMessage);
+};
+
+// This class is used to explicitly ignore values in the conditional
+// logging macros.  This avoids compiler warnings like "value computed
+// is not used" and "statement has no effect".
+class LogMessageVoidify {
+ public:
+  LogMessageVoidify() = default;
+  // This has to be an operator with a precedence lower than << but
+  // higher than ?:
+  void operator&(std::ostream&) { }
+};
+
+#if defined(OS_WIN)
+typedef unsigned long SystemErrorCode;
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+typedef int SystemErrorCode;
+#endif
+
+// Alias for ::GetLastError() on Windows and errno on POSIX. Avoids having to
+// pull in windows.h just for GetLastError() and DWORD.
+BASE_EXPORT SystemErrorCode GetLastSystemErrorCode();
+BASE_EXPORT std::string SystemErrorCodeToString(SystemErrorCode error_code);
+
+#if defined(OS_WIN)
+// Appends a formatted system message of the GetLastError() type.
+class BASE_EXPORT Win32ErrorLogMessage {
+ public:
+  Win32ErrorLogMessage(const char* file,
+                       int line,
+                       LogSeverity severity,
+                       SystemErrorCode err);
+
+  // Appends the error message before destructing the encapsulated class.
+  ~Win32ErrorLogMessage();
+
+  std::ostream& stream() { return log_message_.stream(); }
+
+ private:
+  SystemErrorCode err_;
+  LogMessage log_message_;
+
+  DISALLOW_COPY_AND_ASSIGN(Win32ErrorLogMessage);
+};
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+// Appends a formatted system message of the errno type
+class BASE_EXPORT ErrnoLogMessage {
+ public:
+  ErrnoLogMessage(const char* file,
+                  int line,
+                  LogSeverity severity,
+                  SystemErrorCode err);
+
+  // Appends the error message before destructing the encapsulated class.
+  ~ErrnoLogMessage();
+
+  std::ostream& stream() { return log_message_.stream(); }
+
+ private:
+  SystemErrorCode err_;
+  LogMessage log_message_;
+
+  DISALLOW_COPY_AND_ASSIGN(ErrnoLogMessage);
+};
+#endif  // OS_WIN
+
+// Closes the log file explicitly if open.
+// NOTE: Since the log file is opened as necessary by the action of logging
+//       statements, there's no guarantee that it will stay closed
+//       after this call.
+BASE_EXPORT void CloseLogFile();
+
+// Async signal safe logging mechanism.
+BASE_EXPORT void RawLog(int level, const char* message);
+
+#define RAW_LOG(level, message) \
+  ::logging::RawLog(::logging::LOG_##level, message)
+
+#define RAW_CHECK(condition)                               \
+  do {                                                     \
+    if (!(condition))                                      \
+      ::logging::RawLog(::logging::LOG_FATAL,              \
+                        "Check failed: " #condition "\n"); \
+  } while (0)
+
+#if defined(OS_WIN)
+// Returns true if logging to file is enabled.
+BASE_EXPORT bool IsLoggingToFileEnabled();
+
+// Returns the default log file path.
+BASE_EXPORT std::wstring GetLogFileFullPath();
+#endif
+
+}  // namespace logging
+
+// Note that "The behavior of a C++ program is undefined if it adds declarations
+// or definitions to namespace std or to a namespace within namespace std unless
+// otherwise specified." --C++11[namespace.std]
+//
+// We've checked that this particular definition has the intended behavior on
+// our implementations, but it's prone to breaking in the future, and please
+// don't imitate this in your own definitions without checking with some
+// standard library experts.
+namespace std {
+// These functions are provided as a convenience for logging, which is where we
+// use streams (it is against Google style to use streams in other places). It
+// is designed to allow you to emit non-ASCII Unicode strings to the log file,
+// which is normally ASCII. It is relatively slow, so try not to use it for
+// common cases. Non-ASCII characters will be converted to UTF-8 by these
+// operators.
+BASE_EXPORT std::ostream& operator<<(std::ostream& out, const wchar_t* wstr);
+inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) {
+  return out << wstr.c_str();
+}
+}  // namespace std
+
+// The NOTIMPLEMENTED() macro annotates codepaths which have not been
+// implemented yet. If output spam is a serious concern,
+// NOTIMPLEMENTED_LOG_ONCE can be used.
+
+#if defined(COMPILER_GCC)
+// On Linux, with GCC, we can use __PRETTY_FUNCTION__ to get the demangled name
+// of the current function in the NOTIMPLEMENTED message.
+#define NOTIMPLEMENTED_MSG "Not implemented reached in " << __PRETTY_FUNCTION__
+#else
+#define NOTIMPLEMENTED_MSG "NOT IMPLEMENTED"
+#endif
+
+#if defined(OS_ANDROID) && defined(OFFICIAL_BUILD)
+#define NOTIMPLEMENTED() EAT_STREAM_PARAMETERS
+#define NOTIMPLEMENTED_LOG_ONCE() EAT_STREAM_PARAMETERS
+#else
+#define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG
+#define NOTIMPLEMENTED_LOG_ONCE()                      \
+  do {                                                 \
+    static bool logged_once = false;                   \
+    LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG; \
+    logged_once = true;                                \
+  } while (0);                                         \
+  EAT_STREAM_PARAMETERS
+#endif
+
+#endif  // BASE_LOGGING_H_
diff --git a/native/zucchini/vendor/libchrome/base/macros.h b/native/zucchini/vendor/libchrome/base/macros.h
new file mode 100644
index 0000000..8685117
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/macros.h
@@ -0,0 +1,114 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file contains macros and macro-like constructs (e.g., templates) that
+// are commonly used throughout Chromium source. (It may also contain things
+// that are closely related to things that are commonly used that belong in this
+// file.)
+
+#ifndef BASE_MACROS_H_
+#define BASE_MACROS_H_
+
+#include <stddef.h>  // For size_t.
+
+#if defined(ANDROID)
+// Prefer Android's libbase definitions to our own.
+#include <android-base/macros.h>
+#endif  // defined(ANDROID)
+
+// We define following macros conditionally as they may be defined by another libraries.
+
+// Distinguish mips32.
+#if defined(__mips__) && (_MIPS_SIM == _ABIO32) && !defined(__mips32__)
+#define __mips32__
+#endif
+
+// Distinguish mips64.
+#if defined(__mips__) && (_MIPS_SIM == _ABI64) && !defined(__mips64__)
+#define __mips64__
+#endif
+
+// Put this in the declarations for a class to be uncopyable.
+#if !defined(DISALLOW_COPY)
+#define DISALLOW_COPY(TypeName) \
+  TypeName(const TypeName&) = delete
+#endif
+
+// Put this in the declarations for a class to be unassignable.
+#if !defined(DISALLOW_ASSIGN)
+#define DISALLOW_ASSIGN(TypeName) TypeName& operator=(const TypeName&) = delete
+#endif
+
+// Put this in the declarations for a class to be uncopyable and unassignable.
+#if !defined(DISALLOW_COPY_AND_ASSIGN)
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  DISALLOW_COPY(TypeName);                 \
+  DISALLOW_ASSIGN(TypeName)
+#endif
+
+// A macro to disallow all the implicit constructors, namely the
+// default constructor, copy constructor and operator= functions.
+// This is especially useful for classes containing only static methods.
+#if !defined(DISALLOW_IMPLICIT_CONSTRUCTORS)
+#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
+  TypeName() = delete;                           \
+  DISALLOW_COPY_AND_ASSIGN(TypeName)
+#endif
+
+// The arraysize(arr) macro returns the # of elements in an array arr.  The
+// expression is a compile-time constant, and therefore can be used in defining
+// new arrays, for example.  If you use arraysize on a pointer by mistake, you
+// will get a compile-time error.  For the technical details, refer to
+// http://blogs.msdn.com/b/the1/archive/2004/05/07/128242.aspx.
+
+// This template function declaration is used in defining arraysize.
+// Note that the function doesn't need an implementation, as we only
+// use its type.
+//
+// DEPRECATED, please use base::size(array) instead.
+// TODO(https://crbug.com/837308): Replace existing arraysize usages.
+#if !defined(arraysize)
+template <typename T, size_t N> char (&ArraySizeHelper(T (&array)[N]))[N];
+#define arraysize(array) (sizeof(ArraySizeHelper(array)))
+#endif
+
+// Used to explicitly mark the return value of a function as unused. If you are
+// really sure you don't want to do anything with the return value of a function
+// that has been marked WARN_UNUSED_RESULT, wrap it with this. Example:
+//
+//   std::unique_ptr<MyType> my_var = ...;
+//   if (TakeOwnership(my_var.get()) == SUCCESS)
+//     ignore_result(my_var.release());
+//
+template<typename T>
+inline void ignore_result(const T&) {
+}
+
+namespace base {
+
+// Use these to declare and define a static local variable (static T;) so that
+// it is leaked so that its destructors are not called at exit.  This is
+// thread-safe.
+//
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DEPRECATED !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// Please don't use this macro. Use a function-local static of type
+// base::NoDestructor<T> instead:
+//
+// Factory& Factory::GetInstance() {
+//   static base::NoDestructor<Factory> instance;
+//   return *instance;
+// }
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+#if !defined(CR_DEFINE_STATIC_LOCAL)
+#define CR_DEFINE_STATIC_LOCAL(type, name, arguments) \
+  static type& name = *new type arguments
+#endif
+
+// Workaround for MSVC, which expands __VA_ARGS__ as one macro argument. To
+// work around this bug, wrap the entire expression in this macro...
+#define CR_EXPAND_ARG(arg) arg
+
+}  // base
+
+#endif  // BASE_MACROS_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/free_deleter.h b/native/zucchini/vendor/libchrome/base/memory/free_deleter.h
new file mode 100644
index 0000000..5604118
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/memory/free_deleter.h
@@ -0,0 +1,25 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_MEMORY_FREE_DELETER_H_
+#define BASE_MEMORY_FREE_DELETER_H_
+
+#include <stdlib.h>
+
+namespace base {
+
+// Function object which invokes 'free' on its parameter, which must be
+// a pointer. Can be used to store malloc-allocated pointers in std::unique_ptr:
+//
+// std::unique_ptr<int, base::FreeDeleter> foo_ptr(
+//     static_cast<int*>(malloc(sizeof(int))));
+struct FreeDeleter {
+  inline void operator()(void* ptr) const {
+    free(ptr);
+  }
+};
+
+}  // namespace base
+
+#endif  // BASE_MEMORY_FREE_DELETER_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/ptr_util.h b/native/zucchini/vendor/libchrome/base/memory/ptr_util.h
new file mode 100644
index 0000000..42f4f49
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/memory/ptr_util.h
@@ -0,0 +1,23 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_MEMORY_PTR_UTIL_H_
+#define BASE_MEMORY_PTR_UTIL_H_
+
+#include <memory>
+#include <utility>
+
+namespace base {
+
+// Helper to transfer ownership of a raw pointer to a std::unique_ptr<T>.
+// Note that std::unique_ptr<T> has very different semantics from
+// std::unique_ptr<T[]>: do not use this helper for array allocations.
+template <typename T>
+std::unique_ptr<T> WrapUnique(T* ptr) {
+  return std::unique_ptr<T>(ptr);
+}
+
+}  // namespace base
+
+#endif  // BASE_MEMORY_PTR_UTIL_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/raw_scoped_refptr_mismatch_checker.h b/native/zucchini/vendor/libchrome/base/memory/raw_scoped_refptr_mismatch_checker.h
new file mode 100644
index 0000000..ab8b2ab
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/memory/raw_scoped_refptr_mismatch_checker.h
@@ -0,0 +1,52 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_MEMORY_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
+#define BASE_MEMORY_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
+
+#include <type_traits>
+
+#include "base/template_util.h"
+
+// It is dangerous to post a task with a T* argument where T is a subtype of
+// RefCounted(Base|ThreadSafeBase), since by the time the parameter is used, the
+// object may already have been deleted since it was not held with a
+// scoped_refptr. Example: http://crbug.com/27191
+// The following set of traits are designed to generate a compile error
+// whenever this antipattern is attempted.
+
+namespace base {
+
+// This is a base internal implementation file used by task.h and callback.h.
+// Not for public consumption, so we wrap it in namespace internal.
+namespace internal {
+
+template <typename T, typename = void>
+struct IsRefCountedType : std::false_type {};
+
+template <typename T>
+struct IsRefCountedType<T,
+                        void_t<decltype(std::declval<T*>()->AddRef()),
+                               decltype(std::declval<T*>()->Release())>>
+    : std::true_type {};
+
+template <typename T>
+struct NeedsScopedRefptrButGetsRawPtr {
+  static_assert(!std::is_reference<T>::value,
+                "NeedsScopedRefptrButGetsRawPtr requires non-reference type.");
+
+  enum {
+    // Human readable translation: you needed to be a scoped_refptr if you are a
+    // raw pointer type and are convertible to a RefCounted(Base|ThreadSafeBase)
+    // type.
+    value = std::is_pointer<T>::value &&
+            IsRefCountedType<std::remove_pointer_t<T>>::value
+  };
+};
+
+}  // namespace internal
+
+}  // namespace base
+
+#endif  // BASE_MEMORY_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/ref_counted.h b/native/zucchini/vendor/libchrome/base/memory/ref_counted.h
new file mode 100644
index 0000000..249f70e
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/memory/ref_counted.h
@@ -0,0 +1,425 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_MEMORY_REF_COUNTED_H_
+#define BASE_MEMORY_REF_COUNTED_H_
+
+#include <stddef.h>
+
+#include <utility>
+
+#include "base/atomic_ref_count.h"
+#include "base/base_export.h"
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/scoped_refptr.h"
+#include "base/sequence_checker.h"
+#include "base/threading/thread_collision_warner.h"
+#include "build/build_config.h"
+
+namespace base {
+namespace subtle {
+
+class BASE_EXPORT RefCountedBase {
+ public:
+  bool HasOneRef() const { return ref_count_ == 1; }
+
+ protected:
+  explicit RefCountedBase(StartRefCountFromZeroTag) {
+#if DCHECK_IS_ON()
+    sequence_checker_.DetachFromSequence();
+#endif
+  }
+
+  explicit RefCountedBase(StartRefCountFromOneTag) : ref_count_(1) {
+#if DCHECK_IS_ON()
+    needs_adopt_ref_ = true;
+    sequence_checker_.DetachFromSequence();
+#endif
+  }
+
+  ~RefCountedBase() {
+#if DCHECK_IS_ON()
+    DCHECK(in_dtor_) << "RefCounted object deleted without calling Release()";
+#endif
+  }
+
+  void AddRef() const {
+    // TODO(maruel): Add back once it doesn't assert 500 times/sec.
+    // Current thread books the critical section "AddRelease"
+    // without release it.
+    // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_);
+#if DCHECK_IS_ON()
+    DCHECK(!in_dtor_);
+    DCHECK(!needs_adopt_ref_)
+        << "This RefCounted object is created with non-zero reference count."
+        << " The first reference to such a object has to be made by AdoptRef or"
+        << " MakeRefCounted.";
+    if (ref_count_ >= 1) {
+      DCHECK(CalledOnValidSequence());
+    }
+#endif
+
+    AddRefImpl();
+  }
+
+  // Returns true if the object should self-delete.
+  bool Release() const {
+    --ref_count_;
+
+    // TODO(maruel): Add back once it doesn't assert 500 times/sec.
+    // Current thread books the critical section "AddRelease"
+    // without release it.
+    // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_);
+
+#if DCHECK_IS_ON()
+    DCHECK(!in_dtor_);
+    if (ref_count_ == 0)
+      in_dtor_ = true;
+
+    if (ref_count_ >= 1)
+      DCHECK(CalledOnValidSequence());
+    if (ref_count_ == 1)
+      sequence_checker_.DetachFromSequence();
+#endif
+
+    return ref_count_ == 0;
+  }
+
+  // Returns true if it is safe to read or write the object, from a thread
+  // safety standpoint. Should be DCHECK'd from the methods of RefCounted
+  // classes if there is a danger of objects being shared across threads.
+  //
+  // This produces fewer false positives than adding a separate SequenceChecker
+  // into the subclass, because it automatically detaches from the sequence when
+  // the reference count is 1 (and never fails if there is only one reference).
+  //
+  // This means unlike a separate SequenceChecker, it will permit a singly
+  // referenced object to be passed between threads (not holding a reference on
+  // the sending thread), but will trap if the sending thread holds onto a
+  // reference, or if the object is accessed from multiple threads
+  // simultaneously.
+  bool IsOnValidSequence() const {
+#if DCHECK_IS_ON()
+    return ref_count_ <= 1 || CalledOnValidSequence();
+#else
+    return true;
+#endif
+  }
+
+ private:
+  template <typename U>
+  friend scoped_refptr<U> base::AdoptRef(U*);
+
+  void Adopted() const {
+#if DCHECK_IS_ON()
+    DCHECK(needs_adopt_ref_);
+    needs_adopt_ref_ = false;
+#endif
+  }
+
+#if defined(ARCH_CPU_64_BIT)
+  void AddRefImpl() const;
+#else
+  void AddRefImpl() const { ++ref_count_; }
+#endif
+
+#if DCHECK_IS_ON()
+  bool CalledOnValidSequence() const;
+#endif
+
+  mutable uint32_t ref_count_ = 0;
+
+#if DCHECK_IS_ON()
+  mutable bool needs_adopt_ref_ = false;
+  mutable bool in_dtor_ = false;
+  mutable SequenceChecker sequence_checker_;
+#endif
+
+  DFAKE_MUTEX(add_release_);
+
+  DISALLOW_COPY_AND_ASSIGN(RefCountedBase);
+};
+
+class BASE_EXPORT RefCountedThreadSafeBase {
+ public:
+  bool HasOneRef() const;
+
+ protected:
+  explicit constexpr RefCountedThreadSafeBase(StartRefCountFromZeroTag) {}
+  explicit constexpr RefCountedThreadSafeBase(StartRefCountFromOneTag)
+      : ref_count_(1) {
+#if DCHECK_IS_ON()
+    needs_adopt_ref_ = true;
+#endif
+  }
+
+#if DCHECK_IS_ON()
+  ~RefCountedThreadSafeBase();
+#else
+  ~RefCountedThreadSafeBase() = default;
+#endif
+
+// Release and AddRef are suitable for inlining on X86 because they generate
+// very small code sequences. On other platforms (ARM), it causes a size
+// regression and is probably not worth it.
+#if defined(ARCH_CPU_X86_FAMILY)
+  // Returns true if the object should self-delete.
+  bool Release() const { return ReleaseImpl(); }
+  void AddRef() const { AddRefImpl(); }
+#else
+  // Returns true if the object should self-delete.
+  bool Release() const;
+  void AddRef() const;
+#endif
+
+ private:
+  template <typename U>
+  friend scoped_refptr<U> base::AdoptRef(U*);
+
+  void Adopted() const {
+#if DCHECK_IS_ON()
+    DCHECK(needs_adopt_ref_);
+    needs_adopt_ref_ = false;
+#endif
+  }
+
+  ALWAYS_INLINE void AddRefImpl() const {
+#if DCHECK_IS_ON()
+    DCHECK(!in_dtor_);
+    DCHECK(!needs_adopt_ref_)
+        << "This RefCounted object is created with non-zero reference count."
+        << " The first reference to such a object has to be made by AdoptRef or"
+        << " MakeRefCounted.";
+#endif
+    ref_count_.Increment();
+  }
+
+  ALWAYS_INLINE bool ReleaseImpl() const {
+#if DCHECK_IS_ON()
+    DCHECK(!in_dtor_);
+    DCHECK(!ref_count_.IsZero());
+#endif
+    if (!ref_count_.Decrement()) {
+#if DCHECK_IS_ON()
+      in_dtor_ = true;
+#endif
+      return true;
+    }
+    return false;
+  }
+
+  mutable AtomicRefCount ref_count_{0};
+#if DCHECK_IS_ON()
+  mutable bool needs_adopt_ref_ = false;
+  mutable bool in_dtor_ = false;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafeBase);
+};
+
+}  // namespace subtle
+
+// ScopedAllowCrossThreadRefCountAccess disables the check documented on
+// RefCounted below for rare pre-existing use cases where thread-safety was
+// guaranteed through other means (e.g. explicit sequencing of calls across
+// execution sequences when bouncing between threads in order). New callers
+// should refrain from using this (callsites handling thread-safety through
+// locks should use RefCountedThreadSafe per the overhead of its atomics being
+// negligible compared to locks anyways and callsites doing explicit sequencing
+// should properly std::move() the ref to avoid hitting this check).
+// TODO(tzik): Cleanup existing use cases and remove
+// ScopedAllowCrossThreadRefCountAccess.
+class BASE_EXPORT ScopedAllowCrossThreadRefCountAccess final {
+ public:
+#if DCHECK_IS_ON()
+  ScopedAllowCrossThreadRefCountAccess();
+  ~ScopedAllowCrossThreadRefCountAccess();
+#else
+  ScopedAllowCrossThreadRefCountAccess() {}
+  ~ScopedAllowCrossThreadRefCountAccess() {}
+#endif
+};
+
+//
+// A base class for reference counted classes.  Otherwise, known as a cheap
+// knock-off of WebKit's RefCounted<T> class.  To use this, just extend your
+// class from it like so:
+//
+//   class MyFoo : public base::RefCounted<MyFoo> {
+//    ...
+//    private:
+//     friend class base::RefCounted<MyFoo>;
+//     ~MyFoo();
+//   };
+//
+// You should always make your destructor non-public, to avoid any code deleting
+// the object accidently while there are references to it.
+//
+//
+// The ref count manipulation to RefCounted is NOT thread safe and has DCHECKs
+// to trap unsafe cross thread usage. A subclass instance of RefCounted can be
+// passed to another execution sequence only when its ref count is 1. If the ref
+// count is more than 1, the RefCounted class verifies the ref updates are made
+// on the same execution sequence as the previous ones. The subclass can also
+// manually call IsOnValidSequence to trap other non-thread-safe accesses; see
+// the documentation for that method.
+//
+//
+// The reference count starts from zero by default, and we intended to migrate
+// to start-from-one ref count. Put REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE() to
+// the ref counted class to opt-in.
+//
+// If an object has start-from-one ref count, the first scoped_refptr need to be
+// created by base::AdoptRef() or base::MakeRefCounted(). We can use
+// base::MakeRefCounted() to create create both type of ref counted object.
+//
+// The motivations to use start-from-one ref count are:
+//  - Start-from-one ref count doesn't need the ref count increment for the
+//    first reference.
+//  - It can detect an invalid object acquisition for a being-deleted object
+//    that has zero ref count. That tends to happen on custom deleter that
+//    delays the deletion.
+//    TODO(tzik): Implement invalid acquisition detection.
+//  - Behavior parity to Blink's WTF::RefCounted, whose count starts from one.
+//    And start-from-one ref count is a step to merge WTF::RefCounted into
+//    base::RefCounted.
+//
+#define REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE()             \
+  static constexpr ::base::subtle::StartRefCountFromOneTag \
+      kRefCountPreference = ::base::subtle::kStartRefCountFromOneTag
+
+template <class T, typename Traits>
+class RefCounted;
+
+template <typename T>
+struct DefaultRefCountedTraits {
+  static void Destruct(const T* x) {
+    RefCounted<T, DefaultRefCountedTraits>::DeleteInternal(x);
+  }
+};
+
+template <class T, typename Traits = DefaultRefCountedTraits<T>>
+class RefCounted : public subtle::RefCountedBase {
+ public:
+  static constexpr subtle::StartRefCountFromZeroTag kRefCountPreference =
+      subtle::kStartRefCountFromZeroTag;
+
+  RefCounted() : subtle::RefCountedBase(T::kRefCountPreference) {}
+
+  void AddRef() const {
+    subtle::RefCountedBase::AddRef();
+  }
+
+  void Release() const {
+    if (subtle::RefCountedBase::Release()) {
+      // Prune the code paths which the static analyzer may take to simulate
+      // object destruction. Use-after-free errors aren't possible given the
+      // lifetime guarantees of the refcounting system.
+      ANALYZER_SKIP_THIS_PATH();
+
+      Traits::Destruct(static_cast<const T*>(this));
+    }
+  }
+
+ protected:
+  ~RefCounted() = default;
+
+ private:
+  friend struct DefaultRefCountedTraits<T>;
+  template <typename U>
+  static void DeleteInternal(const U* x) {
+    delete x;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(RefCounted);
+};
+
+// Forward declaration.
+template <class T, typename Traits> class RefCountedThreadSafe;
+
+// Default traits for RefCountedThreadSafe<T>.  Deletes the object when its ref
+// count reaches 0.  Overload to delete it on a different thread etc.
+template<typename T>
+struct DefaultRefCountedThreadSafeTraits {
+  static void Destruct(const T* x) {
+    // Delete through RefCountedThreadSafe to make child classes only need to be
+    // friend with RefCountedThreadSafe instead of this struct, which is an
+    // implementation detail.
+    RefCountedThreadSafe<T,
+                         DefaultRefCountedThreadSafeTraits>::DeleteInternal(x);
+  }
+};
+
+//
+// A thread-safe variant of RefCounted<T>
+//
+//   class MyFoo : public base::RefCountedThreadSafe<MyFoo> {
+//    ...
+//   };
+//
+// If you're using the default trait, then you should add compile time
+// asserts that no one else is deleting your object.  i.e.
+//    private:
+//     friend class base::RefCountedThreadSafe<MyFoo>;
+//     ~MyFoo();
+//
+// We can use REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE() with RefCountedThreadSafe
+// too. See the comment above the RefCounted definition for details.
+template <class T, typename Traits = DefaultRefCountedThreadSafeTraits<T> >
+class RefCountedThreadSafe : public subtle::RefCountedThreadSafeBase {
+ public:
+  static constexpr subtle::StartRefCountFromZeroTag kRefCountPreference =
+      subtle::kStartRefCountFromZeroTag;
+
+  explicit RefCountedThreadSafe()
+      : subtle::RefCountedThreadSafeBase(T::kRefCountPreference) {}
+
+  void AddRef() const {
+    subtle::RefCountedThreadSafeBase::AddRef();
+  }
+
+  void Release() const {
+    if (subtle::RefCountedThreadSafeBase::Release()) {
+      ANALYZER_SKIP_THIS_PATH();
+      Traits::Destruct(static_cast<const T*>(this));
+    }
+  }
+
+ protected:
+  ~RefCountedThreadSafe() = default;
+
+ private:
+  friend struct DefaultRefCountedThreadSafeTraits<T>;
+  template <typename U>
+  static void DeleteInternal(const U* x) {
+    delete x;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafe);
+};
+
+//
+// A thread-safe wrapper for some piece of data so we can place other
+// things in scoped_refptrs<>.
+//
+template<typename T>
+class RefCountedData
+    : public base::RefCountedThreadSafe< base::RefCountedData<T> > {
+ public:
+  RefCountedData() : data() {}
+  RefCountedData(const T& in_value) : data(in_value) {}
+  RefCountedData(T&& in_value) : data(std::move(in_value)) {}
+
+  T data;
+
+ private:
+  friend class base::RefCountedThreadSafe<base::RefCountedData<T> >;
+  ~RefCountedData() = default;
+};
+
+}  // namespace base
+
+#endif  // BASE_MEMORY_REF_COUNTED_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/scoped_refptr.h b/native/zucchini/vendor/libchrome/base/memory/scoped_refptr.h
new file mode 100644
index 0000000..389d0cb
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/memory/scoped_refptr.h
@@ -0,0 +1,337 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_MEMORY_SCOPED_REFPTR_H_
+#define BASE_MEMORY_SCOPED_REFPTR_H_
+
+#include <stddef.h>
+
+#include <iosfwd>
+#include <type_traits>
+#include <utility>
+
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/macros.h"
+
+template <class T>
+class scoped_refptr;
+
+namespace base {
+
+template <class, typename>
+class RefCounted;
+template <class, typename>
+class RefCountedThreadSafe;
+
+template <typename T>
+scoped_refptr<T> AdoptRef(T* t);
+
+namespace subtle {
+
+enum AdoptRefTag { kAdoptRefTag };
+enum StartRefCountFromZeroTag { kStartRefCountFromZeroTag };
+enum StartRefCountFromOneTag { kStartRefCountFromOneTag };
+
+template <typename T, typename U, typename V>
+constexpr bool IsRefCountPreferenceOverridden(const T*,
+                                              const RefCounted<U, V>*) {
+  return !std::is_same<std::decay_t<decltype(T::kRefCountPreference)>,
+                       std::decay_t<decltype(U::kRefCountPreference)>>::value;
+}
+
+template <typename T, typename U, typename V>
+constexpr bool IsRefCountPreferenceOverridden(
+    const T*,
+    const RefCountedThreadSafe<U, V>*) {
+  return !std::is_same<std::decay_t<decltype(T::kRefCountPreference)>,
+                       std::decay_t<decltype(U::kRefCountPreference)>>::value;
+}
+
+constexpr bool IsRefCountPreferenceOverridden(...) {
+  return false;
+}
+
+}  // namespace subtle
+
+// Creates a scoped_refptr from a raw pointer without incrementing the reference
+// count. Use this only for a newly created object whose reference count starts
+// from 1 instead of 0.
+template <typename T>
+scoped_refptr<T> AdoptRef(T* obj) {
+  using Tag = std::decay_t<decltype(T::kRefCountPreference)>;
+  static_assert(std::is_same<subtle::StartRefCountFromOneTag, Tag>::value,
+                "Use AdoptRef only for the reference count starts from one.");
+
+  DCHECK(obj);
+  DCHECK(obj->HasOneRef());
+  obj->Adopted();
+  return scoped_refptr<T>(obj, subtle::kAdoptRefTag);
+}
+
+namespace subtle {
+
+template <typename T>
+scoped_refptr<T> AdoptRefIfNeeded(T* obj, StartRefCountFromZeroTag) {
+  return scoped_refptr<T>(obj);
+}
+
+template <typename T>
+scoped_refptr<T> AdoptRefIfNeeded(T* obj, StartRefCountFromOneTag) {
+  return AdoptRef(obj);
+}
+
+}  // namespace subtle
+
+// Constructs an instance of T, which is a ref counted type, and wraps the
+// object into a scoped_refptr<T>.
+template <typename T, typename... Args>
+scoped_refptr<T> MakeRefCounted(Args&&... args) {
+  T* obj = new T(std::forward<Args>(args)...);
+  return subtle::AdoptRefIfNeeded(obj, T::kRefCountPreference);
+}
+
+// Takes an instance of T, which is a ref counted type, and wraps the object
+// into a scoped_refptr<T>.
+template <typename T>
+scoped_refptr<T> WrapRefCounted(T* t) {
+  return scoped_refptr<T>(t);
+}
+
+}  // namespace base
+
+//
+// A smart pointer class for reference counted objects.  Use this class instead
+// of calling AddRef and Release manually on a reference counted object to
+// avoid common memory leaks caused by forgetting to Release an object
+// reference.  Sample usage:
+//
+//   class MyFoo : public RefCounted<MyFoo> {
+//    ...
+//    private:
+//     friend class RefCounted<MyFoo>;  // Allow destruction by RefCounted<>.
+//     ~MyFoo();                        // Destructor must be private/protected.
+//   };
+//
+//   void some_function() {
+//     scoped_refptr<MyFoo> foo = MakeRefCounted<MyFoo>();
+//     foo->Method(param);
+//     // |foo| is released when this function returns
+//   }
+//
+//   void some_other_function() {
+//     scoped_refptr<MyFoo> foo = MakeRefCounted<MyFoo>();
+//     ...
+//     foo.reset();  // explicitly releases |foo|
+//     ...
+//     if (foo)
+//       foo->Method(param);
+//   }
+//
+// The above examples show how scoped_refptr<T> acts like a pointer to T.
+// Given two scoped_refptr<T> classes, it is also possible to exchange
+// references between the two objects, like so:
+//
+//   {
+//     scoped_refptr<MyFoo> a = MakeRefCounted<MyFoo>();
+//     scoped_refptr<MyFoo> b;
+//
+//     b.swap(a);
+//     // now, |b| references the MyFoo object, and |a| references nullptr.
+//   }
+//
+// To make both |a| and |b| in the above example reference the same MyFoo
+// object, simply use the assignment operator:
+//
+//   {
+//     scoped_refptr<MyFoo> a = MakeRefCounted<MyFoo>();
+//     scoped_refptr<MyFoo> b;
+//
+//     b = a;
+//     // now, |a| and |b| each own a reference to the same MyFoo object.
+//   }
+//
+// Also see Chromium's ownership and calling conventions:
+// https://chromium.googlesource.com/chromium/src/+/lkgr/styleguide/c++/c++.md#object-ownership-and-calling-conventions
+// Specifically:
+//   If the function (at least sometimes) takes a ref on a refcounted object,
+//   declare the param as scoped_refptr<T>. The caller can decide whether it
+//   wishes to transfer ownership (by calling std::move(t) when passing t) or
+//   retain its ref (by simply passing t directly).
+//   In other words, use scoped_refptr like you would a std::unique_ptr except
+//   in the odd case where it's required to hold on to a ref while handing one
+//   to another component (if a component merely needs to use t on the stack
+//   without keeping a ref: pass t as a raw T*).
+template <class T>
+class scoped_refptr {
+ public:
+  typedef T element_type;
+
+  constexpr scoped_refptr() = default;
+
+  // Constructs from raw pointer. constexpr if |p| is null.
+  constexpr scoped_refptr(T* p) : ptr_(p) {
+    if (ptr_)
+      AddRef(ptr_);
+  }
+
+  // Copy constructor. This is required in addition to the copy conversion
+  // constructor below.
+  scoped_refptr(const scoped_refptr& r) : scoped_refptr(r.ptr_) {}
+
+  // Copy conversion constructor.
+  template <typename U,
+            typename = typename std::enable_if<
+                std::is_convertible<U*, T*>::value>::type>
+  scoped_refptr(const scoped_refptr<U>& r) : scoped_refptr(r.ptr_) {}
+
+  // Move constructor. This is required in addition to the move conversion
+  // constructor below.
+  scoped_refptr(scoped_refptr&& r) noexcept : ptr_(r.ptr_) { r.ptr_ = nullptr; }
+
+  // Move conversion constructor.
+  template <typename U,
+            typename = typename std::enable_if<
+                std::is_convertible<U*, T*>::value>::type>
+  scoped_refptr(scoped_refptr<U>&& r) noexcept : ptr_(r.ptr_) {
+    r.ptr_ = nullptr;
+  }
+
+  ~scoped_refptr() {
+    static_assert(!base::subtle::IsRefCountPreferenceOverridden(
+                      static_cast<T*>(nullptr), static_cast<T*>(nullptr)),
+                  "It's unsafe to override the ref count preference."
+                  " Please remove REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE"
+                  " from subclasses.");
+    if (ptr_)
+      Release(ptr_);
+  }
+
+  T* get() const { return ptr_; }
+
+  T& operator*() const {
+    DCHECK(ptr_);
+    return *ptr_;
+  }
+
+  T* operator->() const {
+    DCHECK(ptr_);
+    return ptr_;
+  }
+
+  scoped_refptr& operator=(T* p) { return *this = scoped_refptr(p); }
+
+  // Unified assignment operator.
+  scoped_refptr& operator=(scoped_refptr r) noexcept {
+    swap(r);
+    return *this;
+  }
+
+  // Sets managed object to null and releases reference to the previous managed
+  // object, if it existed.
+  void reset() { scoped_refptr().swap(*this); }
+
+  void swap(scoped_refptr& r) noexcept { std::swap(ptr_, r.ptr_); }
+
+  explicit operator bool() const { return ptr_ != nullptr; }
+
+  template <typename U>
+  bool operator==(const scoped_refptr<U>& rhs) const {
+    return ptr_ == rhs.get();
+  }
+
+  template <typename U>
+  bool operator!=(const scoped_refptr<U>& rhs) const {
+    return !operator==(rhs);
+  }
+
+  template <typename U>
+  bool operator<(const scoped_refptr<U>& rhs) const {
+    return ptr_ < rhs.get();
+  }
+
+ protected:
+  T* ptr_ = nullptr;
+
+ private:
+  template <typename U>
+  friend scoped_refptr<U> base::AdoptRef(U*);
+
+  scoped_refptr(T* p, base::subtle::AdoptRefTag) : ptr_(p) {}
+
+  // Friend required for move constructors that set r.ptr_ to null.
+  template <typename U>
+  friend class scoped_refptr;
+
+  // Non-inline helpers to allow:
+  //     class Opaque;
+  //     extern template class scoped_refptr<Opaque>;
+  // Otherwise the compiler will complain that Opaque is an incomplete type.
+  static void AddRef(T* ptr);
+  static void Release(T* ptr);
+};
+
+// static
+template <typename T>
+void scoped_refptr<T>::AddRef(T* ptr) {
+  ptr->AddRef();
+}
+
+// static
+template <typename T>
+void scoped_refptr<T>::Release(T* ptr) {
+  ptr->Release();
+}
+
+template <typename T, typename U>
+bool operator==(const scoped_refptr<T>& lhs, const U* rhs) {
+  return lhs.get() == rhs;
+}
+
+template <typename T, typename U>
+bool operator==(const T* lhs, const scoped_refptr<U>& rhs) {
+  return lhs == rhs.get();
+}
+
+template <typename T>
+bool operator==(const scoped_refptr<T>& lhs, std::nullptr_t null) {
+  return !static_cast<bool>(lhs);
+}
+
+template <typename T>
+bool operator==(std::nullptr_t null, const scoped_refptr<T>& rhs) {
+  return !static_cast<bool>(rhs);
+}
+
+template <typename T, typename U>
+bool operator!=(const scoped_refptr<T>& lhs, const U* rhs) {
+  return !operator==(lhs, rhs);
+}
+
+template <typename T, typename U>
+bool operator!=(const T* lhs, const scoped_refptr<U>& rhs) {
+  return !operator==(lhs, rhs);
+}
+
+template <typename T>
+bool operator!=(const scoped_refptr<T>& lhs, std::nullptr_t null) {
+  return !operator==(lhs, null);
+}
+
+template <typename T>
+bool operator!=(std::nullptr_t null, const scoped_refptr<T>& rhs) {
+  return !operator==(null, rhs);
+}
+
+template <typename T>
+std::ostream& operator<<(std::ostream& out, const scoped_refptr<T>& p) {
+  return out << p.get();
+}
+
+template <typename T>
+void swap(scoped_refptr<T>& lhs, scoped_refptr<T>& rhs) noexcept {
+  lhs.swap(rhs);
+}
+
+#endif  // BASE_MEMORY_SCOPED_REFPTR_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/shared_memory.h b/native/zucchini/vendor/libchrome/base/memory/shared_memory.h
new file mode 100644
index 0000000..c573ef7
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/memory/shared_memory.h
@@ -0,0 +1,254 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_MEMORY_SHARED_MEMORY_H_
+#define BASE_MEMORY_SHARED_MEMORY_H_
+
+#include <stddef.h>
+
+#include <string>
+
+#include "base/base_export.h"
+#include "base/hash.h"
+#include "base/macros.h"
+#include "base/memory/shared_memory_handle.h"
+#include "base/process/process_handle.h"
+#include "base/strings/string16.h"
+#include "build/build_config.h"
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+#include <stdio.h>
+#include <sys/types.h>
+#include <semaphore.h>
+#include "base/file_descriptor_posix.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_file.h"
+#endif
+
+#if defined(OS_WIN)
+#include "base/win/scoped_handle.h"
+#endif
+
+namespace base {
+
+class FilePath;
+
+// Options for creating a shared memory object.
+struct BASE_EXPORT SharedMemoryCreateOptions {
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  // The type of OS primitive that should back the SharedMemory object.
+  SharedMemoryHandle::Type type = SharedMemoryHandle::MACH;
+#elif !defined(OS_FUCHSIA)
+  // DEPRECATED (crbug.com/345734):
+  // If NULL, the object is anonymous.  This pointer is owned by the caller
+  // and must live through the call to Create().
+  const std::string* name_deprecated = nullptr;
+
+  // DEPRECATED (crbug.com/345734):
+  // If true, and the shared memory already exists, Create() will open the
+  // existing shared memory and ignore the size parameter.  If false,
+  // shared memory must not exist.  This flag is meaningless unless
+  // name_deprecated is non-NULL.
+  bool open_existing_deprecated = false;
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+
+  // Size of the shared memory object to be created.
+  // When opening an existing object, this has no effect.
+  size_t size = 0;
+
+  // If true, mappings might need to be made executable later.
+  bool executable = false;
+
+  // If true, the file can be shared read-only to a process.
+  bool share_read_only = false;
+};
+
+// Platform abstraction for shared memory.
+// SharedMemory consumes a SharedMemoryHandle [potentially one that it created]
+// to map a shared memory OS resource into the virtual address space of the
+// current process.
+class BASE_EXPORT SharedMemory {
+ public:
+  SharedMemory();
+
+#if defined(OS_WIN)
+  // Similar to the default constructor, except that this allows for
+  // calling LockDeprecated() to acquire the named mutex before either Create or
+  // Open are called on Windows.
+  explicit SharedMemory(const string16& name);
+#endif
+
+  // Create a new SharedMemory object from an existing, open
+  // shared memory file.
+  //
+  // WARNING: This does not reduce the OS-level permissions on the handle; it
+  // only affects how the SharedMemory will be mmapped. Use
+  // GetReadOnlyHandle to drop permissions. TODO(jln,jyasskin): DCHECK
+  // that |read_only| matches the permissions of the handle.
+  SharedMemory(const SharedMemoryHandle& handle, bool read_only);
+
+  // Closes any open files.
+  ~SharedMemory();
+
+  // Return true iff the given handle is valid (i.e. not the distingished
+  // invalid value; NULL for a HANDLE and -1 for a file descriptor)
+  static bool IsHandleValid(const SharedMemoryHandle& handle);
+
+  // Closes a shared memory handle.
+  static void CloseHandle(const SharedMemoryHandle& handle);
+
+  // Returns the maximum number of handles that can be open at once per process.
+  static size_t GetHandleLimit();
+
+  // Duplicates The underlying OS primitive. Returns an invalid handle on
+  // failure. The caller is responsible for destroying the duplicated OS
+  // primitive.
+  static SharedMemoryHandle DuplicateHandle(const SharedMemoryHandle& handle);
+
+#if defined(OS_POSIX)
+  // This method requires that the SharedMemoryHandle is backed by a POSIX fd.
+  static int GetFdFromSharedMemoryHandle(const SharedMemoryHandle& handle);
+#endif
+
+  // Creates a shared memory object as described by the options struct.
+  // Returns true on success and false on failure.
+  bool Create(const SharedMemoryCreateOptions& options);
+
+  // Creates and maps an anonymous shared memory segment of size size.
+  // Returns true on success and false on failure.
+  bool CreateAndMapAnonymous(size_t size);
+
+  // Creates an anonymous shared memory segment of size size.
+  // Returns true on success and false on failure.
+  bool CreateAnonymous(size_t size) {
+    SharedMemoryCreateOptions options;
+    options.size = size;
+    return Create(options);
+  }
+
+#if (!defined(OS_MACOSX) || defined(OS_IOS)) && !defined(OS_FUCHSIA)
+  // DEPRECATED (crbug.com/345734):
+  // Creates or opens a shared memory segment based on a name.
+  // If open_existing is true, and the shared memory already exists,
+  // opens the existing shared memory and ignores the size parameter.
+  // If open_existing is false, shared memory must not exist.
+  // size is the size of the block to be created.
+  // Returns true on success, false on failure.
+  bool CreateNamedDeprecated(
+      const std::string& name, bool open_existing, size_t size) {
+    SharedMemoryCreateOptions options;
+    options.name_deprecated = &name;
+    options.open_existing_deprecated = open_existing;
+    options.size = size;
+    return Create(options);
+  }
+
+  // Deletes resources associated with a shared memory segment based on name.
+  // Not all platforms require this call.
+  bool Delete(const std::string& name);
+
+  // Opens a shared memory segment based on a name.
+  // If read_only is true, opens for read-only access.
+  // Returns true on success, false on failure.
+  bool Open(const std::string& name, bool read_only);
+#endif  // !defined(OS_MACOSX) || defined(OS_IOS)
+
+  // Maps the shared memory into the caller's address space.
+  // Returns true on success, false otherwise.  The memory address
+  // is accessed via the memory() accessor.  The mapped address is guaranteed to
+  // have an alignment of at least MAP_MINIMUM_ALIGNMENT. This method will fail
+  // if this object is currently mapped.
+  bool Map(size_t bytes) {
+    return MapAt(0, bytes);
+  }
+
+  // Same as above, but with |offset| to specify from begining of the shared
+  // memory block to map.
+  // |offset| must be alignent to value of |SysInfo::VMAllocationGranularity()|.
+  bool MapAt(off_t offset, size_t bytes);
+  enum { MAP_MINIMUM_ALIGNMENT = 32 };
+
+  // Unmaps the shared memory from the caller's address space.
+  // Returns true if successful; returns false on error or if the
+  // memory is not mapped.
+  bool Unmap();
+
+  // The size requested when the map is first created.
+  size_t requested_size() const { return requested_size_; }
+
+  // The actual size of the mapped memory (may be larger than requested).
+  size_t mapped_size() const { return mapped_size_; }
+
+  // Gets a pointer to the opened memory space if it has been
+  // Mapped via Map().  Returns NULL if it is not mapped.
+  void* memory() const { return memory_; }
+
+  // Returns the underlying OS handle for this segment.
+  // Use of this handle for anything other than an opaque
+  // identifier is not portable.
+  SharedMemoryHandle handle() const;
+
+  // Returns the underlying OS handle for this segment. The caller takes
+  // ownership of the handle and memory is unmapped. This is equivalent to
+  // duplicating the handle and then calling Unmap() and Close() on this object,
+  // without the overhead of duplicating the handle.
+  SharedMemoryHandle TakeHandle();
+
+  // Closes the open shared memory segment. The memory will remain mapped if
+  // it was previously mapped.
+  // It is safe to call Close repeatedly.
+  void Close();
+
+  // Returns a read-only handle to this shared memory region. The caller takes
+  // ownership of the handle. For POSIX handles, CHECK-fails if the region
+  // wasn't Created or Opened with share_read_only=true, which is required to
+  // make the handle read-only. When the handle is passed to the IPC subsystem,
+  // that takes ownership of the handle. As such, it's not valid to pass the
+  // sample handle to the IPC subsystem twice. Returns an invalid handle on
+  // failure.
+  SharedMemoryHandle GetReadOnlyHandle() const;
+
+  // Returns an ID for the mapped region. This is ID of the SharedMemoryHandle
+  // that was mapped. The ID is valid even after the SharedMemoryHandle is
+  // Closed, as long as the region is not unmapped.
+  const UnguessableToken& mapped_id() const { return mapped_id_; }
+
+ private:
+#if defined(OS_POSIX) && !defined(OS_NACL) && !defined(OS_ANDROID) && \
+    (!defined(OS_MACOSX) || defined(OS_IOS))
+  bool FilePathForMemoryName(const std::string& mem_name, FilePath* path);
+#endif
+
+#if defined(OS_WIN)
+  // If true indicates this came from an external source so needs extra checks
+  // before being mapped.
+  bool external_section_ = false;
+  string16 name_;
+#elif !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
+  // If valid, points to the same memory region as shm_, but with readonly
+  // permissions.
+  SharedMemoryHandle readonly_shm_;
+#endif
+
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  // The mechanism by which the memory is mapped. Only valid if |memory_| is not
+  // |nullptr|.
+  SharedMemoryHandle::Type mapped_memory_mechanism_ = SharedMemoryHandle::MACH;
+#endif
+
+  // The OS primitive that backs the shared memory region.
+  SharedMemoryHandle shm_;
+
+  size_t mapped_size_ = 0;
+  void* memory_ = nullptr;
+  bool read_only_ = false;
+  size_t requested_size_ = 0;
+  base::UnguessableToken mapped_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(SharedMemory);
+};
+
+}  // namespace base
+
+#endif  // BASE_MEMORY_SHARED_MEMORY_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/shared_memory_handle.h b/native/zucchini/vendor/libchrome/base/memory/shared_memory_handle.h
new file mode 100644
index 0000000..dd3d47a
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/memory/shared_memory_handle.h
@@ -0,0 +1,238 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_MEMORY_SHARED_MEMORY_HANDLE_H_
+#define BASE_MEMORY_SHARED_MEMORY_HANDLE_H_
+
+#include <stddef.h>
+
+#include "base/unguessable_token.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include "base/process/process_handle.h"
+#include "base/win/windows_types.h"
+#elif defined(OS_MACOSX) && !defined(OS_IOS)
+#include <mach/mach.h>
+#include "base/base_export.h"
+#include "base/file_descriptor_posix.h"
+#include "base/macros.h"
+#include "base/process/process_handle.h"
+#elif defined(OS_POSIX)
+#include <sys/types.h>
+#include "base/file_descriptor_posix.h"
+#elif defined(OS_FUCHSIA)
+#include <zircon/types.h>
+#endif
+
+namespace base {
+
+// SharedMemoryHandle is the smallest possible IPC-transportable "reference" to
+// a shared memory OS resource. A "reference" can be consumed exactly once [by
+// base::SharedMemory] to map the shared memory OS resource into the virtual
+// address space of the current process.
+// TODO(erikchen): This class should have strong ownership semantics to prevent
+// leaks of the underlying OS resource. https://crbug.com/640840.
+class BASE_EXPORT SharedMemoryHandle {
+ public:
+  // The default constructor returns an invalid SharedMemoryHandle.
+  SharedMemoryHandle();
+
+  // Standard copy constructor. The new instance shares the underlying OS
+  // primitives.
+  SharedMemoryHandle(const SharedMemoryHandle& handle);
+
+  // Standard assignment operator. The updated instance shares the underlying
+  // OS primitives.
+  SharedMemoryHandle& operator=(const SharedMemoryHandle& handle);
+
+  // Closes the underlying OS resource.
+  // The fact that this method needs to be "const" is an artifact of the
+  // original interface for base::SharedMemory::CloseHandle.
+  // TODO(erikchen): This doesn't clear the underlying reference, which seems
+  // like a bug, but is how this class has always worked. Fix this:
+  // https://crbug.com/716072.
+  void Close() const;
+
+  // Whether ownership of the underlying OS resource is implicitly passed to
+  // the IPC subsystem during serialization.
+  void SetOwnershipPassesToIPC(bool ownership_passes);
+  bool OwnershipPassesToIPC() const;
+
+  // Whether the underlying OS resource is valid.
+  bool IsValid() const;
+
+  // Duplicates the underlying OS resource. Using the return value as a
+  // parameter to an IPC message will cause the IPC subsystem to consume the OS
+  // resource.
+  SharedMemoryHandle Duplicate() const;
+
+  // Uniques identifies the shared memory region that the underlying OS resource
+  // points to. Multiple SharedMemoryHandles that point to the same shared
+  // memory region will have the same GUID. Preserved across IPC.
+  base::UnguessableToken GetGUID() const;
+
+  // Returns the size of the memory region that SharedMemoryHandle points to.
+  size_t GetSize() const;
+
+#if defined(OS_WIN)
+  // Takes implicit ownership of |h|.
+  // |guid| uniquely identifies the shared memory region pointed to by the
+  // underlying OS resource. If the HANDLE is associated with another
+  // SharedMemoryHandle, the caller must pass the |guid| of that
+  // SharedMemoryHandle. Otherwise, the caller should generate a new
+  // UnguessableToken.
+  // Passing the wrong |size| has no immediate consequence, but may cause errors
+  // when trying to map the SharedMemoryHandle at a later point in time.
+  SharedMemoryHandle(HANDLE h, size_t size, const base::UnguessableToken& guid);
+  HANDLE GetHandle() const;
+#elif defined(OS_FUCHSIA)
+  // Takes implicit ownership of |h|.
+  // |guid| uniquely identifies the shared memory region pointed to by the
+  // underlying OS resource. If the zx_handle_t is associated with another
+  // SharedMemoryHandle, the caller must pass the |guid| of that
+  // SharedMemoryHandle. Otherwise, the caller should generate a new
+  // UnguessableToken.
+  // Passing the wrong |size| has no immediate consequence, but may cause errors
+  // when trying to map the SharedMemoryHandle at a later point in time.
+  SharedMemoryHandle(zx_handle_t h,
+                     size_t size,
+                     const base::UnguessableToken& guid);
+  zx_handle_t GetHandle() const;
+#elif defined(OS_MACOSX) && !defined(OS_IOS)
+  enum Type {
+    // The SharedMemoryHandle is backed by a POSIX fd.
+    POSIX,
+    // The SharedMemoryHandle is backed by the Mach primitive "memory object".
+    MACH,
+  };
+
+  // Makes a Mach-based SharedMemoryHandle of the given size. On error,
+  // subsequent calls to IsValid() return false.
+  // Passing the wrong |size| has no immediate consequence, but may cause errors
+  // when trying to map the SharedMemoryHandle at a later point in time.
+  SharedMemoryHandle(mach_vm_size_t size, const base::UnguessableToken& guid);
+
+  // Makes a Mach-based SharedMemoryHandle from |memory_object|, a named entry
+  // in the current task. The memory region has size |size|.
+  // Passing the wrong |size| has no immediate consequence, but may cause errors
+  // when trying to map the SharedMemoryHandle at a later point in time.
+  SharedMemoryHandle(mach_port_t memory_object,
+                     mach_vm_size_t size,
+                     const base::UnguessableToken& guid);
+
+  // Exposed so that the SharedMemoryHandle can be transported between
+  // processes.
+  mach_port_t GetMemoryObject() const;
+
+  // The SharedMemoryHandle must be valid.
+  // Returns whether the SharedMemoryHandle was successfully mapped into memory.
+  // On success, |memory| is an output variable that contains the start of the
+  // mapped memory.
+  bool MapAt(off_t offset, size_t bytes, void** memory, bool read_only);
+#elif defined(OS_POSIX)
+  // Creates a SharedMemoryHandle from an |fd| supplied from an external
+  // service.
+  // Passing the wrong |size| has no immediate consequence, but may cause errors
+  // when trying to map the SharedMemoryHandle at a later point in time.
+  static SharedMemoryHandle ImportHandle(int fd, size_t size);
+
+  // Returns the underlying OS resource.
+  int GetHandle() const;
+
+  // Invalidates [but doesn't close] the underlying OS resource. This will leak
+  // unless the caller is careful.
+  int Release();
+#endif
+
+#if defined(OS_ANDROID)
+  // Marks the current file descriptor as read-only, for the purpose of
+  // mapping. This is independent of the region's read-only status.
+  void SetReadOnly() { read_only_ = true; }
+
+  // Returns true iff the descriptor is to be used for read-only
+  // mappings.
+  bool IsReadOnly() const { return read_only_; }
+
+  // Returns true iff the corresponding region is read-only.
+  bool IsRegionReadOnly() const;
+
+  // Try to set the region read-only. This will fail any future attempt
+  // at read-write mapping.
+  bool SetRegionReadOnly() const;
+#endif
+
+#if defined(OS_POSIX)
+  // Constructs a SharedMemoryHandle backed by a FileDescriptor. The newly
+  // created instance has the same ownership semantics as base::FileDescriptor.
+  // This typically means that the SharedMemoryHandle takes ownership of the
+  // |fd| if |auto_close| is true. Unfortunately, it's common for existing code
+  // to make shallow copies of SharedMemoryHandle, and the one that is finally
+  // passed into a base::SharedMemory is the one that "consumes" the fd.
+  //
+  // |guid| uniquely identifies the shared memory region pointed to by the
+  // underlying OS resource. If |file_descriptor| is associated with another
+  // SharedMemoryHandle, the caller must pass the |guid| of that
+  // SharedMemoryHandle. Otherwise, the caller should generate a new
+  // UnguessableToken.
+  // Passing the wrong |size| has no immediate consequence, but may cause errors
+  // when trying to map the SharedMemoryHandle at a later point in time.
+  SharedMemoryHandle(const base::FileDescriptor& file_descriptor,
+                     size_t size,
+                     const base::UnguessableToken& guid);
+#endif
+
+ private:
+#if defined(OS_WIN)
+  HANDLE handle_ = nullptr;
+
+  // Whether passing this object as a parameter to an IPC message passes
+  // ownership of |handle_| to the IPC stack. This is meant to mimic the
+  // behavior of the |auto_close| parameter of FileDescriptor. This member only
+  // affects attachment-brokered SharedMemoryHandles.
+  // Defaults to |false|.
+  bool ownership_passes_to_ipc_ = false;
+#elif defined(OS_FUCHSIA)
+  zx_handle_t handle_ = ZX_HANDLE_INVALID;
+  bool ownership_passes_to_ipc_ = false;
+#elif defined(OS_MACOSX) && !defined(OS_IOS)
+  friend class SharedMemory;
+  friend bool CheckReadOnlySharedMemoryHandleForTesting(
+      SharedMemoryHandle handle);
+
+  Type type_ = MACH;
+
+  // Each instance of a SharedMemoryHandle is backed either by a POSIX fd or a
+  // mach port. |type_| determines the backing member.
+  union {
+    FileDescriptor file_descriptor_;
+
+    struct {
+      mach_port_t memory_object_ = MACH_PORT_NULL;
+
+      // Whether passing this object as a parameter to an IPC message passes
+      // ownership of |memory_object_| to the IPC stack. This is meant to mimic
+      // the behavior of the |auto_close| parameter of FileDescriptor.
+      // Defaults to |false|.
+      bool ownership_passes_to_ipc_ = false;
+    };
+  };
+#elif defined(OS_ANDROID)
+  friend class SharedMemory;
+
+  FileDescriptor file_descriptor_;
+  bool read_only_ = false;
+#elif defined(OS_POSIX)
+  FileDescriptor file_descriptor_;
+#endif
+
+  base::UnguessableToken guid_;
+
+  // The size of the region referenced by the SharedMemoryHandle.
+  size_t size_ = 0;
+};
+
+}  // namespace base
+
+#endif  // BASE_MEMORY_SHARED_MEMORY_HANDLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/singleton.h b/native/zucchini/vendor/libchrome/base/memory/singleton.h
new file mode 100644
index 0000000..880ef0a
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/memory/singleton.h
@@ -0,0 +1,262 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// PLEASE READ: Do you really need a singleton? If possible, use a
+// function-local static of type base::NoDestructor<T> instead:
+//
+// Factory& Factory::GetInstance() {
+//   static base::NoDestructor<Factory> instance;
+//   return *instance;
+// }
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+//
+// Singletons make it hard to determine the lifetime of an object, which can
+// lead to buggy code and spurious crashes.
+//
+// Instead of adding another singleton into the mix, try to identify either:
+//   a) An existing singleton that can manage your object's lifetime
+//   b) Locations where you can deterministically create the object and pass
+//      into other objects
+//
+// If you absolutely need a singleton, please keep them as trivial as possible
+// and ideally a leaf dependency. Singletons get problematic when they attempt
+// to do too much in their destructor or have circular dependencies.
+
+#ifndef BASE_MEMORY_SINGLETON_H_
+#define BASE_MEMORY_SINGLETON_H_
+
+#include "base/at_exit.h"
+#include "base/atomicops.h"
+#include "base/base_export.h"
+#include "base/lazy_instance_helpers.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/threading/thread_restrictions.h"
+
+namespace base {
+
+// Default traits for Singleton<Type>. Calls operator new and operator delete on
+// the object. Registers automatic deletion at process exit.
+// Overload if you need arguments or another memory allocation function.
+template<typename Type>
+struct DefaultSingletonTraits {
+  // Allocates the object.
+  static Type* New() {
+    // The parenthesis is very important here; it forces POD type
+    // initialization.
+    return new Type();
+  }
+
+  // Destroys the object.
+  static void Delete(Type* x) {
+    delete x;
+  }
+
+  // Set to true to automatically register deletion of the object on process
+  // exit. See below for the required call that makes this happen.
+  static const bool kRegisterAtExit = true;
+
+#if DCHECK_IS_ON()
+  // Set to false to disallow access on a non-joinable thread.  This is
+  // different from kRegisterAtExit because StaticMemorySingletonTraits allows
+  // access on non-joinable threads, and gracefully handles this.
+  static const bool kAllowedToAccessOnNonjoinableThread = false;
+#endif
+};
+
+
+// Alternate traits for use with the Singleton<Type>.  Identical to
+// DefaultSingletonTraits except that the Singleton will not be cleaned up
+// at exit.
+template<typename Type>
+struct LeakySingletonTraits : public DefaultSingletonTraits<Type> {
+  static const bool kRegisterAtExit = false;
+#if DCHECK_IS_ON()
+  static const bool kAllowedToAccessOnNonjoinableThread = true;
+#endif
+};
+
+// Alternate traits for use with the Singleton<Type>.  Allocates memory
+// for the singleton instance from a static buffer.  The singleton will
+// be cleaned up at exit, but can't be revived after destruction unless
+// the ResurrectForTesting() method is called.
+//
+// This is useful for a certain category of things, notably logging and
+// tracing, where the singleton instance is of a type carefully constructed to
+// be safe to access post-destruction.
+// In logging and tracing you'll typically get stray calls at odd times, like
+// during static destruction, thread teardown and the like, and there's a
+// termination race on the heap-based singleton - e.g. if one thread calls
+// get(), but then another thread initiates AtExit processing, the first thread
+// may call into an object residing in unallocated memory. If the instance is
+// allocated from the data segment, then this is survivable.
+//
+// The destructor is to deallocate system resources, in this case to unregister
+// a callback the system will invoke when logging levels change. Note that
+// this is also used in e.g. Chrome Frame, where you have to allow for the
+// possibility of loading briefly into someone else's process space, and
+// so leaking is not an option, as that would sabotage the state of your host
+// process once you've unloaded.
+template <typename Type>
+struct StaticMemorySingletonTraits {
+  // WARNING: User has to support a New() which returns null.
+  static Type* New() {
+    // Only constructs once and returns pointer; otherwise returns null.
+    if (subtle::NoBarrier_AtomicExchange(&dead_, 1))
+      return nullptr;
+
+    return new (buffer_) Type();
+  }
+
+  static void Delete(Type* p) {
+    if (p)
+      p->Type::~Type();
+  }
+
+  static const bool kRegisterAtExit = true;
+
+#if DCHECK_IS_ON()
+  static const bool kAllowedToAccessOnNonjoinableThread = true;
+#endif
+
+  static void ResurrectForTesting() { subtle::NoBarrier_Store(&dead_, 0); }
+
+ private:
+  alignas(Type) static char buffer_[sizeof(Type)];
+  // Signal the object was already deleted, so it is not revived.
+  static subtle::Atomic32 dead_;
+};
+
+template <typename Type>
+alignas(Type) char StaticMemorySingletonTraits<Type>::buffer_[sizeof(Type)];
+template <typename Type>
+subtle::Atomic32 StaticMemorySingletonTraits<Type>::dead_ = 0;
+
+// The Singleton<Type, Traits, DifferentiatingType> class manages a single
+// instance of Type which will be created on first use and will be destroyed at
+// normal process exit). The Trait::Delete function will not be called on
+// abnormal process exit.
+//
+// DifferentiatingType is used as a key to differentiate two different
+// singletons having the same memory allocation functions but serving a
+// different purpose. This is mainly used for Locks serving different purposes.
+//
+// Example usage:
+//
+// In your header:
+//   namespace base {
+//   template <typename T>
+//   struct DefaultSingletonTraits;
+//   }
+//   class FooClass {
+//    public:
+//     static FooClass* GetInstance();  <-- See comment below on this.
+//     void Bar() { ... }
+//    private:
+//     FooClass() { ... }
+//     friend struct base::DefaultSingletonTraits<FooClass>;
+//
+//     DISALLOW_COPY_AND_ASSIGN(FooClass);
+//   };
+//
+// In your source file:
+//  #include "base/memory/singleton.h"
+//  FooClass* FooClass::GetInstance() {
+//    return base::Singleton<FooClass>::get();
+//  }
+//
+// Or for leaky singletons:
+//  #include "base/memory/singleton.h"
+//  FooClass* FooClass::GetInstance() {
+//    return base::Singleton<
+//        FooClass, base::LeakySingletonTraits<FooClass>>::get();
+//  }
+//
+// And to call methods on FooClass:
+//   FooClass::GetInstance()->Bar();
+//
+// NOTE: The method accessing Singleton<T>::get() has to be named as GetInstance
+// and it is important that FooClass::GetInstance() is not inlined in the
+// header. This makes sure that when source files from multiple targets include
+// this header they don't end up with different copies of the inlined code
+// creating multiple copies of the singleton.
+//
+// Singleton<> has no non-static members and doesn't need to actually be
+// instantiated.
+//
+// This class is itself thread-safe. The underlying Type must of course be
+// thread-safe if you want to use it concurrently. Two parameters may be tuned
+// depending on the user's requirements.
+//
+// Glossary:
+//   RAE = kRegisterAtExit
+//
+// On every platform, if Traits::RAE is true, the singleton will be destroyed at
+// process exit. More precisely it uses AtExitManager which requires an
+// object of this type to be instantiated. AtExitManager mimics the semantics
+// of atexit() such as LIFO order but under Windows is safer to call. For more
+// information see at_exit.h.
+//
+// If Traits::RAE is false, the singleton will not be freed at process exit,
+// thus the singleton will be leaked if it is ever accessed. Traits::RAE
+// shouldn't be false unless absolutely necessary. Remember that the heap where
+// the object is allocated may be destroyed by the CRT anyway.
+//
+// Caveats:
+// (a) Every call to get(), operator->() and operator*() incurs some overhead
+//     (16ns on my P4/2.8GHz) to check whether the object has already been
+//     initialized.  You may wish to cache the result of get(); it will not
+//     change.
+//
+// (b) Your factory function must never throw an exception. This class is not
+//     exception-safe.
+//
+
+template <typename Type,
+          typename Traits = DefaultSingletonTraits<Type>,
+          typename DifferentiatingType = Type>
+class Singleton {
+ private:
+  // Classes using the Singleton<T> pattern should declare a GetInstance()
+  // method and call Singleton::get() from within that.
+  friend Type* Type::GetInstance();
+
+  // This class is safe to be constructed and copy-constructed since it has no
+  // member.
+
+  // Return a pointer to the one true instance of the class.
+  static Type* get() {
+#if DCHECK_IS_ON()
+    if (!Traits::kAllowedToAccessOnNonjoinableThread)
+      ThreadRestrictions::AssertSingletonAllowed();
+#endif
+
+    return subtle::GetOrCreateLazyPointer(
+        &instance_, &CreatorFunc, nullptr,
+        Traits::kRegisterAtExit ? OnExit : nullptr, nullptr);
+  }
+
+  // Internal method used as an adaptor for GetOrCreateLazyPointer(). Do not use
+  // outside of that use case.
+  static Type* CreatorFunc(void* /* creator_arg*/) { return Traits::New(); }
+
+  // Adapter function for use with AtExit().  This should be called single
+  // threaded, so don't use atomic operations.
+  // Calling OnExit while singleton is in use by other threads is a mistake.
+  static void OnExit(void* /*unused*/) {
+    // AtExit should only ever be register after the singleton instance was
+    // created.  We should only ever get here with a valid instance_ pointer.
+    Traits::Delete(reinterpret_cast<Type*>(subtle::NoBarrier_Load(&instance_)));
+    instance_ = 0;
+  }
+  static subtle::AtomicWord instance_;
+};
+
+template <typename Type, typename Traits, typename DifferentiatingType>
+subtle::AtomicWord Singleton<Type, Traits, DifferentiatingType>::instance_ = 0;
+
+}  // namespace base
+
+#endif  // BASE_MEMORY_SINGLETON_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/weak_ptr.h b/native/zucchini/vendor/libchrome/base/memory/weak_ptr.h
new file mode 100644
index 0000000..34e7d2e
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/memory/weak_ptr.h
@@ -0,0 +1,377 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Weak pointers are pointers to an object that do not affect its lifetime,
+// and which may be invalidated (i.e. reset to nullptr) by the object, or its
+// owner, at any time, most commonly when the object is about to be deleted.
+
+// Weak pointers are useful when an object needs to be accessed safely by one
+// or more objects other than its owner, and those callers can cope with the
+// object vanishing and e.g. tasks posted to it being silently dropped.
+// Reference-counting such an object would complicate the ownership graph and
+// make it harder to reason about the object's lifetime.
+
+// EXAMPLE:
+//
+//  class Controller {
+//   public:
+//    Controller() : weak_factory_(this) {}
+//    void SpawnWorker() { Worker::StartNew(weak_factory_.GetWeakPtr()); }
+//    void WorkComplete(const Result& result) { ... }
+//   private:
+//    // Member variables should appear before the WeakPtrFactory, to ensure
+//    // that any WeakPtrs to Controller are invalidated before its members
+//    // variable's destructors are executed, rendering them invalid.
+//    WeakPtrFactory<Controller> weak_factory_;
+//  };
+//
+//  class Worker {
+//   public:
+//    static void StartNew(const WeakPtr<Controller>& controller) {
+//      Worker* worker = new Worker(controller);
+//      // Kick off asynchronous processing...
+//    }
+//   private:
+//    Worker(const WeakPtr<Controller>& controller)
+//        : controller_(controller) {}
+//    void DidCompleteAsynchronousProcessing(const Result& result) {
+//      if (controller_)
+//        controller_->WorkComplete(result);
+//    }
+//    WeakPtr<Controller> controller_;
+//  };
+//
+// With this implementation a caller may use SpawnWorker() to dispatch multiple
+// Workers and subsequently delete the Controller, without waiting for all
+// Workers to have completed.
+
+// ------------------------- IMPORTANT: Thread-safety -------------------------
+
+// Weak pointers may be passed safely between threads, but must always be
+// dereferenced and invalidated on the same SequencedTaskRunner otherwise
+// checking the pointer would be racey.
+//
+// To ensure correct use, the first time a WeakPtr issued by a WeakPtrFactory
+// is dereferenced, the factory and its WeakPtrs become bound to the calling
+// thread or current SequencedWorkerPool token, and cannot be dereferenced or
+// invalidated on any other task runner. Bound WeakPtrs can still be handed
+// off to other task runners, e.g. to use to post tasks back to object on the
+// bound sequence.
+//
+// If all WeakPtr objects are destroyed or invalidated then the factory is
+// unbound from the SequencedTaskRunner/Thread. The WeakPtrFactory may then be
+// destroyed, or new WeakPtr objects may be used, from a different sequence.
+//
+// Thus, at least one WeakPtr object must exist and have been dereferenced on
+// the correct thread to enforce that other WeakPtr objects will enforce they
+// are used on the desired thread.
+
+#ifndef BASE_MEMORY_WEAK_PTR_H_
+#define BASE_MEMORY_WEAK_PTR_H_
+
+#include <cstddef>
+#include <type_traits>
+
+#include "base/base_export.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/sequence_checker.h"
+
+namespace base {
+
+template <typename T> class SupportsWeakPtr;
+template <typename T> class WeakPtr;
+
+namespace internal {
+// These classes are part of the WeakPtr implementation.
+// DO NOT USE THESE CLASSES DIRECTLY YOURSELF.
+
+class BASE_EXPORT WeakReference {
+ public:
+  // Although Flag is bound to a specific SequencedTaskRunner, it may be
+  // deleted from another via base::WeakPtr::~WeakPtr().
+  class BASE_EXPORT Flag : public RefCountedThreadSafe<Flag> {
+   public:
+    Flag();
+
+    void Invalidate();
+    bool IsValid() const;
+
+   private:
+    friend class base::RefCountedThreadSafe<Flag>;
+
+    ~Flag();
+
+    SequenceChecker sequence_checker_;
+    bool is_valid_;
+  };
+
+  WeakReference();
+  explicit WeakReference(const scoped_refptr<Flag>& flag);
+  ~WeakReference();
+
+  WeakReference(WeakReference&& other);
+  WeakReference(const WeakReference& other);
+  WeakReference& operator=(WeakReference&& other) = default;
+  WeakReference& operator=(const WeakReference& other) = default;
+
+  bool is_valid() const;
+
+ private:
+  scoped_refptr<const Flag> flag_;
+};
+
+class BASE_EXPORT WeakReferenceOwner {
+ public:
+  WeakReferenceOwner();
+  ~WeakReferenceOwner();
+
+  WeakReference GetRef() const;
+
+  bool HasRefs() const { return flag_ && !flag_->HasOneRef(); }
+
+  void Invalidate();
+
+ private:
+  mutable scoped_refptr<WeakReference::Flag> flag_;
+};
+
+// This class simplifies the implementation of WeakPtr's type conversion
+// constructor by avoiding the need for a public accessor for ref_.  A
+// WeakPtr<T> cannot access the private members of WeakPtr<U>, so this
+// base class gives us a way to access ref_ in a protected fashion.
+class BASE_EXPORT WeakPtrBase {
+ public:
+  WeakPtrBase();
+  ~WeakPtrBase();
+
+  WeakPtrBase(const WeakPtrBase& other) = default;
+  WeakPtrBase(WeakPtrBase&& other) = default;
+  WeakPtrBase& operator=(const WeakPtrBase& other) = default;
+  WeakPtrBase& operator=(WeakPtrBase&& other) = default;
+
+  void reset() {
+    ref_ = internal::WeakReference();
+    ptr_ = 0;
+  }
+
+ protected:
+  WeakPtrBase(const WeakReference& ref, uintptr_t ptr);
+
+  WeakReference ref_;
+
+  // This pointer is only valid when ref_.is_valid() is true.  Otherwise, its
+  // value is undefined (as opposed to nullptr).
+  uintptr_t ptr_;
+};
+
+// This class provides a common implementation of common functions that would
+// otherwise get instantiated separately for each distinct instantiation of
+// SupportsWeakPtr<>.
+class SupportsWeakPtrBase {
+ public:
+  // A safe static downcast of a WeakPtr<Base> to WeakPtr<Derived>. This
+  // conversion will only compile if there is exists a Base which inherits
+  // from SupportsWeakPtr<Base>. See base::AsWeakPtr() below for a helper
+  // function that makes calling this easier.
+  //
+  // Precondition: t != nullptr
+  template<typename Derived>
+  static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {
+    static_assert(
+        std::is_base_of<internal::SupportsWeakPtrBase, Derived>::value,
+        "AsWeakPtr argument must inherit from SupportsWeakPtr");
+    return AsWeakPtrImpl<Derived>(t);
+  }
+
+ private:
+  // This template function uses type inference to find a Base of Derived
+  // which is an instance of SupportsWeakPtr<Base>. We can then safely
+  // static_cast the Base* to a Derived*.
+  template <typename Derived, typename Base>
+  static WeakPtr<Derived> AsWeakPtrImpl(SupportsWeakPtr<Base>* t) {
+    WeakPtr<Base> ptr = t->AsWeakPtr();
+    return WeakPtr<Derived>(
+        ptr.ref_, static_cast<Derived*>(reinterpret_cast<Base*>(ptr.ptr_)));
+  }
+};
+
+}  // namespace internal
+
+template <typename T> class WeakPtrFactory;
+
+// The WeakPtr class holds a weak reference to |T*|.
+//
+// This class is designed to be used like a normal pointer.  You should always
+// null-test an object of this class before using it or invoking a method that
+// may result in the underlying object being destroyed.
+//
+// EXAMPLE:
+//
+//   class Foo { ... };
+//   WeakPtr<Foo> foo;
+//   if (foo)
+//     foo->method();
+//
+template <typename T>
+class WeakPtr : public internal::WeakPtrBase {
+ public:
+  WeakPtr() = default;
+
+  WeakPtr(std::nullptr_t) {}
+
+  // Allow conversion from U to T provided U "is a" T. Note that this
+  // is separate from the (implicit) copy and move constructors.
+  template <typename U>
+  WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other) {
+    // Need to cast from U* to T* to do pointer adjustment in case of multiple
+    // inheritance. This also enforces the "U is a T" rule.
+    T* t = reinterpret_cast<U*>(other.ptr_);
+    ptr_ = reinterpret_cast<uintptr_t>(t);
+  }
+  template <typename U>
+  WeakPtr(WeakPtr<U>&& other) : WeakPtrBase(std::move(other)) {
+    // Need to cast from U* to T* to do pointer adjustment in case of multiple
+    // inheritance. This also enforces the "U is a T" rule.
+    T* t = reinterpret_cast<U*>(other.ptr_);
+    ptr_ = reinterpret_cast<uintptr_t>(t);
+  }
+
+  T* get() const {
+    return ref_.is_valid() ? reinterpret_cast<T*>(ptr_) : nullptr;
+  }
+
+  T& operator*() const {
+    DCHECK(get() != nullptr);
+    return *get();
+  }
+  T* operator->() const {
+    DCHECK(get() != nullptr);
+    return get();
+  }
+
+  // Allow conditionals to test validity, e.g. if (weak_ptr) {...};
+  explicit operator bool() const { return get() != nullptr; }
+
+ private:
+  friend class internal::SupportsWeakPtrBase;
+  template <typename U> friend class WeakPtr;
+  friend class SupportsWeakPtr<T>;
+  friend class WeakPtrFactory<T>;
+
+  WeakPtr(const internal::WeakReference& ref, T* ptr)
+      : WeakPtrBase(ref, reinterpret_cast<uintptr_t>(ptr)) {}
+};
+
+// Allow callers to compare WeakPtrs against nullptr to test validity.
+template <class T>
+bool operator!=(const WeakPtr<T>& weak_ptr, std::nullptr_t) {
+  return !(weak_ptr == nullptr);
+}
+template <class T>
+bool operator!=(std::nullptr_t, const WeakPtr<T>& weak_ptr) {
+  return weak_ptr != nullptr;
+}
+template <class T>
+bool operator==(const WeakPtr<T>& weak_ptr, std::nullptr_t) {
+  return weak_ptr.get() == nullptr;
+}
+template <class T>
+bool operator==(std::nullptr_t, const WeakPtr<T>& weak_ptr) {
+  return weak_ptr == nullptr;
+}
+
+namespace internal {
+class BASE_EXPORT WeakPtrFactoryBase {
+ protected:
+  WeakPtrFactoryBase(uintptr_t ptr);
+  ~WeakPtrFactoryBase();
+  internal::WeakReferenceOwner weak_reference_owner_;
+  uintptr_t ptr_;
+};
+}  // namespace internal
+
+// A class may be composed of a WeakPtrFactory and thereby
+// control how it exposes weak pointers to itself.  This is helpful if you only
+// need weak pointers within the implementation of a class.  This class is also
+// useful when working with primitive types.  For example, you could have a
+// WeakPtrFactory<bool> that is used to pass around a weak reference to a bool.
+template <class T>
+class WeakPtrFactory : public internal::WeakPtrFactoryBase {
+ public:
+  explicit WeakPtrFactory(T* ptr)
+      : WeakPtrFactoryBase(reinterpret_cast<uintptr_t>(ptr)) {}
+
+  ~WeakPtrFactory() = default;
+
+  WeakPtr<T> GetWeakPtr() {
+    return WeakPtr<T>(weak_reference_owner_.GetRef(),
+                      reinterpret_cast<T*>(ptr_));
+  }
+
+  // Call this method to invalidate all existing weak pointers.
+  void InvalidateWeakPtrs() {
+    DCHECK(ptr_);
+    weak_reference_owner_.Invalidate();
+  }
+
+  // Call this method to determine if any weak pointers exist.
+  bool HasWeakPtrs() const {
+    DCHECK(ptr_);
+    return weak_reference_owner_.HasRefs();
+  }
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory);
+};
+
+// A class may extend from SupportsWeakPtr to let others take weak pointers to
+// it. This avoids the class itself implementing boilerplate to dispense weak
+// pointers.  However, since SupportsWeakPtr's destructor won't invalidate
+// weak pointers to the class until after the derived class' members have been
+// destroyed, its use can lead to subtle use-after-destroy issues.
+template <class T>
+class SupportsWeakPtr : public internal::SupportsWeakPtrBase {
+ public:
+  SupportsWeakPtr() = default;
+
+  WeakPtr<T> AsWeakPtr() {
+    return WeakPtr<T>(weak_reference_owner_.GetRef(), static_cast<T*>(this));
+  }
+
+ protected:
+  ~SupportsWeakPtr() = default;
+
+ private:
+  internal::WeakReferenceOwner weak_reference_owner_;
+  DISALLOW_COPY_AND_ASSIGN(SupportsWeakPtr);
+};
+
+// Helper function that uses type deduction to safely return a WeakPtr<Derived>
+// when Derived doesn't directly extend SupportsWeakPtr<Derived>, instead it
+// extends a Base that extends SupportsWeakPtr<Base>.
+//
+// EXAMPLE:
+//   class Base : public base::SupportsWeakPtr<Producer> {};
+//   class Derived : public Base {};
+//
+//   Derived derived;
+//   base::WeakPtr<Derived> ptr = base::AsWeakPtr(&derived);
+//
+// Note that the following doesn't work (invalid type conversion) since
+// Derived::AsWeakPtr() is WeakPtr<Base> SupportsWeakPtr<Base>::AsWeakPtr(),
+// and there's no way to safely cast WeakPtr<Base> to WeakPtr<Derived> at
+// the caller.
+//
+//   base::WeakPtr<Derived> ptr = derived.AsWeakPtr();  // Fails.
+
+template <typename Derived>
+WeakPtr<Derived> AsWeakPtr(Derived* t) {
+  return internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);
+}
+
+}  // namespace base
+
+#endif  // BASE_MEMORY_WEAK_PTR_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/bucket_ranges.h b/native/zucchini/vendor/libchrome/base/metrics/bucket_ranges.h
new file mode 100644
index 0000000..1b6d069
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/metrics/bucket_ranges.h
@@ -0,0 +1,105 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// BucketRanges stores the vector of ranges that delimit what samples are
+// tallied in the corresponding buckets of a histogram. Histograms that have
+// same ranges for all their corresponding buckets should share the same
+// BucketRanges object.
+//
+// E.g. A 5 buckets LinearHistogram with 1 as minimal value and 4 as maximal
+// value will need a BucketRanges with 6 ranges:
+// 0, 1, 2, 3, 4, INT_MAX
+//
+// TODO(kaiwang): Currently we keep all negative values in 0~1 bucket. Consider
+// changing 0 to INT_MIN.
+
+#ifndef BASE_METRICS_BUCKET_RANGES_H_
+#define BASE_METRICS_BUCKET_RANGES_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <vector>
+
+#include <limits.h>
+
+#include "base/atomicops.h"
+#include "base/base_export.h"
+#include "base/macros.h"
+#include "base/metrics/histogram_base.h"
+
+namespace base {
+
+class BASE_EXPORT BucketRanges {
+ public:
+  typedef std::vector<HistogramBase::Sample> Ranges;
+
+  explicit BucketRanges(size_t num_ranges);
+  ~BucketRanges();
+
+  size_t size() const { return ranges_.size(); }
+  HistogramBase::Sample range(size_t i) const { return ranges_[i]; }
+  void set_range(size_t i, HistogramBase::Sample value) {
+    DCHECK_LT(i, ranges_.size());
+    DCHECK_GE(value, 0);
+    ranges_[i] = value;
+  }
+  uint32_t checksum() const { return checksum_; }
+  void set_checksum(uint32_t checksum) { checksum_ = checksum; }
+
+  // A bucket is defined by a consecutive pair of entries in |ranges|, so there
+  // is one fewer bucket than there are ranges.  For example, if |ranges| is
+  // [0, 1, 3, 7, INT_MAX], then the buckets in this histogram are
+  // [0, 1), [1, 3), [3, 7), and [7, INT_MAX).
+  size_t bucket_count() const { return ranges_.size() - 1; }
+
+  // Checksum methods to verify whether the ranges are corrupted (e.g. bad
+  // memory access).
+  uint32_t CalculateChecksum() const;
+  bool HasValidChecksum() const;
+  void ResetChecksum();
+
+  // Return true iff |other| object has same ranges_ as |this| object's ranges_.
+  bool Equals(const BucketRanges* other) const;
+
+  // Set and get a reference into persistent memory where this bucket data
+  // can be found (and re-used). These calls are internally atomic with no
+  // safety against overwriting an existing value since though it is wasteful
+  // to have multiple identical persistent records, it is still safe.
+  void set_persistent_reference(uint32_t ref) const {
+    subtle::Release_Store(&persistent_reference_, ref);
+  }
+  uint32_t persistent_reference() const {
+    return subtle::Acquire_Load(&persistent_reference_);
+  }
+
+ private:
+  // A monotonically increasing list of values which determine which bucket to
+  // put a sample into.  For each index, show the smallest sample that can be
+  // added to the corresponding bucket.
+  Ranges ranges_;
+
+  // Checksum for the conntents of ranges_.  Used to detect random over-writes
+  // of our data, and to quickly see if some other BucketRanges instance is
+  // possibly Equal() to this instance.
+  // TODO(kaiwang): Consider change this to uint64_t. Because we see a lot of
+  // noise on UMA dashboard.
+  uint32_t checksum_;
+
+  // A reference into a global PersistentMemoryAllocator where the ranges
+  // information is stored. This allows for the record to be created once and
+  // re-used simply by having all histograms with the same ranges use the
+  // same reference.
+  mutable subtle::Atomic32 persistent_reference_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(BucketRanges);
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// Expose only for test.
+BASE_EXPORT extern const uint32_t kCrcTable[256];
+
+}  // namespace base
+
+#endif  // BASE_METRICS_BUCKET_RANGES_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/field_trial.h b/native/zucchini/vendor/libchrome/base/metrics/field_trial.h
new file mode 100644
index 0000000..ac4ea1c
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/metrics/field_trial.h
@@ -0,0 +1,802 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// FieldTrial is a class for handling details of statistical experiments
+// performed by actual users in the field (i.e., in a shipped or beta product).
+// All code is called exclusively on the UI thread currently.
+//
+// The simplest example is an experiment to see whether one of two options
+// produces "better" results across our user population.  In that scenario, UMA
+// data is uploaded to aggregate the test results, and this FieldTrial class
+// manages the state of each such experiment (state == which option was
+// pseudo-randomly selected).
+//
+// States are typically generated randomly, either based on a one time
+// randomization (which will yield the same results, in terms of selecting
+// the client for a field trial or not, for every run of the program on a
+// given machine), or by a session randomization (generated each time the
+// application starts up, but held constant during the duration of the
+// process).
+
+//------------------------------------------------------------------------------
+// Example:  Suppose we have an experiment involving memory, such as determining
+// the impact of some pruning algorithm.
+// We assume that we already have a histogram of memory usage, such as:
+
+//   UMA_HISTOGRAM_COUNTS("Memory.RendererTotal", count);
+
+// Somewhere in main thread initialization code, we'd probably define an
+// instance of a FieldTrial, with code such as:
+
+// // FieldTrials are reference counted, and persist automagically until
+// // process teardown, courtesy of their automatic registration in
+// // FieldTrialList.
+// // Note: This field trial will run in Chrome instances compiled through
+// //       8 July, 2015, and after that all instances will be in "StandardMem".
+// scoped_refptr<base::FieldTrial> trial(
+//     base::FieldTrialList::FactoryGetFieldTrial(
+//         "MemoryExperiment", 1000, "StandardMem", 2015, 7, 8,
+//         base::FieldTrial::ONE_TIME_RANDOMIZED, NULL));
+//
+// const int high_mem_group =
+//     trial->AppendGroup("HighMem", 20);  // 2% in HighMem group.
+// const int low_mem_group =
+//     trial->AppendGroup("LowMem", 20);   // 2% in LowMem group.
+// // Take action depending of which group we randomly land in.
+// if (trial->group() == high_mem_group)
+//   SetPruningAlgorithm(kType1);  // Sample setting of browser state.
+// else if (trial->group() == low_mem_group)
+//   SetPruningAlgorithm(kType2);  // Sample alternate setting.
+
+//------------------------------------------------------------------------------
+
+#ifndef BASE_METRICS_FIELD_TRIAL_H_
+#define BASE_METRICS_FIELD_TRIAL_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "base/atomicops.h"
+#include "base/base_export.h"
+#include "base/command_line.h"
+#include "base/feature_list.h"
+#include "base/files/file.h"
+#include "base/gtest_prod_util.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/shared_memory.h"
+#include "base/memory/shared_memory_handle.h"
+#include "base/metrics/persistent_memory_allocator.h"
+#include "base/observer_list_threadsafe.h"
+#include "base/pickle.h"
+#include "base/process/launch.h"
+#include "base/strings/string_piece.h"
+#include "base/synchronization/lock.h"
+#include "base/time/time.h"
+#include "build/build_config.h"
+
+namespace base {
+
+class FieldTrialList;
+
+class BASE_EXPORT FieldTrial : public RefCounted<FieldTrial> {
+ public:
+  typedef int Probability;  // Probability type for being selected in a trial.
+
+  // TODO(665129): Make private again after crash has been resolved.
+  typedef SharedPersistentMemoryAllocator::Reference FieldTrialRef;
+
+  // Specifies the persistence of the field trial group choice.
+  enum RandomizationType {
+    // One time randomized trials will persist the group choice between
+    // restarts, which is recommended for most trials, especially those that
+    // change user visible behavior.
+    ONE_TIME_RANDOMIZED,
+    // Session randomized trials will roll the dice to select a group on every
+    // process restart.
+    SESSION_RANDOMIZED,
+  };
+
+  // EntropyProvider is an interface for providing entropy for one-time
+  // randomized (persistent) field trials.
+  class BASE_EXPORT EntropyProvider {
+   public:
+    virtual ~EntropyProvider();
+
+    // Returns a double in the range of [0, 1) to be used for the dice roll for
+    // the specified field trial. If |randomization_seed| is not 0, it will be
+    // used in preference to |trial_name| for generating the entropy by entropy
+    // providers that support it. A given instance should always return the same
+    // value given the same input |trial_name| and |randomization_seed| values.
+    virtual double GetEntropyForTrial(const std::string& trial_name,
+                                      uint32_t randomization_seed) const = 0;
+  };
+
+  // A pair representing a Field Trial and its selected group.
+  struct ActiveGroup {
+    std::string trial_name;
+    std::string group_name;
+  };
+
+  // A triplet representing a FieldTrial, its selected group and whether it's
+  // active. String members are pointers to the underlying strings owned by the
+  // FieldTrial object. Does not use StringPiece to avoid conversions back to
+  // std::string.
+  struct BASE_EXPORT State {
+    const std::string* trial_name = nullptr;
+    const std::string* group_name = nullptr;
+    bool activated = false;
+
+    State();
+    State(const State& other);
+    ~State();
+  };
+
+  // We create one FieldTrialEntry per field trial in shared memory, via
+  // AddToAllocatorWhileLocked. The FieldTrialEntry is followed by a
+  // base::Pickle object that we unpickle and read from.
+  struct BASE_EXPORT FieldTrialEntry {
+    // SHA1(FieldTrialEntry): Increment this if structure changes!
+    static constexpr uint32_t kPersistentTypeId = 0xABA17E13 + 2;
+
+    // Expected size for 32/64-bit check.
+    static constexpr size_t kExpectedInstanceSize = 8;
+
+    // Whether or not this field trial is activated. This is really just a
+    // boolean but using a 32 bit value for portability reasons. It should be
+    // accessed via NoBarrier_Load()/NoBarrier_Store() to prevent the compiler
+    // from doing unexpected optimizations because it thinks that only one
+    // thread is accessing the memory location.
+    subtle::Atomic32 activated;
+
+    // Size of the pickled structure, NOT the total size of this entry.
+    uint32_t pickle_size;
+
+    // Calling this is only valid when the entry is initialized. That is, it
+    // resides in shared memory and has a pickle containing the trial name and
+    // group name following it.
+    bool GetTrialAndGroupName(StringPiece* trial_name,
+                              StringPiece* group_name) const;
+
+    // Calling this is only valid when the entry is initialized as well. Reads
+    // the parameters following the trial and group name and stores them as
+    // key-value mappings in |params|.
+    bool GetParams(std::map<std::string, std::string>* params) const;
+
+   private:
+    // Returns an iterator over the data containing names and params.
+    PickleIterator GetPickleIterator() const;
+
+    // Takes the iterator and writes out the first two items into |trial_name|
+    // and |group_name|.
+    bool ReadStringPair(PickleIterator* iter,
+                        StringPiece* trial_name,
+                        StringPiece* group_name) const;
+  };
+
+  typedef std::vector<ActiveGroup> ActiveGroups;
+
+  // A return value to indicate that a given instance has not yet had a group
+  // assignment (and hence is not yet participating in the trial).
+  static const int kNotFinalized;
+
+  // Disables this trial, meaning it always determines the default group
+  // has been selected. May be called immediately after construction, or
+  // at any time after initialization (should not be interleaved with
+  // AppendGroup calls). Once disabled, there is no way to re-enable a
+  // trial.
+  // TODO(mad): http://code.google.com/p/chromium/issues/detail?id=121446
+  // This doesn't properly reset to Default when a group was forced.
+  void Disable();
+
+  // Establish the name and probability of the next group in this trial.
+  // Sometimes, based on construction randomization, this call may cause the
+  // provided group to be *THE* group selected for use in this instance.
+  // The return value is the group number of the new group.
+  int AppendGroup(const std::string& name, Probability group_probability);
+
+  // Return the name of the FieldTrial (excluding the group name).
+  const std::string& trial_name() const { return trial_name_; }
+
+  // Return the randomly selected group number that was assigned, and notify
+  // any/all observers that this finalized group number has presumably been used
+  // (queried), and will never change. Note that this will force an instance to
+  // participate, and make it illegal to attempt to probabilistically add any
+  // other groups to the trial.
+  int group();
+
+  // If the group's name is empty, a string version containing the group number
+  // is used as the group name. This causes a winner to be chosen if none was.
+  const std::string& group_name();
+
+  // Finalizes the group choice and returns the chosen group, but does not mark
+  // the trial as active - so its state will not be reported until group_name()
+  // or similar is called.
+  const std::string& GetGroupNameWithoutActivation();
+
+  // Set the field trial as forced, meaning that it was setup earlier than
+  // the hard coded registration of the field trial to override it.
+  // This allows the code that was hard coded to register the field trial to
+  // still succeed even though the field trial has already been registered.
+  // This must be called after appending all the groups, since we will make
+  // the group choice here. Note that this is a NOOP for already forced trials.
+  // And, as the rest of the FieldTrial code, this is not thread safe and must
+  // be done from the UI thread.
+  void SetForced();
+
+  // Enable benchmarking sets field trials to a common setting.
+  static void EnableBenchmarking();
+
+  // Creates a FieldTrial object with the specified parameters, to be used for
+  // simulation of group assignment without actually affecting global field
+  // trial state in the running process. Group assignment will be done based on
+  // |entropy_value|, which must have a range of [0, 1).
+  //
+  // Note: Using this function will not register the field trial globally in the
+  // running process - for that, use FieldTrialList::FactoryGetFieldTrial().
+  //
+  // The ownership of the returned FieldTrial is transfered to the caller which
+  // is responsible for deref'ing it (e.g. by using scoped_refptr<FieldTrial>).
+  static FieldTrial* CreateSimulatedFieldTrial(
+      const std::string& trial_name,
+      Probability total_probability,
+      const std::string& default_group_name,
+      double entropy_value);
+
+ private:
+  // Allow tests to access our innards for testing purposes.
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, Registration);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, AbsoluteProbabilities);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, RemainingProbability);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, FiftyFiftyProbability);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, MiddleProbabilities);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, OneWinner);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, DisableProbability);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, ActiveGroups);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, AllGroups);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, ActiveGroupsNotFinalized);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, Save);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SaveAll);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, DuplicateRestore);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedTurnFeatureOff);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedTurnFeatureOn);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedChangeDefault_Default);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedChangeDefault_NonDefault);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, FloatBoundariesGiveEqualGroupSizes);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, DoesNotSurpassTotalProbability);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest,
+                           DoNotAddSimulatedFieldTrialsToAllocator);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, ClearParamsFromSharedMemory);
+
+  friend class base::FieldTrialList;
+
+  friend class RefCounted<FieldTrial>;
+
+  // This is the group number of the 'default' group when a choice wasn't forced
+  // by a call to FieldTrialList::CreateFieldTrial. It is kept private so that
+  // consumers don't use it by mistake in cases where the group was forced.
+  static const int kDefaultGroupNumber;
+
+  // Creates a field trial with the specified parameters. Group assignment will
+  // be done based on |entropy_value|, which must have a range of [0, 1).
+  FieldTrial(const std::string& trial_name,
+             Probability total_probability,
+             const std::string& default_group_name,
+             double entropy_value);
+  virtual ~FieldTrial();
+
+  // Return the default group name of the FieldTrial.
+  std::string default_group_name() const { return default_group_name_; }
+
+  // Marks this trial as having been registered with the FieldTrialList. Must be
+  // called no more than once and before any |group()| calls have occurred.
+  void SetTrialRegistered();
+
+  // Sets the chosen group name and number.
+  void SetGroupChoice(const std::string& group_name, int number);
+
+  // Ensures that a group is chosen, if it hasn't yet been. The field trial
+  // might yet be disabled, so this call will *not* notify observers of the
+  // status.
+  void FinalizeGroupChoice();
+
+  // Implements FinalizeGroupChoice() with the added flexibility of being
+  // deadlock-free if |is_locked| is true and the caller is holding a lock.
+  void FinalizeGroupChoiceImpl(bool is_locked);
+
+  // Returns the trial name and selected group name for this field trial via
+  // the output parameter |active_group|, but only if the group has already
+  // been chosen and has been externally observed via |group()| and the trial
+  // has not been disabled. In that case, true is returned and |active_group|
+  // is filled in; otherwise, the result is false and |active_group| is left
+  // untouched.
+  bool GetActiveGroup(ActiveGroup* active_group) const;
+
+  // Returns the trial name and selected group name for this field trial via
+  // the output parameter |field_trial_state| for all the studies when
+  // |bool include_expired| is true. In case when |bool include_expired| is
+  // false, if the trial has not been disabled true is returned and
+  // |field_trial_state| is filled in; otherwise, the result is false and
+  // |field_trial_state| is left untouched.
+  // This function is deadlock-free if the caller is holding a lock.
+  bool GetStateWhileLocked(State* field_trial_state, bool include_expired);
+
+  // Returns the group_name. A winner need not have been chosen.
+  std::string group_name_internal() const { return group_name_; }
+
+  // The name of the field trial, as can be found via the FieldTrialList.
+  const std::string trial_name_;
+
+  // The maximum sum of all probabilities supplied, which corresponds to 100%.
+  // This is the scaling factor used to adjust supplied probabilities.
+  const Probability divisor_;
+
+  // The name of the default group.
+  const std::string default_group_name_;
+
+  // The randomly selected probability that is used to select a group (or have
+  // the instance not participate).  It is the product of divisor_ and a random
+  // number between [0, 1).
+  Probability random_;
+
+  // Sum of the probabilities of all appended groups.
+  Probability accumulated_group_probability_;
+
+  // The number that will be returned by the next AppendGroup() call.
+  int next_group_number_;
+
+  // The pseudo-randomly assigned group number.
+  // This is kNotFinalized if no group has been assigned.
+  int group_;
+
+  // A textual name for the randomly selected group. Valid after |group()|
+  // has been called.
+  std::string group_name_;
+
+  // When enable_field_trial_ is false, field trial reverts to the 'default'
+  // group.
+  bool enable_field_trial_;
+
+  // When forced_ is true, we return the chosen group from AppendGroup when
+  // appropriate.
+  bool forced_;
+
+  // Specifies whether the group choice has been reported to observers.
+  bool group_reported_;
+
+  // Whether this trial is registered with the global FieldTrialList and thus
+  // should notify it when its group is queried.
+  bool trial_registered_;
+
+  // Reference to related field trial struct and data in shared memory.
+  FieldTrialRef ref_;
+
+  // When benchmarking is enabled, field trials all revert to the 'default'
+  // group.
+  static bool enable_benchmarking_;
+
+  DISALLOW_COPY_AND_ASSIGN(FieldTrial);
+};
+
+//------------------------------------------------------------------------------
+// Class with a list of all active field trials.  A trial is active if it has
+// been registered, which includes evaluating its state based on its probaility.
+// Only one instance of this class exists and outside of testing, will live for
+// the entire life time of the process.
+class BASE_EXPORT FieldTrialList {
+ public:
+  typedef SharedPersistentMemoryAllocator FieldTrialAllocator;
+
+  // Type for function pointer passed to |AllParamsToString| used to escape
+  // special characters from |input|.
+  typedef std::string (*EscapeDataFunc)(const std::string& input);
+
+  // Year that is guaranteed to not be expired when instantiating a field trial
+  // via |FactoryGetFieldTrial()|.  Set to two years from the build date.
+  static int kNoExpirationYear;
+
+  // Observer is notified when a FieldTrial's group is selected.
+  class BASE_EXPORT Observer {
+   public:
+    // Notify observers when FieldTrials's group is selected.
+    virtual void OnFieldTrialGroupFinalized(const std::string& trial_name,
+                                            const std::string& group_name) = 0;
+
+   protected:
+    virtual ~Observer();
+  };
+
+  // This singleton holds the global list of registered FieldTrials.
+  //
+  // To support one-time randomized field trials, specify a non-null
+  // |entropy_provider| which should be a source of uniformly distributed
+  // entropy values. If one time randomization is not desired, pass in null for
+  // |entropy_provider|.
+  explicit FieldTrialList(
+      std::unique_ptr<const FieldTrial::EntropyProvider> entropy_provider);
+
+  // Destructor Release()'s references to all registered FieldTrial instances.
+  ~FieldTrialList();
+
+  // Get a FieldTrial instance from the factory.
+  //
+  // |name| is used to register the instance with the FieldTrialList class,
+  // and can be used to find the trial (only one trial can be present for each
+  // name). |default_group_name| is the name of the default group which will
+  // be chosen if none of the subsequent appended groups get to be chosen.
+  // |default_group_number| can receive the group number of the default group as
+  // AppendGroup returns the number of the subsequence groups. |trial_name| and
+  // |default_group_name| may not be empty but |default_group_number| can be
+  // NULL if the value is not needed.
+  //
+  // Group probabilities that are later supplied must sum to less than or equal
+  // to the |total_probability|. Arguments |year|, |month| and |day_of_month|
+  // specify the expiration time. If the build time is after the expiration time
+  // then the field trial reverts to the 'default' group.
+  //
+  // Use this static method to get a startup-randomized FieldTrial or a
+  // previously created forced FieldTrial.
+  static FieldTrial* FactoryGetFieldTrial(
+      const std::string& trial_name,
+      FieldTrial::Probability total_probability,
+      const std::string& default_group_name,
+      const int year,
+      const int month,
+      const int day_of_month,
+      FieldTrial::RandomizationType randomization_type,
+      int* default_group_number);
+
+  // Same as FactoryGetFieldTrial(), but allows specifying a custom seed to be
+  // used on one-time randomized field trials (instead of a hash of the trial
+  // name, which is used otherwise or if |randomization_seed| has value 0). The
+  // |randomization_seed| value (other than 0) should never be the same for two
+  // trials, else this would result in correlated group assignments.  Note:
+  // Using a custom randomization seed is only supported by the
+  // PermutedEntropyProvider (which is used when UMA is not enabled). If
+  // |override_entropy_provider| is not null, then it will be used for
+  // randomization instead of the provider given when the FieldTrialList was
+  // instantiated.
+  static FieldTrial* FactoryGetFieldTrialWithRandomizationSeed(
+      const std::string& trial_name,
+      FieldTrial::Probability total_probability,
+      const std::string& default_group_name,
+      const int year,
+      const int month,
+      const int day_of_month,
+      FieldTrial::RandomizationType randomization_type,
+      uint32_t randomization_seed,
+      int* default_group_number,
+      const FieldTrial::EntropyProvider* override_entropy_provider);
+
+  // The Find() method can be used to test to see if a named trial was already
+  // registered, or to retrieve a pointer to it from the global map.
+  static FieldTrial* Find(const std::string& trial_name);
+
+  // Returns the group number chosen for the named trial, or
+  // FieldTrial::kNotFinalized if the trial does not exist.
+  static int FindValue(const std::string& trial_name);
+
+  // Returns the group name chosen for the named trial, or the empty string if
+  // the trial does not exist. The first call of this function on a given field
+  // trial will mark it as active, so that its state will be reported with usage
+  // metrics, crashes, etc.
+  static std::string FindFullName(const std::string& trial_name);
+
+  // Returns true if the named trial has been registered.
+  static bool TrialExists(const std::string& trial_name);
+
+  // Returns true if the named trial exists and has been activated.
+  static bool IsTrialActive(const std::string& trial_name);
+
+  // Creates a persistent representation of active FieldTrial instances for
+  // resurrection in another process. This allows randomization to be done in
+  // one process, and secondary processes can be synchronized on the result.
+  // The resulting string contains the name and group name pairs of all
+  // registered FieldTrials for which the group has been chosen and externally
+  // observed (via |group()|) and which have not been disabled, with "/" used
+  // to separate all names and to terminate the string. This string is parsed
+  // by |CreateTrialsFromString()|.
+  static void StatesToString(std::string* output);
+
+  // Creates a persistent representation of all FieldTrial instances for
+  // resurrection in another process. This allows randomization to be done in
+  // one process, and secondary processes can be synchronized on the result.
+  // The resulting string contains the name and group name pairs of all
+  // registered FieldTrials including disabled based on |include_expired|,
+  // with "/" used to separate all names and to terminate the string. All
+  // activated trials have their name prefixed with "*". This string is parsed
+  // by |CreateTrialsFromString()|.
+  static void AllStatesToString(std::string* output, bool include_expired);
+
+  // Creates a persistent representation of all FieldTrial params for
+  // resurrection in another process. The returned string contains the trial
+  // name and group name pairs of all registered FieldTrials including disabled
+  // based on |include_expired| separated by '.'. The pair is followed by ':'
+  // separator and list of param name and values separated by '/'. It also takes
+  // |encode_data_func| function pointer for encodeing special charactors.
+  // This string is parsed by |AssociateParamsFromString()|.
+  static std::string AllParamsToString(bool include_expired,
+                                       EscapeDataFunc encode_data_func);
+
+  // Fills in the supplied vector |active_groups| (which must be empty when
+  // called) with a snapshot of all registered FieldTrials for which the group
+  // has been chosen and externally observed (via |group()|) and which have
+  // not been disabled.
+  static void GetActiveFieldTrialGroups(
+      FieldTrial::ActiveGroups* active_groups);
+
+  // Returns the field trials that are marked active in |trials_string|.
+  static void GetActiveFieldTrialGroupsFromString(
+      const std::string& trials_string,
+      FieldTrial::ActiveGroups* active_groups);
+
+  // Returns the field trials that were active when the process was
+  // created. Either parses the field trial string or the shared memory
+  // holding field trial information.
+  // Must be called only after a call to CreateTrialsFromCommandLine().
+  static void GetInitiallyActiveFieldTrials(
+      const base::CommandLine& command_line,
+      FieldTrial::ActiveGroups* active_groups);
+
+  // Use a state string (re: StatesToString()) to augment the current list of
+  // field trials to include the supplied trials, and using a 100% probability
+  // for each trial, force them to have the same group string. This is commonly
+  // used in a non-browser process, to carry randomly selected state in a
+  // browser process into this non-browser process, but could also be invoked
+  // through a command line argument to the browser process. Created field
+  // trials will be marked "used" for the purposes of active trial reporting
+  // if they are prefixed with |kActivationMarker|. Trial names in
+  // |ignored_trial_names| are ignored when parsing |trials_string|.
+  static bool CreateTrialsFromString(
+      const std::string& trials_string,
+      const std::set<std::string>& ignored_trial_names);
+
+  // Achieves the same thing as CreateTrialsFromString, except wraps the logic
+  // by taking in the trials from the command line, either via shared memory
+  // handle or command line argument. A bit of a misnomer since on POSIX we
+  // simply get the trials from opening |fd_key| if using shared memory. On
+  // Windows, we expect the |cmd_line| switch for |field_trial_handle_switch| to
+  // contain the shared memory handle that contains the field trial allocator.
+  // We need the |field_trial_handle_switch| and |fd_key| arguments to be passed
+  // in since base/ can't depend on content/.
+  static void CreateTrialsFromCommandLine(const base::CommandLine& cmd_line,
+                                          const char* field_trial_handle_switch,
+                                          int fd_key);
+
+  // Creates base::Feature overrides from the command line by first trying to
+  // use shared memory and then falling back to the command line if it fails.
+  static void CreateFeaturesFromCommandLine(
+      const base::CommandLine& command_line,
+      const char* enable_features_switch,
+      const char* disable_features_switch,
+      FeatureList* feature_list);
+
+#if defined(OS_WIN)
+  // On Windows, we need to explicitly pass down any handles to be inherited.
+  // This function adds the shared memory handle to field trial state to the
+  // list of handles to be inherited.
+  static void AppendFieldTrialHandleIfNeeded(
+      base::HandlesToInheritVector* handles);
+#elif defined(OS_FUCHSIA)
+  // TODO(fuchsia): Implement shared-memory configuration (crbug.com/752368).
+#elif defined(OS_POSIX) && !defined(OS_NACL)
+  // On POSIX, we also need to explicitly pass down this file descriptor that
+  // should be shared with the child process. Returns an invalid handle if it
+  // was not initialized properly.
+  static base::SharedMemoryHandle GetFieldTrialHandle();
+#endif
+
+  // Adds a switch to the command line containing the field trial state as a
+  // string (if not using shared memory to share field trial state), or the
+  // shared memory handle + length.
+  // Needs the |field_trial_handle_switch| argument to be passed in since base/
+  // can't depend on content/.
+  static void CopyFieldTrialStateToFlags(const char* field_trial_handle_switch,
+                                         const char* enable_features_switch,
+                                         const char* disable_features_switch,
+                                         base::CommandLine* cmd_line);
+
+  // Create a FieldTrial with the given |name| and using 100% probability for
+  // the FieldTrial, force FieldTrial to have the same group string as
+  // |group_name|. This is commonly used in a non-browser process, to carry
+  // randomly selected state in a browser process into this non-browser process.
+  // It returns NULL if there is a FieldTrial that is already registered with
+  // the same |name| but has different finalized group string (|group_name|).
+  static FieldTrial* CreateFieldTrial(const std::string& name,
+                                      const std::string& group_name);
+
+  // Add an observer to be notified when a field trial is irrevocably committed
+  // to being part of some specific field_group (and hence the group_name is
+  // also finalized for that field_trial). Returns false and does nothing if
+  // there is no FieldTrialList singleton.
+  static bool AddObserver(Observer* observer);
+
+  // Remove an observer.
+  static void RemoveObserver(Observer* observer);
+
+  // Similar to AddObserver(), but the passed observer will be notified
+  // synchronously when a field trial is activated and its group selected. It
+  // will be notified synchronously on the same thread where the activation and
+  // group selection happened. It is the responsibility of the observer to make
+  // sure that this is a safe operation and the operation must be fast, as this
+  // work is done synchronously as part of group() or related APIs. Only a
+  // single such observer is supported, exposed specifically for crash
+  // reporting. Must be called on the main thread before any other threads
+  // have been started.
+  static void SetSynchronousObserver(Observer* observer);
+
+  // Removes the single synchronous observer.
+  static void RemoveSynchronousObserver(Observer* observer);
+
+  // Grabs the lock if necessary and adds the field trial to the allocator. This
+  // should only be called from FinalizeGroupChoice().
+  static void OnGroupFinalized(bool is_locked, FieldTrial* field_trial);
+
+  // Notify all observers that a group has been finalized for |field_trial|.
+  static void NotifyFieldTrialGroupSelection(FieldTrial* field_trial);
+
+  // Return the number of active field trials.
+  static size_t GetFieldTrialCount();
+
+  // Gets the parameters for |field_trial| from shared memory and stores them in
+  // |params|. This is only exposed for use by FieldTrialParamAssociator and
+  // shouldn't be used by anything else.
+  static bool GetParamsFromSharedMemory(
+      FieldTrial* field_trial,
+      std::map<std::string, std::string>* params);
+
+  // Clears all the params in the allocator.
+  static void ClearParamsFromSharedMemoryForTesting();
+
+  // Dumps field trial state to an allocator so that it can be analyzed after a
+  // crash.
+  static void DumpAllFieldTrialsToPersistentAllocator(
+      PersistentMemoryAllocator* allocator);
+
+  // Retrieves field trial state from an allocator so that it can be analyzed
+  // after a crash. The pointers in the returned vector are into the persistent
+  // memory segment and so are only valid as long as the allocator is valid.
+  static std::vector<const FieldTrial::FieldTrialEntry*>
+  GetAllFieldTrialsFromPersistentAllocator(
+      PersistentMemoryAllocator const& allocator);
+
+  // Returns true if a global field trial list is set. Only used for testing.
+  static bool IsGlobalSetForTesting();
+
+ private:
+  // Allow tests to access our innards for testing purposes.
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, InstantiateAllocator);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, AddTrialsToAllocator);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest,
+                           DoNotAddSimulatedFieldTrialsToAllocator);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, AssociateFieldTrialParams);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, ClearParamsFromSharedMemory);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest,
+                           SerializeSharedMemoryHandleMetadata);
+  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, CheckReadOnlySharedMemoryHandle);
+
+  // Serialization is used to pass information about the handle to child
+  // processes. It passes a reference to the relevant OS resource, and it passes
+  // a GUID. Serialization and deserialization doesn't actually transport the
+  // underlying OS resource - that must be done by the Process launcher.
+  static std::string SerializeSharedMemoryHandleMetadata(
+      const SharedMemoryHandle& shm);
+#if defined(OS_WIN) || defined(OS_FUCHSIA)
+  static SharedMemoryHandle DeserializeSharedMemoryHandleMetadata(
+      const std::string& switch_value);
+#elif defined(OS_POSIX) && !defined(OS_NACL)
+  static SharedMemoryHandle DeserializeSharedMemoryHandleMetadata(
+      int fd,
+      const std::string& switch_value);
+#endif
+
+#if defined(OS_WIN) || defined(OS_FUCHSIA)
+  // Takes in |handle_switch| from the command line which represents the shared
+  // memory handle for field trials, parses it, and creates the field trials.
+  // Returns true on success, false on failure.
+  // |switch_value| also contains the serialized GUID.
+  static bool CreateTrialsFromSwitchValue(const std::string& switch_value);
+#elif defined(OS_POSIX) && !defined(OS_NACL)
+  // On POSIX systems that use the zygote, we look up the correct fd that backs
+  // the shared memory segment containing the field trials by looking it up via
+  // an fd key in GlobalDescriptors. Returns true on success, false on failure.
+  // |switch_value| also contains the serialized GUID.
+  static bool CreateTrialsFromDescriptor(int fd_key,
+                                         const std::string& switch_value);
+#endif
+
+  // Takes an unmapped SharedMemoryHandle, creates a SharedMemory object from it
+  // and maps it with the correct size.
+  static bool CreateTrialsFromSharedMemoryHandle(SharedMemoryHandle shm_handle);
+
+  // Expects a mapped piece of shared memory |shm| that was created from the
+  // browser process's field_trial_allocator and shared via the command line.
+  // This function recreates the allocator, iterates through all the field
+  // trials in it, and creates them via CreateFieldTrial(). Returns true if
+  // successful and false otherwise.
+  static bool CreateTrialsFromSharedMemory(
+      std::unique_ptr<base::SharedMemory> shm);
+
+  // Instantiate the field trial allocator, add all existing field trials to it,
+  // and duplicates its handle to a read-only handle, which gets stored in
+  // |readonly_allocator_handle|.
+  static void InstantiateFieldTrialAllocatorIfNeeded();
+
+  // Adds the field trial to the allocator. Caller must hold a lock before
+  // calling this.
+  static void AddToAllocatorWhileLocked(PersistentMemoryAllocator* allocator,
+                                        FieldTrial* field_trial);
+
+  // Activate the corresponding field trial entry struct in shared memory.
+  static void ActivateFieldTrialEntryWhileLocked(FieldTrial* field_trial);
+
+  // A map from FieldTrial names to the actual instances.
+  typedef std::map<std::string, FieldTrial*> RegistrationMap;
+
+  // If one-time randomization is enabled, returns a weak pointer to the
+  // corresponding EntropyProvider. Otherwise, returns NULL.
+  static const FieldTrial::EntropyProvider*
+      GetEntropyProviderForOneTimeRandomization();
+
+  // Helper function should be called only while holding lock_.
+  FieldTrial* PreLockedFind(const std::string& name);
+
+  // Register() stores a pointer to the given trial in a global map.
+  // This method also AddRef's the indicated trial.
+  // This should always be called after creating a new FieldTrial instance.
+  static void Register(FieldTrial* trial);
+
+  // Returns all the registered trials.
+  static RegistrationMap GetRegisteredTrials();
+
+  static FieldTrialList* global_;  // The singleton of this class.
+
+  // This will tell us if there is an attempt to register a field
+  // trial or check if one-time randomization is enabled without
+  // creating the FieldTrialList. This is not an error, unless a
+  // FieldTrialList is created after that.
+  static bool used_without_global_;
+
+  // Lock for access to registered_ and field_trial_allocator_.
+  Lock lock_;
+  RegistrationMap registered_;
+
+  std::map<std::string, std::string> seen_states_;
+
+  // Entropy provider to be used for one-time randomized field trials. If NULL,
+  // one-time randomization is not supported.
+  std::unique_ptr<const FieldTrial::EntropyProvider> entropy_provider_;
+
+  // List of observers to be notified when a group is selected for a FieldTrial.
+  scoped_refptr<ObserverListThreadSafe<Observer> > observer_list_;
+
+  // Single synchronous observer to be notified when a trial group is chosen.
+  Observer* synchronous_observer_ = nullptr;
+
+  // Allocator in shared memory containing field trial data. Used in both
+  // browser and child processes, but readonly in the child.
+  // In the future, we may want to move this to a more generic place if we want
+  // to start passing more data other than field trials.
+  std::unique_ptr<FieldTrialAllocator> field_trial_allocator_ = nullptr;
+
+  // Readonly copy of the handle to the allocator. Needs to be a member variable
+  // because it's needed from both CopyFieldTrialStateToFlags() and
+  // AppendFieldTrialHandleIfNeeded().
+  base::SharedMemoryHandle readonly_allocator_handle_;
+
+  // Tracks whether CreateTrialsFromCommandLine() has been called.
+  bool create_trials_from_command_line_called_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(FieldTrialList);
+};
+
+}  // namespace base
+
+#endif  // BASE_METRICS_FIELD_TRIAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram.h b/native/zucchini/vendor/libchrome/base/metrics/histogram.h
new file mode 100644
index 0000000..bd5a9eb
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/metrics/histogram.h
@@ -0,0 +1,610 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Histogram is an object that aggregates statistics, and can summarize them in
+// various forms, including ASCII graphical, HTML, and numerically (as a
+// vector of numbers corresponding to each of the aggregating buckets).
+
+// It supports calls to accumulate either time intervals (which are processed
+// as integral number of milliseconds), or arbitrary integral units.
+
+// For Histogram (exponential histogram), LinearHistogram and CustomHistogram,
+// the minimum for a declared range is 1 (instead of 0), while the maximum is
+// (HistogramBase::kSampleType_MAX - 1). However, there will always be underflow
+// and overflow buckets added automatically, so a 0 bucket will always exist
+// even when a minimum value of 1 is specified.
+
+// Each use of a histogram with the same name will reference the same underlying
+// data, so it is safe to record to the same histogram from multiple locations
+// in the code. It is a runtime error if all uses of the same histogram do not
+// agree exactly in type, bucket size and range.
+
+// For Histogram and LinearHistogram, the maximum for a declared range should
+// always be larger (not equal) than minimal range. Zero and
+// HistogramBase::kSampleType_MAX are implicitly added as first and last ranges,
+// so the smallest legal bucket_count is 3. However CustomHistogram can have
+// bucket count as 2 (when you give a custom ranges vector containing only 1
+// range).
+// For these 3 kinds of histograms, the max bucket count is always
+// (Histogram::kBucketCount_MAX - 1).
+
+// The buckets layout of class Histogram is exponential. For example, buckets
+// might contain (sequentially) the count of values in the following intervals:
+// [0,1), [1,2), [2,4), [4,8), [8,16), [16,32), [32,64), [64,infinity)
+// That bucket allocation would actually result from construction of a histogram
+// for values between 1 and 64, with 8 buckets, such as:
+// Histogram count("some name", 1, 64, 8);
+// Note that the underflow bucket [0,1) and the overflow bucket [64,infinity)
+// are also counted by the constructor in the user supplied "bucket_count"
+// argument.
+// The above example has an exponential ratio of 2 (doubling the bucket width
+// in each consecutive bucket).  The Histogram class automatically calculates
+// the smallest ratio that it can use to construct the number of buckets
+// selected in the constructor.  An another example, if you had 50 buckets,
+// and millisecond time values from 1 to 10000, then the ratio between
+// consecutive bucket widths will be approximately somewhere around the 50th
+// root of 10000.  This approach provides very fine grain (narrow) buckets
+// at the low end of the histogram scale, but allows the histogram to cover a
+// gigantic range with the addition of very few buckets.
+
+// Usually we use macros to define and use a histogram, which are defined in
+// base/metrics/histogram_macros.h. Note: Callers should include that header
+// directly if they only access the histogram APIs through macros.
+//
+// Macros use a pattern involving a function static variable, that is a pointer
+// to a histogram.  This static is explicitly initialized on any thread
+// that detects a uninitialized (NULL) pointer.  The potentially racy
+// initialization is not a problem as it is always set to point to the same
+// value (i.e., the FactoryGet always returns the same value).  FactoryGet
+// is also completely thread safe, which results in a completely thread safe,
+// and relatively fast, set of counters.  To avoid races at shutdown, the static
+// pointer is NOT deleted, and we leak the histograms at process termination.
+
+#ifndef BASE_METRICS_HISTOGRAM_H_
+#define BASE_METRICS_HISTOGRAM_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/compiler_specific.h"
+#include "base/containers/span.h"
+#include "base/gtest_prod_util.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/metrics/bucket_ranges.h"
+#include "base/metrics/histogram_base.h"
+#include "base/metrics/histogram_samples.h"
+#include "base/strings/string_piece.h"
+#include "base/time/time.h"
+
+namespace base {
+
+class BooleanHistogram;
+class CustomHistogram;
+class DelayedPersistentAllocation;
+class Histogram;
+class HistogramTest;
+class LinearHistogram;
+class Pickle;
+class PickleIterator;
+class SampleVector;
+class SampleVectorBase;
+
+class BASE_EXPORT Histogram : public HistogramBase {
+ public:
+  // Initialize maximum number of buckets in histograms as 16,384.
+  static const uint32_t kBucketCount_MAX;
+
+  typedef std::vector<Count> Counts;
+
+  ~Histogram() override;
+
+  //----------------------------------------------------------------------------
+  // For a valid histogram, input should follow these restrictions:
+  // minimum > 0 (if a minimum below 1 is specified, it will implicitly be
+  //              normalized up to 1)
+  // maximum > minimum
+  // buckets > 2 [minimum buckets needed: underflow, overflow and the range]
+  // Additionally,
+  // buckets <= (maximum - minimum + 2) - this is to ensure that we don't have
+  // more buckets than the range of numbers; having more buckets than 1 per
+  // value in the range would be nonsensical.
+  static HistogramBase* FactoryGet(const std::string& name,
+                                   Sample minimum,
+                                   Sample maximum,
+                                   uint32_t bucket_count,
+                                   int32_t flags);
+  static HistogramBase* FactoryTimeGet(const std::string& name,
+                                       base::TimeDelta minimum,
+                                       base::TimeDelta maximum,
+                                       uint32_t bucket_count,
+                                       int32_t flags);
+  static HistogramBase* FactoryMicrosecondsTimeGet(const std::string& name,
+                                                   base::TimeDelta minimum,
+                                                   base::TimeDelta maximum,
+                                                   uint32_t bucket_count,
+                                                   int32_t flags);
+
+  // Overloads of the above functions that take a const char* |name| param, to
+  // avoid code bloat from the std::string constructor being inlined into call
+  // sites.
+  static HistogramBase* FactoryGet(const char* name,
+                                   Sample minimum,
+                                   Sample maximum,
+                                   uint32_t bucket_count,
+                                   int32_t flags);
+  static HistogramBase* FactoryTimeGet(const char* name,
+                                       base::TimeDelta minimum,
+                                       base::TimeDelta maximum,
+                                       uint32_t bucket_count,
+                                       int32_t flags);
+  static HistogramBase* FactoryMicrosecondsTimeGet(const char* name,
+                                                   base::TimeDelta minimum,
+                                                   base::TimeDelta maximum,
+                                                   uint32_t bucket_count,
+                                                   int32_t flags);
+
+  // Create a histogram using data in persistent storage.
+  static std::unique_ptr<HistogramBase> PersistentCreate(
+      const char* name,
+      Sample minimum,
+      Sample maximum,
+      const BucketRanges* ranges,
+      const DelayedPersistentAllocation& counts,
+      const DelayedPersistentAllocation& logged_counts,
+      HistogramSamples::Metadata* meta,
+      HistogramSamples::Metadata* logged_meta);
+
+  static void InitializeBucketRanges(Sample minimum,
+                                     Sample maximum,
+                                     BucketRanges* ranges);
+
+  // This constant if for FindCorruption. Since snapshots of histograms are
+  // taken asynchronously relative to sampling, and our counting code currently
+  // does not prevent race conditions, it is pretty likely that we'll catch a
+  // redundant count that doesn't match the sample count.  We allow for a
+  // certain amount of slop before flagging this as an inconsistency. Even with
+  // an inconsistency, we'll snapshot it again (for UMA in about a half hour),
+  // so we'll eventually get the data, if it was not the result of a corruption.
+  static const int kCommonRaceBasedCountMismatch;
+
+  // Check to see if bucket ranges, counts and tallies in the snapshot are
+  // consistent with the bucket ranges and checksums in our histogram.  This can
+  // produce a false-alarm if a race occurred in the reading of the data during
+  // a SnapShot process, but should otherwise be false at all times (unless we
+  // have memory over-writes, or DRAM failures). Flag definitions are located
+  // under "enum Inconsistency" in base/metrics/histogram_base.h.
+  uint32_t FindCorruption(const HistogramSamples& samples) const override;
+
+  //----------------------------------------------------------------------------
+  // Accessors for factory construction, serialization and testing.
+  //----------------------------------------------------------------------------
+  const BucketRanges* bucket_ranges() const;
+  Sample declared_min() const;
+  Sample declared_max() const;
+  virtual Sample ranges(uint32_t i) const;
+  virtual uint32_t bucket_count() const;
+
+  // This function validates histogram construction arguments. It returns false
+  // if some of the arguments are bad but also corrects them so they should
+  // function on non-dcheck builds without crashing.
+  // Note. Currently it allow some bad input, e.g. 0 as minimum, but silently
+  // converts it to good input: 1.
+  // TODO(bcwhite): Use false returns to create "sink" histograms so that bad
+  // data doesn't create confusion on the servers.
+  static bool InspectConstructionArguments(StringPiece name,
+                                           Sample* minimum,
+                                           Sample* maximum,
+                                           uint32_t* bucket_count);
+
+  // HistogramBase implementation:
+  uint64_t name_hash() const override;
+  HistogramType GetHistogramType() const override;
+  bool HasConstructionArguments(Sample expected_minimum,
+                                Sample expected_maximum,
+                                uint32_t expected_bucket_count) const override;
+  void Add(Sample value) override;
+  void AddCount(Sample value, int count) override;
+  std::unique_ptr<HistogramSamples> SnapshotSamples() const override;
+  std::unique_ptr<HistogramSamples> SnapshotDelta() override;
+  std::unique_ptr<HistogramSamples> SnapshotFinalDelta() const override;
+  void AddSamples(const HistogramSamples& samples) override;
+  bool AddSamplesFromPickle(base::PickleIterator* iter) override;
+  void WriteHTMLGraph(std::string* output) const override;
+  void WriteAscii(std::string* output) const override;
+
+  // Validates the histogram contents and CHECKs on errors.
+  // TODO(bcwhite): Remove this after https://crbug/836875.
+  void ValidateHistogramContents() const override;
+
+ protected:
+  // This class, defined entirely within the .cc file, contains all the
+  // common logic for building a Histogram and can be overridden by more
+  // specific types to alter details of how the creation is done. It is
+  // defined as an embedded class (rather than an anonymous one) so it
+  // can access the protected constructors.
+  class Factory;
+
+  // |ranges| should contain the underflow and overflow buckets. See top
+  // comments for example.
+  Histogram(const char* name,
+            Sample minimum,
+            Sample maximum,
+            const BucketRanges* ranges);
+
+  // Traditionally, histograms allocate their own memory for the bucket
+  // vector but "shared" histograms use memory regions allocated from a
+  // special memory segment that is passed in here.  It is assumed that
+  // the life of this memory is managed externally and exceeds the lifetime
+  // of this object. Practically, this memory is never released until the
+  // process exits and the OS cleans it up.
+  Histogram(const char* name,
+            Sample minimum,
+            Sample maximum,
+            const BucketRanges* ranges,
+            const DelayedPersistentAllocation& counts,
+            const DelayedPersistentAllocation& logged_counts,
+            HistogramSamples::Metadata* meta,
+            HistogramSamples::Metadata* logged_meta);
+
+  // HistogramBase implementation:
+  void SerializeInfoImpl(base::Pickle* pickle) const override;
+
+  // Method to override to skip the display of the i'th bucket if it's empty.
+  virtual bool PrintEmptyBucket(uint32_t index) const;
+
+  // Get normalized size, relative to the ranges(i).
+  virtual double GetBucketSize(Count current, uint32_t i) const;
+
+  // Return a string description of what goes in a given bucket.
+  // Most commonly this is the numeric value, but in derived classes it may
+  // be a name (or string description) given to the bucket.
+  virtual const std::string GetAsciiBucketRange(uint32_t it) const;
+
+ private:
+  // Allow tests to corrupt our innards for testing purposes.
+  friend class HistogramTest;
+  FRIEND_TEST_ALL_PREFIXES(HistogramTest, BoundsTest);
+  FRIEND_TEST_ALL_PREFIXES(HistogramTest, BucketPlacementTest);
+  FRIEND_TEST_ALL_PREFIXES(HistogramTest, CorruptSampleCounts);
+
+  friend class StatisticsRecorder;  // To allow it to delete duplicates.
+  friend class StatisticsRecorderTest;
+
+  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
+      base::PickleIterator* iter);
+  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
+
+  // Create a snapshot containing all samples (both logged and unlogged).
+  // Implementation of SnapshotSamples method with a more specific type for
+  // internal use.
+  std::unique_ptr<SampleVector> SnapshotAllSamples() const;
+
+  // Create a copy of unlogged samples.
+  std::unique_ptr<SampleVector> SnapshotUnloggedSamples() const;
+
+  //----------------------------------------------------------------------------
+  // Helpers for emitting Ascii graphic.  Each method appends data to output.
+
+  void WriteAsciiImpl(bool graph_it,
+                      const std::string& newline,
+                      std::string* output) const;
+
+  // Find out how large (graphically) the largest bucket will appear to be.
+  double GetPeakBucketSize(const SampleVectorBase& samples) const;
+
+  // Write a common header message describing this histogram.
+  void WriteAsciiHeader(const SampleVectorBase& samples,
+                        Count sample_count,
+                        std::string* output) const;
+
+  // Write information about previous, current, and next buckets.
+  // Information such as cumulative percentage, etc.
+  void WriteAsciiBucketContext(const int64_t past,
+                               const Count current,
+                               const int64_t remaining,
+                               const uint32_t i,
+                               std::string* output) const;
+
+  // WriteJSON calls these.
+  void GetParameters(DictionaryValue* params) const override;
+
+  void GetCountAndBucketData(Count* count,
+                             int64_t* sum,
+                             ListValue* buckets) const override;
+
+  // Samples that have not yet been logged with SnapshotDelta().
+  std::unique_ptr<SampleVectorBase> unlogged_samples_;
+
+  // Accumulation of all samples that have been logged with SnapshotDelta().
+  std::unique_ptr<SampleVectorBase> logged_samples_;
+
+#if DCHECK_IS_ON()  // Don't waste memory if it won't be used.
+  // Flag to indicate if PrepareFinalDelta has been previously called. It is
+  // used to DCHECK that a final delta is not created multiple times.
+  mutable bool final_delta_created_ = false;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(Histogram);
+};
+
+//------------------------------------------------------------------------------
+
+// LinearHistogram is a more traditional histogram, with evenly spaced
+// buckets.
+class BASE_EXPORT LinearHistogram : public Histogram {
+ public:
+  ~LinearHistogram() override;
+
+  /* minimum should start from 1. 0 is as minimum is invalid. 0 is an implicit
+     default underflow bucket. */
+  static HistogramBase* FactoryGet(const std::string& name,
+                                   Sample minimum,
+                                   Sample maximum,
+                                   uint32_t bucket_count,
+                                   int32_t flags);
+  static HistogramBase* FactoryTimeGet(const std::string& name,
+                                       TimeDelta minimum,
+                                       TimeDelta maximum,
+                                       uint32_t bucket_count,
+                                       int32_t flags);
+
+  // Overloads of the above two functions that take a const char* |name| param,
+  // to avoid code bloat from the std::string constructor being inlined into
+  // call sites.
+  static HistogramBase* FactoryGet(const char* name,
+                                   Sample minimum,
+                                   Sample maximum,
+                                   uint32_t bucket_count,
+                                   int32_t flags);
+  static HistogramBase* FactoryTimeGet(const char* name,
+                                       TimeDelta minimum,
+                                       TimeDelta maximum,
+                                       uint32_t bucket_count,
+                                       int32_t flags);
+
+  // Create a histogram using data in persistent storage.
+  static std::unique_ptr<HistogramBase> PersistentCreate(
+      const char* name,
+      Sample minimum,
+      Sample maximum,
+      const BucketRanges* ranges,
+      const DelayedPersistentAllocation& counts,
+      const DelayedPersistentAllocation& logged_counts,
+      HistogramSamples::Metadata* meta,
+      HistogramSamples::Metadata* logged_meta);
+
+  struct DescriptionPair {
+    Sample sample;
+    const char* description;  // Null means end of a list of pairs.
+  };
+
+  // Create a LinearHistogram and store a list of number/text values for use in
+  // writing the histogram graph.
+  // |descriptions| can be NULL, which means no special descriptions to set. If
+  // it's not NULL, the last element in the array must has a NULL in its
+  // "description" field.
+  static HistogramBase* FactoryGetWithRangeDescription(
+      const std::string& name,
+      Sample minimum,
+      Sample maximum,
+      uint32_t bucket_count,
+      int32_t flags,
+      const DescriptionPair descriptions[]);
+
+  static void InitializeBucketRanges(Sample minimum,
+                                     Sample maximum,
+                                     BucketRanges* ranges);
+
+  // Overridden from Histogram:
+  HistogramType GetHistogramType() const override;
+
+ protected:
+  class Factory;
+
+  LinearHistogram(const char* name,
+                  Sample minimum,
+                  Sample maximum,
+                  const BucketRanges* ranges);
+
+  LinearHistogram(const char* name,
+                  Sample minimum,
+                  Sample maximum,
+                  const BucketRanges* ranges,
+                  const DelayedPersistentAllocation& counts,
+                  const DelayedPersistentAllocation& logged_counts,
+                  HistogramSamples::Metadata* meta,
+                  HistogramSamples::Metadata* logged_meta);
+
+  double GetBucketSize(Count current, uint32_t i) const override;
+
+  // If we have a description for a bucket, then return that.  Otherwise
+  // let parent class provide a (numeric) description.
+  const std::string GetAsciiBucketRange(uint32_t i) const override;
+
+  // Skip printing of name for numeric range if we have a name (and if this is
+  // an empty bucket).
+  bool PrintEmptyBucket(uint32_t index) const override;
+
+ private:
+  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
+      base::PickleIterator* iter);
+  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
+
+  // For some ranges, we store a printable description of a bucket range.
+  // If there is no description, then GetAsciiBucketRange() uses parent class
+  // to provide a description.
+  typedef std::map<Sample, std::string> BucketDescriptionMap;
+  BucketDescriptionMap bucket_description_;
+
+  DISALLOW_COPY_AND_ASSIGN(LinearHistogram);
+};
+
+//------------------------------------------------------------------------------
+
+// ScaledLinearHistogram is a wrapper around a linear histogram that scales the
+// counts down by some factor. Remainder values are kept locally but lost when
+// uploaded or serialized. The integral counts are rounded up/down so should
+// average to the correct value when many reports are added.
+//
+// This is most useful when adding many counts at once via AddCount() that can
+// cause overflows of the 31-bit counters, usually with an enum as the value.
+class BASE_EXPORT ScaledLinearHistogram {
+  using AtomicCount = Histogram::AtomicCount;
+  using Sample = Histogram::Sample;
+
+ public:
+  // Currently only works with "exact" linear histograms: minimum=1, maximum=N,
+  // and bucket_count=N+1.
+  ScaledLinearHistogram(const char* name,
+                        Sample minimum,
+                        Sample maximum,
+                        uint32_t bucket_count,
+                        int32_t scale,
+                        int32_t flags);
+
+  ~ScaledLinearHistogram();
+
+  // Like AddCount() but actually accumulates |count|/|scale| and increments
+  // the accumulated remainder by |count|%|scale|. An additional increment
+  // is done when the remainder has grown sufficiently large.
+  void AddScaledCount(Sample value, int count);
+
+  int32_t scale() const { return scale_; }
+  LinearHistogram* histogram() { return histogram_; }
+
+ private:
+  // Pointer to the underlying histogram. Ownership of it remains with
+  // the statistics-recorder.
+  LinearHistogram* const histogram_;
+
+  // The scale factor of the sample counts.
+  const int32_t scale_;
+
+  // A vector of "remainder" counts indexed by bucket number. These values
+  // may be negative as the scaled count is actually bumped once the
+  // remainder is 1/2 way to the scale value (thus "rounding").
+  std::vector<AtomicCount> remainders_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScaledLinearHistogram);
+};
+
+//------------------------------------------------------------------------------
+
+// BooleanHistogram is a histogram for booleans.
+class BASE_EXPORT BooleanHistogram : public LinearHistogram {
+ public:
+  static HistogramBase* FactoryGet(const std::string& name, int32_t flags);
+
+  // Overload of the above function that takes a const char* |name| param,
+  // to avoid code bloat from the std::string constructor being inlined into
+  // call sites.
+  static HistogramBase* FactoryGet(const char* name, int32_t flags);
+
+  // Create a histogram using data in persistent storage.
+  static std::unique_ptr<HistogramBase> PersistentCreate(
+      const char* name,
+      const BucketRanges* ranges,
+      const DelayedPersistentAllocation& counts,
+      const DelayedPersistentAllocation& logged_counts,
+      HistogramSamples::Metadata* meta,
+      HistogramSamples::Metadata* logged_meta);
+
+  HistogramType GetHistogramType() const override;
+
+ protected:
+  class Factory;
+
+ private:
+  BooleanHistogram(const char* name, const BucketRanges* ranges);
+  BooleanHistogram(const char* name,
+                   const BucketRanges* ranges,
+                   const DelayedPersistentAllocation& counts,
+                   const DelayedPersistentAllocation& logged_counts,
+                   HistogramSamples::Metadata* meta,
+                   HistogramSamples::Metadata* logged_meta);
+
+  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
+      base::PickleIterator* iter);
+  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
+
+  DISALLOW_COPY_AND_ASSIGN(BooleanHistogram);
+};
+
+//------------------------------------------------------------------------------
+
+// CustomHistogram is a histogram for a set of custom integers.
+class BASE_EXPORT CustomHistogram : public Histogram {
+ public:
+  // |custom_ranges| contains a vector of limits on ranges. Each limit should be
+  // > 0 and < kSampleType_MAX. (Currently 0 is still accepted for backward
+  // compatibility). The limits can be unordered or contain duplication, but
+  // client should not depend on this.
+  static HistogramBase* FactoryGet(const std::string& name,
+                                   const std::vector<Sample>& custom_ranges,
+                                   int32_t flags);
+
+  // Overload of the above function that takes a const char* |name| param,
+  // to avoid code bloat from the std::string constructor being inlined into
+  // call sites.
+  static HistogramBase* FactoryGet(const char* name,
+                                   const std::vector<Sample>& custom_ranges,
+                                   int32_t flags);
+
+  // Create a histogram using data in persistent storage.
+  static std::unique_ptr<HistogramBase> PersistentCreate(
+      const char* name,
+      const BucketRanges* ranges,
+      const DelayedPersistentAllocation& counts,
+      const DelayedPersistentAllocation& logged_counts,
+      HistogramSamples::Metadata* meta,
+      HistogramSamples::Metadata* logged_meta);
+
+  // Overridden from Histogram:
+  HistogramType GetHistogramType() const override;
+
+  // Helper method for transforming an array of valid enumeration values
+  // to the std::vector<int> expected by UMA_HISTOGRAM_CUSTOM_ENUMERATION.
+  // This function ensures that a guard bucket exists right after any
+  // valid sample value (unless the next higher sample is also a valid value),
+  // so that invalid samples never fall into the same bucket as valid samples.
+  static std::vector<Sample> ArrayToCustomEnumRanges(
+      base::span<const Sample> values);
+
+ protected:
+  class Factory;
+
+  CustomHistogram(const char* name, const BucketRanges* ranges);
+
+  CustomHistogram(const char* name,
+                  const BucketRanges* ranges,
+                  const DelayedPersistentAllocation& counts,
+                  const DelayedPersistentAllocation& logged_counts,
+                  HistogramSamples::Metadata* meta,
+                  HistogramSamples::Metadata* logged_meta);
+
+  // HistogramBase implementation:
+  void SerializeInfoImpl(base::Pickle* pickle) const override;
+
+  double GetBucketSize(Count current, uint32_t i) const override;
+
+ private:
+  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
+      base::PickleIterator* iter);
+  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
+
+  static bool ValidateCustomRanges(const std::vector<Sample>& custom_ranges);
+
+  DISALLOW_COPY_AND_ASSIGN(CustomHistogram);
+};
+
+}  // namespace base
+
+#endif  // BASE_METRICS_HISTOGRAM_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram_base.h b/native/zucchini/vendor/libchrome/base/metrics/histogram_base.h
new file mode 100644
index 0000000..f128ff2
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/metrics/histogram_base.h
@@ -0,0 +1,307 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_METRICS_HISTOGRAM_BASE_H_
+#define BASE_METRICS_HISTOGRAM_BASE_H_
+
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "base/atomicops.h"
+#include "base/base_export.h"
+#include "base/macros.h"
+#include "base/strings/string_piece.h"
+#include "base/time/time.h"
+
+namespace base {
+
+class DictionaryValue;
+class HistogramBase;
+class HistogramSamples;
+class ListValue;
+class Pickle;
+class PickleIterator;
+
+////////////////////////////////////////////////////////////////////////////////
+// This enum is used to facilitate deserialization of histograms from other
+// processes into the browser. If you create another class that inherits from
+// HistogramBase, add new histogram types and names below.
+
+enum HistogramType {
+  HISTOGRAM,
+  LINEAR_HISTOGRAM,
+  BOOLEAN_HISTOGRAM,
+  CUSTOM_HISTOGRAM,
+  SPARSE_HISTOGRAM,
+  DUMMY_HISTOGRAM,
+};
+
+// Controls the verbosity of the information when the histogram is serialized to
+// a JSON.
+// GENERATED_JAVA_ENUM_PACKAGE: org.chromium.base.metrics
+enum JSONVerbosityLevel {
+  // The histogram is completely serialized.
+  JSON_VERBOSITY_LEVEL_FULL,
+  // The bucket information is not serialized.
+  JSON_VERBOSITY_LEVEL_OMIT_BUCKETS,
+};
+
+std::string HistogramTypeToString(HistogramType type);
+
+// This enum is used for reporting how many histograms and of what types and
+// variations are being created. It has to be in the main .h file so it is
+// visible to files that define the various histogram types.
+enum HistogramReport {
+  // Count the number of reports created. The other counts divided by this
+  // number will give the average per run of the program.
+  HISTOGRAM_REPORT_CREATED = 0,
+
+  // Count the total number of histograms created. It is the limit against
+  // which all others are compared.
+  HISTOGRAM_REPORT_HISTOGRAM_CREATED = 1,
+
+  // Count the total number of histograms looked-up. It's better to cache
+  // the result of a single lookup rather than do it repeatedly.
+  HISTOGRAM_REPORT_HISTOGRAM_LOOKUP = 2,
+
+  // These count the individual histogram types. This must follow the order
+  // of HistogramType above.
+  HISTOGRAM_REPORT_TYPE_LOGARITHMIC = 3,
+  HISTOGRAM_REPORT_TYPE_LINEAR = 4,
+  HISTOGRAM_REPORT_TYPE_BOOLEAN = 5,
+  HISTOGRAM_REPORT_TYPE_CUSTOM = 6,
+  HISTOGRAM_REPORT_TYPE_SPARSE = 7,
+
+  // These indicate the individual flags that were set.
+  HISTOGRAM_REPORT_FLAG_UMA_TARGETED = 8,
+  HISTOGRAM_REPORT_FLAG_UMA_STABILITY = 9,
+  HISTOGRAM_REPORT_FLAG_PERSISTENT = 10,
+
+  // This must be last.
+  HISTOGRAM_REPORT_MAX = 11
+};
+
+// Create or find existing histogram that matches the pickled info.
+// Returns NULL if the pickled data has problems.
+BASE_EXPORT HistogramBase* DeserializeHistogramInfo(base::PickleIterator* iter);
+
+////////////////////////////////////////////////////////////////////////////////
+
+class BASE_EXPORT HistogramBase {
+ public:
+  typedef int32_t Sample;                // Used for samples.
+  typedef subtle::Atomic32 AtomicCount;  // Used to count samples.
+  typedef int32_t Count;  // Used to manipulate counts in temporaries.
+
+  static const Sample kSampleType_MAX;  // INT_MAX
+
+  enum Flags {
+    kNoFlags = 0x0,
+
+    // Histogram should be UMA uploaded.
+    kUmaTargetedHistogramFlag = 0x1,
+
+    // Indicates that this is a stability histogram. This flag exists to specify
+    // which histograms should be included in the initial stability log. Please
+    // refer to |MetricsService::PrepareInitialStabilityLog|.
+    kUmaStabilityHistogramFlag = kUmaTargetedHistogramFlag | 0x2,
+
+    // Indicates that the histogram was pickled to be sent across an IPC
+    // Channel. If we observe this flag on a histogram being aggregated into
+    // after IPC, then we are running in a single process mode, and the
+    // aggregation should not take place (as we would be aggregating back into
+    // the source histogram!).
+    kIPCSerializationSourceFlag = 0x10,
+
+    // Indicates that a callback exists for when a new sample is recorded on
+    // this histogram. We store this as a flag with the histogram since
+    // histograms can be in performance critical code, and this allows us
+    // to shortcut looking up the callback if it doesn't exist.
+    kCallbackExists = 0x20,
+
+    // Indicates that the histogram is held in "persistent" memory and may
+    // be accessible between processes. This is only possible if such a
+    // memory segment has been created/attached, used to create a Persistent-
+    // MemoryAllocator, and that loaded into the Histogram module before this
+    // histogram is created.
+    kIsPersistent = 0x40,
+  };
+
+  // Histogram data inconsistency types.
+  enum Inconsistency : uint32_t {
+    NO_INCONSISTENCIES = 0x0,
+    RANGE_CHECKSUM_ERROR = 0x1,
+    BUCKET_ORDER_ERROR = 0x2,
+    COUNT_HIGH_ERROR = 0x4,
+    COUNT_LOW_ERROR = 0x8,
+
+    NEVER_EXCEEDED_VALUE = 0x10,
+  };
+
+  // Construct the base histogram. The name is not copied; it's up to the
+  // caller to ensure that it lives at least as long as this object.
+  explicit HistogramBase(const char* name);
+  virtual ~HistogramBase();
+
+  const char* histogram_name() const { return histogram_name_; }
+
+  // Compares |name| to the histogram name and triggers a DCHECK if they do not
+  // match. This is a helper function used by histogram macros, which results in
+  // in more compact machine code being generated by the macros.
+  virtual void CheckName(const StringPiece& name) const;
+
+  // Get a unique ID for this histogram's samples.
+  virtual uint64_t name_hash() const = 0;
+
+  // Operations with Flags enum.
+  int32_t flags() const { return subtle::NoBarrier_Load(&flags_); }
+  void SetFlags(int32_t flags);
+  void ClearFlags(int32_t flags);
+
+  virtual HistogramType GetHistogramType() const = 0;
+
+  // Whether the histogram has construction arguments as parameters specified.
+  // For histograms that don't have the concept of minimum, maximum or
+  // bucket_count, this function always returns false.
+  virtual bool HasConstructionArguments(
+      Sample expected_minimum,
+      Sample expected_maximum,
+      uint32_t expected_bucket_count) const = 0;
+
+  virtual void Add(Sample value) = 0;
+
+  // In Add function the |value| bucket is increased by one, but in some use
+  // cases we need to increase this value by an arbitrary integer. AddCount
+  // function increases the |value| bucket by |count|. |count| should be greater
+  // than or equal to 1.
+  virtual void AddCount(Sample value, int count) = 0;
+
+  // Similar to above but divides |count| by the |scale| amount. Probabilistic
+  // rounding is used to yield a reasonably accurate total when many samples
+  // are added. Methods for common cases of scales 1000 and 1024 are included.
+  // The ScaledLinearHistogram (which can also used be for enumerations) may be
+  // a better (and faster) solution.
+  void AddScaled(Sample value, int count, int scale);
+  void AddKilo(Sample value, int count);  // scale=1000
+  void AddKiB(Sample value, int count);   // scale=1024
+
+  // Convenient functions that call Add(Sample).
+  void AddTime(const TimeDelta& time) { AddTimeMillisecondsGranularity(time); }
+  void AddTimeMillisecondsGranularity(const TimeDelta& time);
+  // Note: AddTimeMicrosecondsGranularity() drops the report if this client
+  // doesn't have a high-resolution clock.
+  void AddTimeMicrosecondsGranularity(const TimeDelta& time);
+  void AddBoolean(bool value);
+
+  virtual void AddSamples(const HistogramSamples& samples) = 0;
+  virtual bool AddSamplesFromPickle(base::PickleIterator* iter) = 0;
+
+  // Serialize the histogram info into |pickle|.
+  // Note: This only serializes the construction arguments of the histogram, but
+  // does not serialize the samples.
+  void SerializeInfo(base::Pickle* pickle) const;
+
+  // Try to find out data corruption from histogram and the samples.
+  // The returned value is a combination of Inconsistency enum.
+  virtual uint32_t FindCorruption(const HistogramSamples& samples) const;
+
+  // Snapshot the current complete set of sample data.
+  // Override with atomic/locked snapshot if needed.
+  // NOTE: this data can overflow for long-running sessions. It should be
+  // handled with care and this method is recommended to be used only
+  // in about:histograms and test code.
+  virtual std::unique_ptr<HistogramSamples> SnapshotSamples() const = 0;
+
+  // Calculate the change (delta) in histogram counts since the previous call
+  // to this method. Each successive call will return only those counts
+  // changed since the last call.
+  virtual std::unique_ptr<HistogramSamples> SnapshotDelta() = 0;
+
+  // Calculate the change (delta) in histogram counts since the previous call
+  // to SnapshotDelta() but do so without modifying any internal data as to
+  // what was previous logged. After such a call, no further calls to this
+  // method or to SnapshotDelta() should be done as the result would include
+  // data previously returned. Because no internal data is changed, this call
+  // can be made on "const" histograms such as those with data held in
+  // read-only memory.
+  virtual std::unique_ptr<HistogramSamples> SnapshotFinalDelta() const = 0;
+
+  // The following methods provide graphical histogram displays.
+  virtual void WriteHTMLGraph(std::string* output) const = 0;
+  virtual void WriteAscii(std::string* output) const = 0;
+
+  // TODO(bcwhite): Remove this after https://crbug/836875.
+  virtual void ValidateHistogramContents() const;
+
+  // Produce a JSON representation of the histogram with |verbosity_level| as
+  // the serialization verbosity. This is implemented with the help of
+  // GetParameters and GetCountAndBucketData; overwrite them to customize the
+  // output.
+  void WriteJSON(std::string* output, JSONVerbosityLevel verbosity_level) const;
+
+ protected:
+  enum ReportActivity { HISTOGRAM_CREATED, HISTOGRAM_LOOKUP };
+
+  // Subclasses should implement this function to make SerializeInfo work.
+  virtual void SerializeInfoImpl(base::Pickle* pickle) const = 0;
+
+  // Writes information about the construction parameters in |params|.
+  virtual void GetParameters(DictionaryValue* params) const = 0;
+
+  // Writes information about the current (non-empty) buckets and their sample
+  // counts to |buckets|, the total sample count to |count| and the total sum
+  // to |sum|.
+  virtual void GetCountAndBucketData(Count* count,
+                                     int64_t* sum,
+                                     ListValue* buckets) const = 0;
+
+  //// Produce actual graph (set of blank vs non blank char's) for a bucket.
+  void WriteAsciiBucketGraph(double current_size,
+                             double max_size,
+                             std::string* output) const;
+
+  // Return a string description of what goes in a given bucket.
+  const std::string GetSimpleAsciiBucketRange(Sample sample) const;
+
+  // Write textual description of the bucket contents (relative to histogram).
+  // Output is the count in the buckets, as well as the percentage.
+  void WriteAsciiBucketValue(Count current,
+                             double scaled_sum,
+                             std::string* output) const;
+
+  // Retrieves the callback for this histogram, if one exists, and runs it
+  // passing |sample| as the parameter.
+  void FindAndRunCallback(Sample sample) const;
+
+  // Gets a permanent string that can be used for histogram objects when the
+  // original is not a code constant or held in persistent memory.
+  static const char* GetPermanentName(const std::string& name);
+
+ private:
+  friend class HistogramBaseTest;
+
+  // A pointer to permanent storage where the histogram name is held. This can
+  // be code space or the output of GetPermanentName() or any other storage
+  // that is known to never change. This is not StringPiece because (a) char*
+  // is 1/2 the size and (b) StringPiece transparently casts from std::string
+  // which can easily lead to a pointer to non-permanent space.
+  // For persistent histograms, this will simply point into the persistent
+  // memory segment, thus avoiding duplication. For heap histograms, the
+  // GetPermanentName method will create the necessary copy.
+  const char* const histogram_name_;
+
+  // Additional information about the histogram.
+  AtomicCount flags_;
+
+  DISALLOW_COPY_AND_ASSIGN(HistogramBase);
+};
+
+}  // namespace base
+
+#endif  // BASE_METRICS_HISTOGRAM_BASE_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram_functions.h b/native/zucchini/vendor/libchrome/base/metrics/histogram_functions.h
new file mode 100644
index 0000000..60c0057
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/metrics/histogram_functions.h
@@ -0,0 +1,158 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_METRICS_HISTOGRAM_FUNCTIONS_H_
+#define BASE_METRICS_HISTOGRAM_FUNCTIONS_H_
+
+#include "base/metrics/histogram.h"
+#include "base/metrics/histogram_base.h"
+#include "base/time/time.h"
+
+// Functions for recording metrics.
+//
+// For best practices on deciding when to emit to a histogram and what form
+// the histogram should take, see
+// https://chromium.googlesource.com/chromium/src.git/+/HEAD/tools/metrics/histograms/README.md
+
+// Functions for recording UMA histograms. These can be used for cases
+// when the histogram name is generated at runtime. The functionality is
+// equivalent to macros defined in histogram_macros.h but allowing non-constant
+// histogram names. These functions are slower compared to their macro
+// equivalent because the histogram objects are not cached between calls.
+// So, these shouldn't be used in performance critical code.
+namespace base {
+
+// For histograms with linear buckets.
+// Used for capturing integer data with a linear bucketing scheme. This can be
+// used when you want the exact value of some small numeric count, with a max of
+// 100 or less. If you need to capture a range of greater than 100, we recommend
+// the use of the COUNT histograms below.
+// Sample usage:
+//   base::UmaHistogramExactLinear("Histogram.Linear", some_value, 10);
+BASE_EXPORT void UmaHistogramExactLinear(const std::string& name,
+                                         int sample,
+                                         int value_max);
+
+// For adding a sample to an enumerated histogram.
+// Sample usage:
+//   // These values are persisted to logs. Entries should not be renumbered and
+//   // numeric values should never be reused.
+//   enum class MyEnum {
+//     FIRST_VALUE = 0,
+//     SECOND_VALUE = 1,
+//     ...
+//     FINAL_VALUE = N,
+//     COUNT
+//   };
+//   base::UmaHistogramEnumeration("My.Enumeration",
+//                                 MyEnum::SOME_VALUE, MyEnum::COUNT);
+//
+// Note: The value in |sample| must be strictly less than |enum_size|.
+template <typename T>
+void UmaHistogramEnumeration(const std::string& name, T sample, T enum_size) {
+  static_assert(std::is_enum<T>::value,
+                "Non enum passed to UmaHistogramEnumeration");
+  DCHECK_LE(static_cast<uintmax_t>(enum_size), static_cast<uintmax_t>(INT_MAX));
+  DCHECK_LT(static_cast<uintmax_t>(sample), static_cast<uintmax_t>(enum_size));
+  return UmaHistogramExactLinear(name, static_cast<int>(sample),
+                                 static_cast<int>(enum_size));
+}
+
+// Same as above, but uses T::kMaxValue as the inclusive maximum value of the
+// enum.
+template <typename T>
+void UmaHistogramEnumeration(const std::string& name, T sample) {
+  static_assert(std::is_enum<T>::value,
+                "Non enum passed to UmaHistogramEnumeration");
+  DCHECK_LE(static_cast<uintmax_t>(T::kMaxValue),
+            static_cast<uintmax_t>(INT_MAX) - 1);
+  DCHECK_LE(static_cast<uintmax_t>(sample),
+            static_cast<uintmax_t>(T::kMaxValue));
+  return UmaHistogramExactLinear(name, static_cast<int>(sample),
+                                 static_cast<int>(T::kMaxValue) + 1);
+}
+
+// For adding boolean sample to histogram.
+// Sample usage:
+//   base::UmaHistogramBoolean("My.Boolean", true)
+BASE_EXPORT void UmaHistogramBoolean(const std::string& name, bool sample);
+
+// For adding histogram with percent.
+// Percents are integer between 1 and 100.
+// Sample usage:
+//   base::UmaHistogramPercentage("My.Percent", 69)
+BASE_EXPORT void UmaHistogramPercentage(const std::string& name, int percent);
+
+// For adding counts histogram.
+// Sample usage:
+//   base::UmaHistogramCustomCounts("My.Counts", some_value, 1, 600, 30)
+BASE_EXPORT void UmaHistogramCustomCounts(const std::string& name,
+                                          int sample,
+                                          int min,
+                                          int max,
+                                          int buckets);
+
+// Counts specialization for maximum counts 100, 1000, 10k, 100k, 1M and 10M.
+BASE_EXPORT void UmaHistogramCounts100(const std::string& name, int sample);
+BASE_EXPORT void UmaHistogramCounts1000(const std::string& name, int sample);
+BASE_EXPORT void UmaHistogramCounts10000(const std::string& name, int sample);
+BASE_EXPORT void UmaHistogramCounts100000(const std::string& name, int sample);
+BASE_EXPORT void UmaHistogramCounts1M(const std::string& name, int sample);
+BASE_EXPORT void UmaHistogramCounts10M(const std::string& name, int sample);
+
+// For histograms storing times.
+BASE_EXPORT void UmaHistogramCustomTimes(const std::string& name,
+                                         TimeDelta sample,
+                                         TimeDelta min,
+                                         TimeDelta max,
+                                         int buckets);
+// For short timings from 1 ms up to 10 seconds (50 buckets).
+BASE_EXPORT void UmaHistogramTimes(const std::string& name, TimeDelta sample);
+// For medium timings up to 3 minutes (50 buckets).
+BASE_EXPORT void UmaHistogramMediumTimes(const std::string& name,
+                                         TimeDelta sample);
+// For time intervals up to 1 hr (50 buckets).
+BASE_EXPORT void UmaHistogramLongTimes(const std::string& name,
+                                       TimeDelta sample);
+
+// For recording memory related histograms.
+// Used to measure common KB-granularity memory stats. Range is up to 500M.
+BASE_EXPORT void UmaHistogramMemoryKB(const std::string& name, int sample);
+// Used to measure common MB-granularity memory stats. Range is up to ~1G.
+BASE_EXPORT void UmaHistogramMemoryMB(const std::string& name, int sample);
+// Used to measure common MB-granularity memory stats. Range is up to ~64G.
+BASE_EXPORT void UmaHistogramMemoryLargeMB(const std::string& name, int sample);
+
+// For recording sparse histograms.
+// The |sample| can be a negative or non-negative number.
+//
+// Sparse histograms are well suited for recording counts of exact sample values
+// that are sparsely distributed over a relatively large range, in cases where
+// ultra-fast performance is not critical. For instance, Sqlite.Version.* are
+// sparse because for any given database, there's going to be exactly one
+// version logged.
+//
+// Performance:
+// ------------
+// Sparse histograms are typically more memory-efficient but less time-efficient
+// than other histograms. Essentially, they sparse histograms use a map rather
+// than a vector for their backing storage; they also require lock acquisition
+// to increment a sample, whereas other histogram do not. Hence, each increment
+// operation is a bit slower than for other histograms. But, if the data is
+// sparse, then they use less memory client-side, because they allocate buckets
+// on demand rather than preallocating.
+//
+// Data size:
+// ----------
+// Note that server-side, we still need to load all buckets, across all users,
+// at once. Thus, please avoid exploding such histograms, i.e. uploading many
+// many distinct values to the server (across all users). Concretely, keep the
+// number of distinct values <= 100 ideally, definitely <= 1000. If you have no
+// guarantees on the range of your data, use clamping, e.g.:
+//   UmaHistogramSparse("MyHistogram", ClampToRange(value, 0, 200));
+BASE_EXPORT void UmaHistogramSparse(const std::string& name, int sample);
+
+}  // namespace base
+
+#endif  // BASE_METRICS_HISTOGRAM_FUNCTIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram_macros.h b/native/zucchini/vendor/libchrome/base/metrics/histogram_macros.h
new file mode 100644
index 0000000..93bd4bd
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/metrics/histogram_macros.h
@@ -0,0 +1,382 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_METRICS_HISTOGRAM_MACROS_H_
+#define BASE_METRICS_HISTOGRAM_MACROS_H_
+
+#include "base/macros.h"
+#include "base/metrics/histogram.h"
+#include "base/metrics/histogram_macros_internal.h"
+#include "base/metrics/histogram_macros_local.h"
+#include "base/time/time.h"
+
+
+// Macros for efficient use of histograms.
+//
+// For best practices on deciding when to emit to a histogram and what form
+// the histogram should take, see
+// https://chromium.googlesource.com/chromium/src.git/+/HEAD/tools/metrics/histograms/README.md
+
+// TODO(rkaplow): Link to proper documentation on metric creation once we have
+// it in a good state.
+
+// All of these macros must be called with |name| as a runtime constant - it
+// doesn't have to literally be a constant, but it must be the same string on
+// all calls from a particular call site. If this rule is violated, it is
+// possible the data will be written to the wrong histogram.
+
+//------------------------------------------------------------------------------
+// Enumeration histograms.
+
+// These macros create histograms for enumerated data. Ideally, the data should
+// be of the form of "event occurs, log the result". We recommended not putting
+// related but not directly connected data as enums within the same histogram.
+// You should be defining an associated Enum, and the input sample should be
+// an element of the Enum.
+// All of these macros must be called with |name| as a runtime constant.
+
+// The first variant of UMA_HISTOGRAM_ENUMERATION accepts two arguments: the
+// histogram name and the enum sample. It deduces the correct boundary value to
+// use by looking for an enumerator with the name kMaxValue. kMaxValue should
+// share the value of the highest enumerator: this avoids switch statements
+// having to handle a sentinel no-op value.
+//
+// Sample usage:
+//   // These values are persisted to logs. Entries should not be renumbered and
+//   // numeric values should never be reused.
+//   enum class MyEnum {
+//     kFirstValue = 0,
+//     kSecondValue = 1,
+//     ...
+//     kFinalValue = N,
+//     kMaxValue = kFinalValue,
+//   };
+//   UMA_HISTOGRAM_ENUMERATION("My.Enumeration", MyEnum::kSomeValue);
+//
+// The second variant requires three arguments: the first two are the same as
+// before, and the third argument is the enum boundary: this must be strictly
+// greater than any other enumerator that will be sampled.
+//
+// Sample usage:
+//   // These values are persisted to logs. Entries should not be renumbered and
+//   // numeric values should never be reused.
+//   enum class MyEnum {
+//     FIRST_VALUE = 0,
+//     SECOND_VALUE = 1,
+//     ...
+//     FINAL_VALUE = N,
+//     COUNT
+//   };
+//   UMA_HISTOGRAM_ENUMERATION("My.Enumeration",
+//                             MyEnum::SOME_VALUE, MyEnum::COUNT);
+//
+// Note: If the enum is used in a switch, it is often desirable to avoid writing
+// a case statement to handle an unused sentinel value (i.e. COUNT in the above
+// example). For scoped enums, this is awkward since it requires casting the
+// enum to an arithmetic type and adding one. Instead, prefer the two argument
+// version of the macro which automatically deduces the boundary from kMaxValue.
+#define UMA_HISTOGRAM_ENUMERATION(name, ...)                            \
+  CR_EXPAND_ARG(INTERNAL_UMA_HISTOGRAM_ENUMERATION_GET_MACRO(           \
+      __VA_ARGS__, INTERNAL_UMA_HISTOGRAM_ENUMERATION_SPECIFY_BOUNDARY, \
+      INTERNAL_UMA_HISTOGRAM_ENUMERATION_DEDUCE_BOUNDARY)(              \
+      name, __VA_ARGS__, base::HistogramBase::kUmaTargetedHistogramFlag))
+
+// As above but "scaled" count to avoid overflows caused by increments of
+// large amounts. See UMA_HISTOGRAM_SCALED_EXACT_LINEAR for more information.
+// Only the new format utilizing an internal kMaxValue is supported.
+// It'll be necessary to #include "base/lazy_instance.h" to use this macro.
+#define UMA_HISTOGRAM_SCALED_ENUMERATION(name, sample, count, scale) \
+  INTERNAL_HISTOGRAM_SCALED_ENUMERATION_WITH_FLAG(                   \
+      name, sample, count, scale,                                    \
+      base::HistogramBase::kUmaTargetedHistogramFlag)
+
+// Histogram for boolean values.
+
+// Sample usage:
+//   UMA_HISTOGRAM_BOOLEAN("Histogram.Boolean", bool);
+#define UMA_HISTOGRAM_BOOLEAN(name, sample)                                    \
+    STATIC_HISTOGRAM_POINTER_BLOCK(name, AddBoolean(sample),                   \
+        base::BooleanHistogram::FactoryGet(name,                               \
+            base::HistogramBase::kUmaTargetedHistogramFlag))
+
+//------------------------------------------------------------------------------
+// Linear histograms.
+
+// All of these macros must be called with |name| as a runtime constant.
+
+// Used for capturing integer data with a linear bucketing scheme. This can be
+// used when you want the exact value of some small numeric count, with a max of
+// 100 or less. If you need to capture a range of greater than 100, we recommend
+// the use of the COUNT histograms below.
+
+// Sample usage:
+//   UMA_HISTOGRAM_EXACT_LINEAR("Histogram.Linear", count, 10);
+#define UMA_HISTOGRAM_EXACT_LINEAR(name, sample, value_max) \
+  INTERNAL_HISTOGRAM_EXACT_LINEAR_WITH_FLAG(                \
+      name, sample, value_max, base::HistogramBase::kUmaTargetedHistogramFlag)
+
+// Used for capturing basic percentages. This will be 100 buckets of size 1.
+
+// Sample usage:
+//   UMA_HISTOGRAM_PERCENTAGE("Histogram.Percent", percent_as_int);
+#define UMA_HISTOGRAM_PERCENTAGE(name, percent_as_int) \
+  UMA_HISTOGRAM_EXACT_LINEAR(name, percent_as_int, 101)
+
+//------------------------------------------------------------------------------
+// Scaled Linear histograms.
+
+// These take |count| and |scale| parameters to allow cumulative reporting of
+// large numbers. Only the scaled count is reported but the reminder is kept so
+// multiple calls will accumulate correctly.  Only "exact linear" is supported.
+// It'll be necessary to #include "base/lazy_instance.h" to use this macro.
+
+#define UMA_HISTOGRAM_SCALED_EXACT_LINEAR(name, sample, count, value_max, \
+                                          scale)                          \
+  INTERNAL_HISTOGRAM_SCALED_EXACT_LINEAR_WITH_FLAG(                       \
+      name, sample, count, value_max, scale,                              \
+      base::HistogramBase::kUmaTargetedHistogramFlag)
+
+//------------------------------------------------------------------------------
+// Count histograms. These are used for collecting numeric data. Note that we
+// have macros for more specialized use cases below (memory, time, percentages).
+
+// The number suffixes here refer to the max size of the sample, i.e. COUNT_1000
+// will be able to collect samples of counts up to 1000. The default number of
+// buckets in all default macros is 50. We recommend erring on the side of too
+// large a range versus too short a range.
+// These macros default to exponential histograms - i.e. the lengths of the
+// bucket ranges exponentially increase as the sample range increases.
+// These should *not* be used if you are interested in exact counts, i.e. a
+// bucket range of 1. In these cases, you should use the ENUMERATION macros
+// defined later. These should also not be used to capture the number of some
+// event, i.e. "button X was clicked N times". In this cases, an enum should be
+// used, ideally with an appropriate baseline enum entry included.
+// All of these macros must be called with |name| as a runtime constant.
+
+// Sample usage:
+//   UMA_HISTOGRAM_COUNTS_1M("My.Histogram", sample);
+
+#define UMA_HISTOGRAM_COUNTS_100(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(    \
+    name, sample, 1, 100, 50)
+
+#define UMA_HISTOGRAM_COUNTS_1000(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(   \
+    name, sample, 1, 1000, 50)
+
+#define UMA_HISTOGRAM_COUNTS_10000(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(  \
+    name, sample, 1, 10000, 50)
+
+#define UMA_HISTOGRAM_COUNTS_100000(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS( \
+    name, sample, 1, 100000, 50)
+
+#define UMA_HISTOGRAM_COUNTS_1M(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(     \
+    name, sample, 1, 1000000, 50)
+
+#define UMA_HISTOGRAM_COUNTS_10M(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(    \
+    name, sample, 1, 10000000, 50)
+
+// This can be used when the default ranges are not sufficient. This macro lets
+// the metric developer customize the min and max of the sampled range, as well
+// as the number of buckets recorded.
+// Any data outside the range here will be put in underflow and overflow
+// buckets. Min values should be >=1 as emitted 0s will still go into the
+// underflow bucket.
+
+// Sample usage:
+//   UMA_HISTOGRAM_CUSTOM_COUNTS("My.Histogram", 1, 100000000, 100);
+#define UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count)      \
+    INTERNAL_HISTOGRAM_CUSTOM_COUNTS_WITH_FLAG(                                \
+        name, sample, min, max, bucket_count,                                  \
+        base::HistogramBase::kUmaTargetedHistogramFlag)
+
+//------------------------------------------------------------------------------
+// Timing histograms. These are used for collecting timing data (generally
+// latencies).
+
+// These macros create exponentially sized histograms (lengths of the bucket
+// ranges exponentially increase as the sample range increases). The input
+// sample is a base::TimeDelta. The output data is measured in ms granularity.
+// All of these macros must be called with |name| as a runtime constant.
+
+// Sample usage:
+//   UMA_HISTOGRAM_TIMES("My.Timing.Histogram", time_delta);
+
+// Short timings - up to 10 seconds. For high-resolution (microseconds) timings,
+// see UMA_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES.
+#define UMA_HISTOGRAM_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES(          \
+    name, sample, base::TimeDelta::FromMilliseconds(1),                        \
+    base::TimeDelta::FromSeconds(10), 50)
+
+// Medium timings - up to 3 minutes. Note this starts at 10ms (no good reason,
+// but not worth changing).
+#define UMA_HISTOGRAM_MEDIUM_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES(   \
+    name, sample, base::TimeDelta::FromMilliseconds(10),                       \
+    base::TimeDelta::FromMinutes(3), 50)
+
+// Long timings - up to an hour.
+#define UMA_HISTOGRAM_LONG_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES(     \
+    name, sample, base::TimeDelta::FromMilliseconds(1),                        \
+    base::TimeDelta::FromHours(1), 50)
+
+// Long timings with higher granularity - up to an hour with 100 buckets.
+#define UMA_HISTOGRAM_LONG_TIMES_100(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES( \
+    name, sample, base::TimeDelta::FromMilliseconds(1),                        \
+    base::TimeDelta::FromHours(1), 100)
+
+// This can be used when the default ranges are not sufficient. This macro lets
+// the metric developer customize the min and max of the sampled range, as well
+// as the number of buckets recorded.
+
+// Sample usage:
+//   UMA_HISTOGRAM_CUSTOM_TIMES("Very.Long.Timing.Histogram", time_delta,
+//       base::TimeDelta::FromSeconds(1), base::TimeDelta::FromDays(1), 100);
+#define UMA_HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) \
+  STATIC_HISTOGRAM_POINTER_BLOCK(                                        \
+      name, AddTimeMillisecondsGranularity(sample),                      \
+      base::Histogram::FactoryTimeGet(                                   \
+          name, min, max, bucket_count,                                  \
+          base::HistogramBase::kUmaTargetedHistogramFlag))
+
+// Same as UMA_HISTOGRAM_CUSTOM_TIMES but reports |sample| in microseconds,
+// dropping the report if this client doesn't have a high-resolution clock.
+//
+// Note: dropping reports on clients with low-resolution clocks means these
+// reports will be biased to a portion of the population on Windows. See
+// Windows.HasHighResolutionTimeTicks for the affected sample.
+//
+// Sample usage:
+//  UMA_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(
+//      "High.Resolution.TimingMicroseconds.Histogram", time_delta,
+//      base::TimeDelta::FromMicroseconds(1),
+//      base::TimeDelta::FromMilliseconds(10), 100);
+#define UMA_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(name, sample, min, max, \
+                                                bucket_count)           \
+  STATIC_HISTOGRAM_POINTER_BLOCK(                                       \
+      name, AddTimeMicrosecondsGranularity(sample),                     \
+      base::Histogram::FactoryMicrosecondsTimeGet(                      \
+          name, min, max, bucket_count,                                 \
+          base::HistogramBase::kUmaTargetedHistogramFlag))
+
+// Scoped class which logs its time on this earth as a UMA statistic. This is
+// recommended for when you want a histogram which measures the time it takes
+// for a method to execute. This measures up to 10 seconds. It uses
+// UMA_HISTOGRAM_TIMES under the hood.
+
+// Sample usage:
+//   void Function() {
+//     SCOPED_UMA_HISTOGRAM_TIMER("Component.FunctionTime");
+//     ...
+//   }
+#define SCOPED_UMA_HISTOGRAM_TIMER(name)                                       \
+  INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_EXPANDER(name, false, __COUNTER__)
+
+// Similar scoped histogram timer, but this uses UMA_HISTOGRAM_LONG_TIMES_100,
+// which measures up to an hour, and uses 100 buckets. This is more expensive
+// to store, so only use if this often takes >10 seconds.
+#define SCOPED_UMA_HISTOGRAM_LONG_TIMER(name)                                  \
+  INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_EXPANDER(name, true, __COUNTER__)
+
+
+//------------------------------------------------------------------------------
+// Memory histograms.
+
+// These macros create exponentially sized histograms (lengths of the bucket
+// ranges exponentially increase as the sample range increases). The input
+// sample must be a number measured in kilobytes.
+// All of these macros must be called with |name| as a runtime constant.
+
+// Sample usage:
+//   UMA_HISTOGRAM_MEMORY_KB("My.Memory.Histogram", memory_in_kb);
+
+// Used to measure common KB-granularity memory stats. Range is up to 500000KB -
+// approximately 500M.
+#define UMA_HISTOGRAM_MEMORY_KB(name, sample)                                  \
+    UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1000, 500000, 50)
+
+// Used to measure common MB-granularity memory stats. Range is up to ~64G.
+#define UMA_HISTOGRAM_MEMORY_LARGE_MB(name, sample)                            \
+    UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 64000, 100)
+
+
+//------------------------------------------------------------------------------
+// Stability-specific histograms.
+
+// Histograms logged in as stability histograms will be included in the initial
+// stability log. See comments by declaration of
+// MetricsService::PrepareInitialStabilityLog().
+// All of these macros must be called with |name| as a runtime constant.
+
+// For details on usage, see the documentation on the non-stability equivalents.
+
+#define UMA_STABILITY_HISTOGRAM_COUNTS_100(name, sample)                       \
+    UMA_STABILITY_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 100, 50)
+
+#define UMA_STABILITY_HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max,          \
+                                              bucket_count)                    \
+    INTERNAL_HISTOGRAM_CUSTOM_COUNTS_WITH_FLAG(                                \
+        name, sample, min, max, bucket_count,                                  \
+        base::HistogramBase::kUmaStabilityHistogramFlag)
+
+#define UMA_STABILITY_HISTOGRAM_ENUMERATION(name, sample, enum_max)            \
+    INTERNAL_HISTOGRAM_ENUMERATION_WITH_FLAG(                                  \
+        name, sample, enum_max,                                                \
+        base::HistogramBase::kUmaStabilityHistogramFlag)
+
+//------------------------------------------------------------------------------
+// Histogram instantiation helpers.
+
+// Support a collection of histograms, perhaps one for each entry in an
+// enumeration. This macro manages a block of pointers, adding to a specific
+// one by its index.
+//
+// A typical instantiation looks something like this:
+//  STATIC_HISTOGRAM_POINTER_GROUP(
+//      GetHistogramNameForIndex(histogram_index),
+//      histogram_index, MAXIMUM_HISTOGRAM_INDEX, Add(some_delta),
+//      base::Histogram::FactoryGet(
+//          GetHistogramNameForIndex(histogram_index),
+//          MINIMUM_SAMPLE, MAXIMUM_SAMPLE, BUCKET_COUNT,
+//          base::HistogramBase::kUmaTargetedHistogramFlag));
+//
+// Though it seems inefficient to generate the name twice, the first
+// instance will be used only for DCHECK builds and the second will
+// execute only during the first access to the given index, after which
+// the pointer is cached and the name never needed again.
+#define STATIC_HISTOGRAM_POINTER_GROUP(constant_histogram_name, index,        \
+                                       constant_maximum,                      \
+                                       histogram_add_method_invocation,       \
+                                       histogram_factory_get_invocation)      \
+  do {                                                                        \
+    static base::subtle::AtomicWord atomic_histograms[constant_maximum];      \
+    DCHECK_LE(0, index);                                                      \
+    DCHECK_LT(index, constant_maximum);                                       \
+    HISTOGRAM_POINTER_USE(&atomic_histograms[index], constant_histogram_name, \
+                          histogram_add_method_invocation,                    \
+                          histogram_factory_get_invocation);                  \
+  } while (0)
+
+//------------------------------------------------------------------------------
+// Deprecated histogram macros. Not recommended for current use.
+
+// Legacy name for UMA_HISTOGRAM_COUNTS_1M. Suggest using explicit naming
+// and not using this macro going forward.
+#define UMA_HISTOGRAM_COUNTS(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(        \
+    name, sample, 1, 1000000, 50)
+
+// MB-granularity memory metric. This has a short max (1G).
+#define UMA_HISTOGRAM_MEMORY_MB(name, sample)                                  \
+    UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 1000, 50)
+
+// For an enum with customized range. In general, sparse histograms should be
+// used instead.
+// Samples should be one of the std::vector<int> list provided via
+// |custom_ranges|. See comments above CustomRanges::FactoryGet about the
+// requirement of |custom_ranges|. You can use the helper function
+// CustomHistogram::ArrayToCustomEnumRanges to transform a C-style array of
+// valid sample values to a std::vector<int>.
+#define UMA_HISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges)          \
+    STATIC_HISTOGRAM_POINTER_BLOCK(name, Add(sample),                          \
+        base::CustomHistogram::FactoryGet(name, custom_ranges,                 \
+            base::HistogramBase::kUmaTargetedHistogramFlag))
+
+#endif  // BASE_METRICS_HISTOGRAM_MACROS_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram_macros_internal.h b/native/zucchini/vendor/libchrome/base/metrics/histogram_macros_internal.h
new file mode 100644
index 0000000..cc7c76a
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/metrics/histogram_macros_internal.h
@@ -0,0 +1,268 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_METRICS_HISTOGRAM_MACROS_INTERNAL_H_
+#define BASE_METRICS_HISTOGRAM_MACROS_INTERNAL_H_
+
+#include <stdint.h>
+
+#include <limits>
+#include <type_traits>
+
+#include "base/atomicops.h"
+#include "base/logging.h"
+#include "base/metrics/histogram.h"
+#include "base/metrics/sparse_histogram.h"
+#include "base/time/time.h"
+
+// This is for macros and helpers internal to base/metrics. They should not be
+// used outside of this directory. For writing to UMA histograms, see
+// histogram_macros.h.
+
+namespace base {
+namespace internal {
+
+// Helper traits for deducing the boundary value for enums.
+template <typename Enum, typename SFINAE = void>
+struct EnumSizeTraits {
+  static constexpr Enum Count() {
+    static_assert(
+        sizeof(Enum) == 0,
+        "enumerator must define kMaxValue enumerator to use this macro!");
+    return Enum();
+  }
+};
+
+// Since the UMA histogram macros expect a value one larger than the max defined
+// enumerator value, add one.
+template <typename Enum>
+struct EnumSizeTraits<
+    Enum,
+    std::enable_if_t<std::is_enum<decltype(Enum::kMaxValue)>::value>> {
+  static constexpr Enum Count() {
+    return static_cast<Enum>(
+        static_cast<std::underlying_type_t<Enum>>(Enum::kMaxValue) + 1);
+  }
+};
+
+}  // namespace internal
+}  // namespace base
+
+// TODO(rkaplow): Improve commenting of these methods.
+//------------------------------------------------------------------------------
+// Histograms are often put in areas where they are called many many times, and
+// performance is critical.  As a result, they are designed to have a very low
+// recurring cost of executing (adding additional samples). Toward that end,
+// the macros declare a static pointer to the histogram in question, and only
+// take a "slow path" to construct (or find) the histogram on the first run
+// through the macro. We leak the histograms at shutdown time so that we don't
+// have to validate using the pointers at any time during the running of the
+// process.
+
+// In some cases (integration into 3rd party code), it's useful to separate the
+// definition of |atomic_histogram_pointer| from its use. To achieve this we
+// define HISTOGRAM_POINTER_USE, which uses an |atomic_histogram_pointer|, and
+// STATIC_HISTOGRAM_POINTER_BLOCK, which defines an |atomic_histogram_pointer|
+// and forwards to HISTOGRAM_POINTER_USE.
+#define HISTOGRAM_POINTER_USE(atomic_histogram_pointer,                        \
+                              constant_histogram_name,                         \
+                              histogram_add_method_invocation,                 \
+                              histogram_factory_get_invocation)                \
+  do {                                                                         \
+    /*                                                                         \
+     * Acquire_Load() ensures that we acquire visibility to the                \
+     * pointed-to data in the histogram.                                       \
+     */                                                                        \
+    base::HistogramBase* histogram_pointer(                                    \
+        reinterpret_cast<base::HistogramBase*>(                                \
+            base::subtle::Acquire_Load(atomic_histogram_pointer)));            \
+    if (!histogram_pointer) {                                                  \
+      /*                                                                       \
+       * This is the slow path, which will construct OR find the               \
+       * matching histogram.  histogram_factory_get_invocation includes        \
+       * locks on a global histogram name map and is completely thread         \
+       * safe.                                                                 \
+       */                                                                      \
+      histogram_pointer = histogram_factory_get_invocation;                    \
+                                                                               \
+      /*                                                                       \
+       * Use Release_Store to ensure that the histogram data is made           \
+       * available globally before we make the pointer visible. Several        \
+       * threads may perform this store, but the same value will be            \
+       * stored in all cases (for a given named/spec'ed histogram).            \
+       * We could do this without any barrier, since FactoryGet entered        \
+       * and exited a lock after construction, but this barrier makes          \
+       * things clear.                                                         \
+       */                                                                      \
+      base::subtle::Release_Store(                                             \
+          atomic_histogram_pointer,                                            \
+          reinterpret_cast<base::subtle::AtomicWord>(histogram_pointer));      \
+    }                                                                          \
+    if (DCHECK_IS_ON())                                                        \
+      histogram_pointer->CheckName(constant_histogram_name);                   \
+    histogram_pointer->histogram_add_method_invocation;                        \
+  } while (0)
+
+// This is a helper macro used by other macros and shouldn't be used directly.
+// Defines the static |atomic_histogram_pointer| and forwards to
+// HISTOGRAM_POINTER_USE.
+#define STATIC_HISTOGRAM_POINTER_BLOCK(constant_histogram_name,                \
+                                       histogram_add_method_invocation,        \
+                                       histogram_factory_get_invocation)       \
+  do {                                                                         \
+    /*                                                                         \
+     * The pointer's presence indicates that the initialization is complete.   \
+     * Initialization is idempotent, so it can safely be atomically repeated.  \
+     */                                                                        \
+    static base::subtle::AtomicWord atomic_histogram_pointer = 0;              \
+    HISTOGRAM_POINTER_USE(&atomic_histogram_pointer, constant_histogram_name,  \
+                          histogram_add_method_invocation,                     \
+                          histogram_factory_get_invocation);                   \
+  } while (0)
+
+// This is a helper macro used by other macros and shouldn't be used directly.
+#define INTERNAL_HISTOGRAM_CUSTOM_COUNTS_WITH_FLAG(name, sample, min, max,     \
+                                                   bucket_count, flag)         \
+    STATIC_HISTOGRAM_POINTER_BLOCK(                                            \
+        name, Add(sample),                                                     \
+        base::Histogram::FactoryGet(name, min, max, bucket_count, flag))
+
+// This is a helper macro used by other macros and shouldn't be used directly.
+// The bucketing scheme is linear with a bucket size of 1. For N items,
+// recording values in the range [0, N - 1] creates a linear histogram with N +
+// 1 buckets:
+//   [0, 1), [1, 2), ..., [N - 1, N)
+// and an overflow bucket [N, infinity).
+//
+// Code should never emit to the overflow bucket; only to the other N buckets.
+// This allows future versions of Chrome to safely increase the boundary size.
+// Otherwise, the histogram would have [N - 1, infinity) as its overflow bucket,
+// and so the maximal value (N - 1) would be emitted to this overflow bucket.
+// But, if an additional value were later added, the bucket label for
+// the value (N - 1) would change to [N - 1, N), which would result in different
+// versions of Chrome using different bucket labels for identical data.
+#define INTERNAL_HISTOGRAM_EXACT_LINEAR_WITH_FLAG(name, sample, boundary,  \
+                                                  flag)                    \
+  do {                                                                     \
+    static_assert(!std::is_enum<decltype(sample)>::value,                  \
+                  "|sample| should not be an enum type!");                 \
+    static_assert(!std::is_enum<decltype(boundary)>::value,                \
+                  "|boundary| should not be an enum type!");               \
+    STATIC_HISTOGRAM_POINTER_BLOCK(                                        \
+        name, Add(sample),                                                 \
+        base::LinearHistogram::FactoryGet(name, 1, boundary, boundary + 1, \
+                                          flag));                          \
+  } while (0)
+
+// While this behaves the same as the above macro, the wrapping of a linear
+// histogram with another object to do the scaling means the POINTER_BLOCK
+// macro can't be used as it is tied to HistogramBase
+#define INTERNAL_HISTOGRAM_SCALED_EXACT_LINEAR_WITH_FLAG(                      \
+    name, sample, count, boundary, scale, flag)                                \
+  do {                                                                         \
+    static_assert(!std::is_enum<decltype(sample)>::value,                      \
+                  "|sample| should not be an enum type!");                     \
+    static_assert(!std::is_enum<decltype(boundary)>::value,                    \
+                  "|boundary| should not be an enum type!");                   \
+    class ScaledLinearHistogramInstance : public base::ScaledLinearHistogram { \
+     public:                                                                   \
+      ScaledLinearHistogramInstance()                                          \
+          : ScaledLinearHistogram(name,                                        \
+                                  1,                                           \
+                                  boundary,                                    \
+                                  boundary + 1,                                \
+                                  scale,                                       \
+                                  flag) {}                                     \
+    };                                                                         \
+    static base::LazyInstance<ScaledLinearHistogramInstance>::Leaky scaled;    \
+    scaled.Get().AddScaledCount(sample, count);                                \
+  } while (0)
+
+// Helper for 'overloading' UMA_HISTOGRAM_ENUMERATION with a variable number of
+// arguments.
+#define INTERNAL_UMA_HISTOGRAM_ENUMERATION_GET_MACRO(_1, _2, NAME, ...) NAME
+
+#define INTERNAL_UMA_HISTOGRAM_ENUMERATION_DEDUCE_BOUNDARY(name, sample,       \
+                                                           flags)              \
+  INTERNAL_HISTOGRAM_ENUMERATION_WITH_FLAG(                                    \
+      name, sample, base::internal::EnumSizeTraits<decltype(sample)>::Count(), \
+      flags)
+
+// Note: The value in |sample| must be strictly less than |enum_size|.
+#define INTERNAL_UMA_HISTOGRAM_ENUMERATION_SPECIFY_BOUNDARY(name, sample,     \
+                                                            enum_size, flags) \
+  INTERNAL_HISTOGRAM_ENUMERATION_WITH_FLAG(name, sample, enum_size, flags)
+
+// Similar to the previous macro but intended for enumerations. This delegates
+// the work to the previous macro, but supports scoped enumerations as well by
+// forcing an explicit cast to the HistogramBase::Sample integral type.
+//
+// Note the range checks verify two separate issues:
+// - that the declared enum size isn't out of range of HistogramBase::Sample
+// - that the declared enum size is > 0
+//
+// TODO(dcheng): This should assert that the passed in types are actually enum
+// types.
+#define INTERNAL_HISTOGRAM_ENUMERATION_WITH_FLAG(name, sample, boundary, flag) \
+  do {                                                                         \
+    using decayed_sample = std::decay<decltype(sample)>::type;                 \
+    using decayed_boundary = std::decay<decltype(boundary)>::type;             \
+    static_assert(!std::is_enum<decayed_boundary>::value ||                    \
+                      std::is_enum<decayed_sample>::value,                     \
+                  "Unexpected: |boundary| is enum, but |sample| is not.");     \
+    static_assert(!std::is_enum<decayed_sample>::value ||                      \
+                      !std::is_enum<decayed_boundary>::value ||                \
+                      std::is_same<decayed_sample, decayed_boundary>::value,   \
+                  "|sample| and |boundary| shouldn't be of different enums");  \
+    static_assert(                                                             \
+        static_cast<uintmax_t>(boundary) <                                     \
+            static_cast<uintmax_t>(                                            \
+                std::numeric_limits<base::HistogramBase::Sample>::max()),      \
+        "|boundary| is out of range of HistogramBase::Sample");                \
+    INTERNAL_HISTOGRAM_EXACT_LINEAR_WITH_FLAG(                                 \
+        name, static_cast<base::HistogramBase::Sample>(sample),                \
+        static_cast<base::HistogramBase::Sample>(boundary), flag);             \
+  } while (0)
+
+#define INTERNAL_HISTOGRAM_SCALED_ENUMERATION_WITH_FLAG(name, sample, count, \
+                                                        scale, flag)         \
+  do {                                                                       \
+    using decayed_sample = std::decay<decltype(sample)>::type;               \
+    static_assert(std::is_enum<decayed_sample>::value,                       \
+                  "Unexpected: |sample| is not at enum.");                   \
+    constexpr auto boundary =                                                \
+        base::internal::EnumSizeTraits<decltype(sample)>::Count();           \
+    static_assert(                                                           \
+        static_cast<uintmax_t>(boundary) <                                   \
+            static_cast<uintmax_t>(                                          \
+                std::numeric_limits<base::HistogramBase::Sample>::max()),    \
+        "|boundary| is out of range of HistogramBase::Sample");              \
+    INTERNAL_HISTOGRAM_SCALED_EXACT_LINEAR_WITH_FLAG(                        \
+        name, static_cast<base::HistogramBase::Sample>(sample), count,       \
+        static_cast<base::HistogramBase::Sample>(boundary), scale, flag);    \
+  } while (0)
+
+// This is a helper macro used by other macros and shouldn't be used directly.
+// This is necessary to expand __COUNTER__ to an actual value.
+#define INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_EXPANDER(name, is_long, key)       \
+  INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_UNIQUE(name, is_long, key)
+
+// This is a helper macro used by other macros and shouldn't be used directly.
+#define INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_UNIQUE(name, is_long, key)         \
+  class ScopedHistogramTimer##key {                                            \
+   public:                                                                     \
+    ScopedHistogramTimer##key() : constructed_(base::TimeTicks::Now()) {}      \
+    ~ScopedHistogramTimer##key() {                                             \
+      base::TimeDelta elapsed = base::TimeTicks::Now() - constructed_;         \
+      if (is_long) {                                                           \
+        UMA_HISTOGRAM_LONG_TIMES_100(name, elapsed);                           \
+      } else {                                                                 \
+        UMA_HISTOGRAM_TIMES(name, elapsed);                                    \
+      }                                                                        \
+    }                                                                          \
+   private:                                                                    \
+    base::TimeTicks constructed_;                                              \
+  } scoped_histogram_timer_##key
+
+#endif  // BASE_METRICS_HISTOGRAM_MACROS_INTERNAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram_macros_local.h b/native/zucchini/vendor/libchrome/base/metrics/histogram_macros_local.h
new file mode 100644
index 0000000..c4d333b
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/metrics/histogram_macros_local.h
@@ -0,0 +1,90 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_METRICS_HISTOGRAM_MACROS_LOCAL_H_
+#define BASE_METRICS_HISTOGRAM_MACROS_LOCAL_H_
+
+#include "base/logging.h"
+#include "base/metrics/histogram.h"
+#include "base/metrics/histogram_macros_internal.h"
+#include "base/time/time.h"
+
+// TODO(rkaplow): Migrate all LOCAL_* usage within Chromium to include this
+// file instead of the histogram_macros.h file.
+
+//------------------------------------------------------------------------------
+// Enumeration histograms.
+//
+// For usage details, see the equivalents in histogram_macros.h.
+
+#define LOCAL_HISTOGRAM_ENUMERATION(name, ...)                          \
+  CR_EXPAND_ARG(INTERNAL_UMA_HISTOGRAM_ENUMERATION_GET_MACRO(           \
+      __VA_ARGS__, INTERNAL_UMA_HISTOGRAM_ENUMERATION_SPECIFY_BOUNDARY, \
+      INTERNAL_UMA_HISTOGRAM_ENUMERATION_DEDUCE_BOUNDARY)(              \
+      name, __VA_ARGS__, base::HistogramBase::kNoFlags))
+
+#define LOCAL_HISTOGRAM_BOOLEAN(name, sample)                                  \
+    STATIC_HISTOGRAM_POINTER_BLOCK(name, AddBoolean(sample),                   \
+        base::BooleanHistogram::FactoryGet(name, base::Histogram::kNoFlags))
+
+//------------------------------------------------------------------------------
+// Percentage histograms.
+//
+// For usage details, see the equivalents in histogram_macros.h
+
+#define LOCAL_HISTOGRAM_PERCENTAGE(name, under_one_hundred)                    \
+    LOCAL_HISTOGRAM_ENUMERATION(name, under_one_hundred, 101)
+
+//------------------------------------------------------------------------------
+// Count histograms. These are used for collecting numeric data. Note that we
+// have macros for more specialized use cases below (memory, time, percentages).
+// For usage details, see the equivalents in histogram_macros.h.
+
+#define LOCAL_HISTOGRAM_COUNTS_100(name, sample)                               \
+    LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 100, 50)
+
+#define LOCAL_HISTOGRAM_COUNTS_10000(name, sample)                             \
+    LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 10000, 50)
+
+#define LOCAL_HISTOGRAM_COUNTS_1000000(name, sample)                           \
+    LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 1000000, 50)
+
+#define LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count)    \
+    INTERNAL_HISTOGRAM_CUSTOM_COUNTS_WITH_FLAG(                                \
+        name, sample, min, max, bucket_count, base::HistogramBase::kNoFlags)
+
+//------------------------------------------------------------------------------
+// Timing histograms. These are used for collecting timing data (generally
+// latencies).
+//
+// For usage details, see the equivalents in histogram_macros.h.
+
+#define LOCAL_HISTOGRAM_TIMES(name, sample) LOCAL_HISTOGRAM_CUSTOM_TIMES(      \
+    name, sample, base::TimeDelta::FromMilliseconds(1),                        \
+    base::TimeDelta::FromSeconds(10), 50)
+
+#define LOCAL_HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) \
+  STATIC_HISTOGRAM_POINTER_BLOCK(                                          \
+      name, AddTimeMillisecondsGranularity(sample),                        \
+      base::Histogram::FactoryTimeGet(name, min, max, bucket_count,        \
+                                      base::HistogramBase::kNoFlags))
+
+//------------------------------------------------------------------------------
+// Memory histograms.
+//
+// For usage details, see the equivalents in histogram_macros.h.
+
+#define LOCAL_HISTOGRAM_MEMORY_KB(name, sample) LOCAL_HISTOGRAM_CUSTOM_COUNTS( \
+    name, sample, 1000, 500000, 50)
+
+//------------------------------------------------------------------------------
+// Deprecated histograms. Not recommended for current use.
+
+// TODO(rkaplow): See if we can clean up this macro and usage.
+// Legacy non-explicit version. We suggest using LOCAL_HISTOGRAM_COUNTS_1000000
+// instead.
+#define LOCAL_HISTOGRAM_COUNTS(name, sample)                                   \
+    LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 1000000, 50)
+
+#endif  // BASE_METRICS_HISTOGRAM_MACROS_LOCAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram_samples.h b/native/zucchini/vendor/libchrome/base/metrics/histogram_samples.h
new file mode 100644
index 0000000..6908873
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/metrics/histogram_samples.h
@@ -0,0 +1,267 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_METRICS_HISTOGRAM_SAMPLES_H_
+#define BASE_METRICS_HISTOGRAM_SAMPLES_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <limits>
+#include <memory>
+
+#include "base/atomicops.h"
+#include "base/macros.h"
+#include "base/metrics/histogram_base.h"
+
+namespace base {
+
+class Pickle;
+class PickleIterator;
+class SampleCountIterator;
+
+// HistogramSamples is a container storing all samples of a histogram. All
+// elements must be of a fixed width to ensure 32/64-bit interoperability.
+// If this structure changes, bump the version number for kTypeIdHistogram
+// in persistent_histogram_allocator.cc.
+//
+// Note that though these samples are individually consistent (through the use
+// of atomic operations on the counts), there is only "eventual consistency"
+// overall when multiple threads are accessing this data. That means that the
+// sum, redundant-count, etc. could be momentarily out-of-sync with the stored
+// counts but will settle to a consistent "steady state" once all threads have
+// exited this code.
+class BASE_EXPORT HistogramSamples {
+ public:
+  // A single bucket and count. To fit within a single atomic on 32-bit build
+  // architectures, both |bucket| and |count| are limited in size to 16 bits.
+  // This limits the functionality somewhat but if an entry can't fit then
+  // the full array of samples can be allocated and used.
+  struct SingleSample {
+    uint16_t bucket;
+    uint16_t count;
+  };
+
+  // A structure for managing an atomic single sample. Because this is generally
+  // used in association with other atomic values, the defined methods use
+  // acquire/release operations to guarantee ordering with outside values.
+  union BASE_EXPORT AtomicSingleSample {
+    AtomicSingleSample() : as_atomic(0) {}
+    AtomicSingleSample(subtle::Atomic32 rhs) : as_atomic(rhs) {}
+
+    // Returns the single sample in an atomic manner. This in an "acquire"
+    // load. The returned sample isn't shared and thus its fields can be safely
+    // accessed.
+    SingleSample Load() const;
+
+    // Extracts the single sample in an atomic manner. If |disable| is true
+    // then this object will be set so it will never accumulate another value.
+    // This is "no barrier" so doesn't enforce ordering with other atomic ops.
+    SingleSample Extract(bool disable);
+
+    // Adds a given count to the held bucket. If not possible, it returns false
+    // and leaves the parts unchanged. Once extracted/disabled, this always
+    // returns false. This in an "acquire/release" operation.
+    bool Accumulate(size_t bucket, HistogramBase::Count count);
+
+    // Returns if the sample has been "disabled" (via Extract) and thus not
+    // allowed to accept further accumulation.
+    bool IsDisabled() const;
+
+   private:
+    // union field: The actual sample bucket and count.
+    SingleSample as_parts;
+
+    // union field: The sample as an atomic value. Atomic64 would provide
+    // more flexibility but isn't available on all builds. This can hold a
+    // special, internal "disabled" value indicating that it must not accept
+    // further accumulation.
+    subtle::Atomic32 as_atomic;
+  };
+
+  // A structure of information about the data, common to all sample containers.
+  // Because of how this is used in persistent memory, it must be a POD object
+  // that makes sense when initialized to all zeros.
+  struct Metadata {
+    // Expected size for 32/64-bit check.
+    static constexpr size_t kExpectedInstanceSize = 24;
+
+    // Initialized when the sample-set is first created with a value provided
+    // by the caller. It is generally used to identify the sample-set across
+    // threads and processes, though not necessarily uniquely as it is possible
+    // to have multiple sample-sets representing subsets of the data.
+    uint64_t id;
+
+    // The sum of all the entries, effectivly the sum(sample * count) for
+    // all samples. Despite being atomic, no guarantees are made on the
+    // accuracy of this value; there may be races during histogram
+    // accumulation and snapshotting that we choose to accept. It should
+    // be treated as approximate.
+#ifdef ARCH_CPU_64_BITS
+    subtle::Atomic64 sum;
+#else
+    // 32-bit systems don't have atomic 64-bit operations. Use a basic type
+    // and don't worry about "shearing".
+    int64_t sum;
+#endif
+
+    // A "redundant" count helps identify memory corruption. It redundantly
+    // stores the total number of samples accumulated in the histogram. We
+    // can compare this count to the sum of the counts (TotalCount() function),
+    // and detect problems. Note, depending on the implementation of different
+    // histogram types, there might be races during histogram accumulation
+    // and snapshotting that we choose to accept. In this case, the tallies
+    // might mismatch even when no memory corruption has happened.
+    HistogramBase::AtomicCount redundant_count;
+
+    // A single histogram value and associated count. This allows histograms
+    // that typically report only a single value to not require full storage
+    // to be allocated.
+    AtomicSingleSample single_sample;  // 32 bits
+  };
+
+  // Because structures held in persistent memory must be POD, there can be no
+  // default constructor to clear the fields. This derived class exists just
+  // to clear them when being allocated on the heap.
+  struct BASE_EXPORT LocalMetadata : Metadata {
+    LocalMetadata();
+  };
+
+  HistogramSamples(uint64_t id, Metadata* meta);
+  virtual ~HistogramSamples();
+
+  virtual void Accumulate(HistogramBase::Sample value,
+                          HistogramBase::Count count) = 0;
+  virtual HistogramBase::Count GetCount(HistogramBase::Sample value) const = 0;
+  virtual HistogramBase::Count TotalCount() const = 0;
+
+  virtual void Add(const HistogramSamples& other);
+
+  // Add from serialized samples.
+  virtual bool AddFromPickle(PickleIterator* iter);
+
+  virtual void Subtract(const HistogramSamples& other);
+
+  virtual std::unique_ptr<SampleCountIterator> Iterator() const = 0;
+  virtual void Serialize(Pickle* pickle) const;
+
+  // Accessor fuctions.
+  uint64_t id() const { return meta_->id; }
+  int64_t sum() const {
+#ifdef ARCH_CPU_64_BITS
+    return subtle::NoBarrier_Load(&meta_->sum);
+#else
+    return meta_->sum;
+#endif
+  }
+  HistogramBase::Count redundant_count() const {
+    return subtle::NoBarrier_Load(&meta_->redundant_count);
+  }
+
+ protected:
+  enum NegativeSampleReason {
+    SAMPLES_HAVE_LOGGED_BUT_NOT_SAMPLE,
+    SAMPLES_SAMPLE_LESS_THAN_LOGGED,
+    SAMPLES_ADDED_NEGATIVE_COUNT,
+    SAMPLES_ADD_WENT_NEGATIVE,
+    SAMPLES_ADD_OVERFLOW,
+    SAMPLES_ACCUMULATE_NEGATIVE_COUNT,
+    SAMPLES_ACCUMULATE_WENT_NEGATIVE,
+    DEPRECATED_SAMPLES_ACCUMULATE_OVERFLOW,
+    SAMPLES_ACCUMULATE_OVERFLOW,
+    MAX_NEGATIVE_SAMPLE_REASONS
+  };
+
+  // Based on |op| type, add or subtract sample counts data from the iterator.
+  enum Operator { ADD, SUBTRACT };
+  virtual bool AddSubtractImpl(SampleCountIterator* iter, Operator op) = 0;
+
+  // Accumulates to the embedded single-sample field if possible. Returns true
+  // on success, false otherwise. Sum and redundant-count are also updated in
+  // the success case.
+  bool AccumulateSingleSample(HistogramBase::Sample value,
+                              HistogramBase::Count count,
+                              size_t bucket);
+
+  // Atomically adjust the sum and redundant-count.
+  void IncreaseSumAndCount(int64_t sum, HistogramBase::Count count);
+
+  // Record a negative-sample observation and the reason why.
+  void RecordNegativeSample(NegativeSampleReason reason,
+                            HistogramBase::Count increment);
+
+  AtomicSingleSample& single_sample() { return meta_->single_sample; }
+  const AtomicSingleSample& single_sample() const {
+    return meta_->single_sample;
+  }
+
+  Metadata* meta() { return meta_; }
+
+ private:
+  // Depending on derived class meta values can come from local stoarge or
+  // external storage in which case HistogramSamples class cannot take ownership
+  // of Metadata*.
+  Metadata* meta_;
+
+  DISALLOW_COPY_AND_ASSIGN(HistogramSamples);
+};
+
+class BASE_EXPORT SampleCountIterator {
+ public:
+  virtual ~SampleCountIterator();
+
+  virtual bool Done() const = 0;
+  virtual void Next() = 0;
+
+  // Get the sample and count at current position.
+  // |min| |max| and |count| can be NULL if the value is not of interest.
+  // Note: |max| is int64_t because histograms support logged values in the
+  // full int32_t range and bucket max is exclusive, so it needs to support
+  // values up to MAXINT32+1.
+  // Requires: !Done();
+  virtual void Get(HistogramBase::Sample* min,
+                   int64_t* max,
+                   HistogramBase::Count* count) const = 0;
+  static_assert(std::numeric_limits<HistogramBase::Sample>::max() <
+                    std::numeric_limits<int64_t>::max(),
+                "Get() |max| must be able to hold Histogram::Sample max + 1");
+
+  // Get the index of current histogram bucket.
+  // For histograms that don't use predefined buckets, it returns false.
+  // Requires: !Done();
+  virtual bool GetBucketIndex(size_t* index) const;
+};
+
+class BASE_EXPORT SingleSampleIterator : public SampleCountIterator {
+ public:
+  SingleSampleIterator(HistogramBase::Sample min,
+                       int64_t max,
+                       HistogramBase::Count count);
+  SingleSampleIterator(HistogramBase::Sample min,
+                       int64_t max,
+                       HistogramBase::Count count,
+                       size_t bucket_index);
+  ~SingleSampleIterator() override;
+
+  // SampleCountIterator:
+  bool Done() const override;
+  void Next() override;
+  void Get(HistogramBase::Sample* min,
+           int64_t* max,
+           HistogramBase::Count* count) const override;
+
+  // SampleVector uses predefined buckets so iterator can return bucket index.
+  bool GetBucketIndex(size_t* index) const override;
+
+ private:
+  // Information about the single value to return.
+  const HistogramBase::Sample min_;
+  const int64_t max_;
+  const size_t bucket_index_;
+  HistogramBase::Count count_;
+};
+
+}  // namespace base
+
+#endif  // BASE_METRICS_HISTOGRAM_SAMPLES_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.cc b/native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.cc
new file mode 100644
index 0000000..9b18a00
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.cc
@@ -0,0 +1,1204 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/metrics/persistent_memory_allocator.h"
+
+#include <assert.h>
+#include <algorithm>
+
+#if defined(OS_WIN)
+#include <windows.h>
+#include "winbase.h"
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+#include <sys/mman.h>
+#endif
+
+#include "base/files/memory_mapped_file.h"
+#include "base/logging.h"
+#include "base/memory/shared_memory.h"
+#include "base/metrics/histogram_functions.h"
+#include "base/metrics/sparse_histogram.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/sys_info.h"
+#include "base/threading/thread_restrictions.h"
+#include "build/build_config.h"
+
+namespace {
+
+// Limit of memory segment size. It has to fit in an unsigned 32-bit number
+// and should be a power of 2 in order to accomodate almost any page size.
+const uint32_t kSegmentMaxSize = 1 << 30;  // 1 GiB
+
+// A constant (random) value placed in the shared metadata to identify
+// an already initialized memory segment.
+const uint32_t kGlobalCookie = 0x408305DC;
+
+// The current version of the metadata. If updates are made that change
+// the metadata, the version number can be queried to operate in a backward-
+// compatible manner until the memory segment is completely re-initalized.
+const uint32_t kGlobalVersion = 2;
+
+// Constant values placed in the block headers to indicate its state.
+const uint32_t kBlockCookieFree = 0;
+const uint32_t kBlockCookieQueue = 1;
+const uint32_t kBlockCookieWasted = (uint32_t)-1;
+const uint32_t kBlockCookieAllocated = 0xC8799269;
+
+// TODO(bcwhite): When acceptable, consider moving flags to std::atomic<char>
+// types rather than combined bitfield.
+
+// Flags stored in the flags_ field of the SharedMetadata structure below.
+enum : int {
+  kFlagCorrupt = 1 << 0,
+  kFlagFull    = 1 << 1
+};
+
+// Errors that are logged in "errors" histogram.
+enum AllocatorError : int {
+  kMemoryIsCorrupt = 1,
+};
+
+bool CheckFlag(const volatile std::atomic<uint32_t>* flags, int flag) {
+  uint32_t loaded_flags = flags->load(std::memory_order_relaxed);
+  return (loaded_flags & flag) != 0;
+}
+
+void SetFlag(volatile std::atomic<uint32_t>* flags, int flag) {
+  uint32_t loaded_flags = flags->load(std::memory_order_relaxed);
+  for (;;) {
+    uint32_t new_flags = (loaded_flags & ~flag) | flag;
+    // In the failue case, actual "flags" value stored in loaded_flags.
+    // These access are "relaxed" because they are completely independent
+    // of all other values.
+    if (flags->compare_exchange_weak(loaded_flags, new_flags,
+                                     std::memory_order_relaxed,
+                                     std::memory_order_relaxed)) {
+      break;
+    }
+  }
+}
+
+}  // namespace
+
+namespace base {
+
+// All allocations and data-structures must be aligned to this byte boundary.
+// Alignment as large as the physical bus between CPU and RAM is _required_
+// for some architectures, is simply more efficient on other CPUs, and
+// generally a Good Idea(tm) for all platforms as it reduces/eliminates the
+// chance that a type will span cache lines. Alignment mustn't be less
+// than 8 to ensure proper alignment for all types. The rest is a balance
+// between reducing spans across multiple cache lines and wasted space spent
+// padding out allocations. An alignment of 16 would ensure that the block
+// header structure always sits in a single cache line. An average of about
+// 1/2 this value will be wasted with every allocation.
+const uint32_t PersistentMemoryAllocator::kAllocAlignment = 8;
+
+// The block-header is placed at the top of every allocation within the
+// segment to describe the data that follows it.
+struct PersistentMemoryAllocator::BlockHeader {
+  uint32_t size;       // Number of bytes in this block, including header.
+  uint32_t cookie;     // Constant value indicating completed allocation.
+  std::atomic<uint32_t> type_id;  // Arbitrary number indicating data type.
+  std::atomic<uint32_t> next;     // Pointer to the next block when iterating.
+};
+
+// The shared metadata exists once at the top of the memory segment to
+// describe the state of the allocator to all processes. The size of this
+// structure must be a multiple of 64-bits to ensure compatibility between
+// architectures.
+struct PersistentMemoryAllocator::SharedMetadata {
+  uint32_t cookie;     // Some value that indicates complete initialization.
+  uint32_t size;       // Total size of memory segment.
+  uint32_t page_size;  // Paging size within memory segment.
+  uint32_t version;    // Version code so upgrades don't break.
+  uint64_t id;         // Arbitrary ID number given by creator.
+  uint32_t name;       // Reference to stored name string.
+  uint32_t padding1;   // Pad-out read-only data to 64-bit alignment.
+
+  // Above is read-only after first construction. Below may be changed and
+  // so must be marked "volatile" to provide correct inter-process behavior.
+
+  // State of the memory, plus some padding to keep alignment.
+  volatile std::atomic<uint8_t> memory_state;  // MemoryState enum values.
+  uint8_t padding2[3];
+
+  // Bitfield of information flags. Access to this should be done through
+  // the CheckFlag() and SetFlag() methods defined above.
+  volatile std::atomic<uint32_t> flags;
+
+  // Offset/reference to first free space in segment.
+  volatile std::atomic<uint32_t> freeptr;
+
+  // The "iterable" queue is an M&S Queue as described here, append-only:
+  // https://www.research.ibm.com/people/m/michael/podc-1996.pdf
+  // |queue| needs to be 64-bit aligned and is itself a multiple of 64 bits.
+  volatile std::atomic<uint32_t> tailptr;  // Last block of iteration queue.
+  volatile BlockHeader queue;   // Empty block for linked-list head/tail.
+};
+
+// The "queue" block header is used to detect "last node" so that zero/null
+// can be used to indicate that it hasn't been added at all. It is part of
+// the SharedMetadata structure which itself is always located at offset zero.
+const PersistentMemoryAllocator::Reference
+    PersistentMemoryAllocator::kReferenceQueue =
+        offsetof(SharedMetadata, queue);
+
+const base::FilePath::CharType PersistentMemoryAllocator::kFileExtension[] =
+    FILE_PATH_LITERAL(".pma");
+
+
+PersistentMemoryAllocator::Iterator::Iterator(
+    const PersistentMemoryAllocator* allocator)
+    : allocator_(allocator), last_record_(kReferenceQueue), record_count_(0) {}
+
+PersistentMemoryAllocator::Iterator::Iterator(
+    const PersistentMemoryAllocator* allocator,
+    Reference starting_after)
+    : allocator_(allocator), last_record_(0), record_count_(0) {
+  Reset(starting_after);
+}
+
+void PersistentMemoryAllocator::Iterator::Reset() {
+  last_record_.store(kReferenceQueue, std::memory_order_relaxed);
+  record_count_.store(0, std::memory_order_relaxed);
+}
+
+void PersistentMemoryAllocator::Iterator::Reset(Reference starting_after) {
+  if (starting_after == 0) {
+    Reset();
+    return;
+  }
+
+  last_record_.store(starting_after, std::memory_order_relaxed);
+  record_count_.store(0, std::memory_order_relaxed);
+
+  // Ensure that the starting point is a valid, iterable block (meaning it can
+  // be read and has a non-zero "next" pointer).
+  const volatile BlockHeader* block =
+      allocator_->GetBlock(starting_after, 0, 0, false, false);
+  if (!block || block->next.load(std::memory_order_relaxed) == 0) {
+    NOTREACHED();
+    last_record_.store(kReferenceQueue, std::memory_order_release);
+  }
+}
+
+PersistentMemoryAllocator::Reference
+PersistentMemoryAllocator::Iterator::GetLast() {
+  Reference last = last_record_.load(std::memory_order_relaxed);
+  if (last == kReferenceQueue)
+    return kReferenceNull;
+  return last;
+}
+
+PersistentMemoryAllocator::Reference
+PersistentMemoryAllocator::Iterator::GetNext(uint32_t* type_return) {
+  // Make a copy of the existing count of found-records, acquiring all changes
+  // made to the allocator, notably "freeptr" (see comment in loop for why
+  // the load of that value cannot be moved above here) that occurred during
+  // any previous runs of this method, including those by parallel threads
+  // that interrupted it. It pairs with the Release at the end of this method.
+  //
+  // Otherwise, if the compiler were to arrange the two loads such that
+  // "count" was fetched _after_ "freeptr" then it would be possible for
+  // this thread to be interrupted between them and other threads perform
+  // multiple allocations, make-iterables, and iterations (with the included
+  // increment of |record_count_|) culminating in the check at the bottom
+  // mistakenly determining that a loop exists. Isn't this stuff fun?
+  uint32_t count = record_count_.load(std::memory_order_acquire);
+
+  Reference last = last_record_.load(std::memory_order_acquire);
+  Reference next;
+  while (true) {
+    const volatile BlockHeader* block =
+        allocator_->GetBlock(last, 0, 0, true, false);
+    if (!block)  // Invalid iterator state.
+      return kReferenceNull;
+
+    // The compiler and CPU can freely reorder all memory accesses on which
+    // there are no dependencies. It could, for example, move the load of
+    // "freeptr" to above this point because there are no explicit dependencies
+    // between it and "next". If it did, however, then another block could
+    // be queued after that but before the following load meaning there is
+    // one more queued block than the future "detect loop by having more
+    // blocks that could fit before freeptr" will allow.
+    //
+    // By "acquiring" the "next" value here, it's synchronized to the enqueue
+    // of the node which in turn is synchronized to the allocation (which sets
+    // freeptr). Thus, the scenario above cannot happen.
+    next = block->next.load(std::memory_order_acquire);
+    if (next == kReferenceQueue)  // No next allocation in queue.
+      return kReferenceNull;
+    block = allocator_->GetBlock(next, 0, 0, false, false);
+    if (!block) {  // Memory is corrupt.
+      allocator_->SetCorrupt();
+      return kReferenceNull;
+    }
+
+    // Update the "last_record" pointer to be the reference being returned.
+    // If it fails then another thread has already iterated past it so loop
+    // again. Failing will also load the existing value into "last" so there
+    // is no need to do another such load when the while-loop restarts. A
+    // "strong" compare-exchange is used because failing unnecessarily would
+    // mean repeating some fairly costly validations above.
+    if (last_record_.compare_exchange_strong(
+            last, next, std::memory_order_acq_rel, std::memory_order_acquire)) {
+      *type_return = block->type_id.load(std::memory_order_relaxed);
+      break;
+    }
+  }
+
+  // Memory corruption could cause a loop in the list. Such must be detected
+  // so as to not cause an infinite loop in the caller. This is done by simply
+  // making sure it doesn't iterate more times than the absolute maximum
+  // number of allocations that could have been made. Callers are likely
+  // to loop multiple times before it is detected but at least it stops.
+  const uint32_t freeptr = std::min(
+      allocator_->shared_meta()->freeptr.load(std::memory_order_relaxed),
+      allocator_->mem_size_);
+  const uint32_t max_records =
+      freeptr / (sizeof(BlockHeader) + kAllocAlignment);
+  if (count > max_records) {
+    allocator_->SetCorrupt();
+    return kReferenceNull;
+  }
+
+  // Increment the count and release the changes made above. It pairs with
+  // the Acquire at the top of this method. Note that this operation is not
+  // strictly synchonized with fetching of the object to return, which would
+  // have to be done inside the loop and is somewhat complicated to achieve.
+  // It does not matter if it falls behind temporarily so long as it never
+  // gets ahead.
+  record_count_.fetch_add(1, std::memory_order_release);
+  return next;
+}
+
+PersistentMemoryAllocator::Reference
+PersistentMemoryAllocator::Iterator::GetNextOfType(uint32_t type_match) {
+  Reference ref;
+  uint32_t type_found;
+  while ((ref = GetNext(&type_found)) != 0) {
+    if (type_found == type_match)
+      return ref;
+  }
+  return kReferenceNull;
+}
+
+
+// static
+bool PersistentMemoryAllocator::IsMemoryAcceptable(const void* base,
+                                                   size_t size,
+                                                   size_t page_size,
+                                                   bool readonly) {
+  return ((base && reinterpret_cast<uintptr_t>(base) % kAllocAlignment == 0) &&
+          (size >= sizeof(SharedMetadata) && size <= kSegmentMaxSize) &&
+          (size % kAllocAlignment == 0 || readonly) &&
+          (page_size == 0 || size % page_size == 0 || readonly));
+}
+
+PersistentMemoryAllocator::PersistentMemoryAllocator(void* base,
+                                                     size_t size,
+                                                     size_t page_size,
+                                                     uint64_t id,
+                                                     base::StringPiece name,
+                                                     bool readonly)
+    : PersistentMemoryAllocator(Memory(base, MEM_EXTERNAL),
+                                size,
+                                page_size,
+                                id,
+                                name,
+                                readonly) {}
+
+PersistentMemoryAllocator::PersistentMemoryAllocator(Memory memory,
+                                                     size_t size,
+                                                     size_t page_size,
+                                                     uint64_t id,
+                                                     base::StringPiece name,
+                                                     bool readonly)
+    : mem_base_(static_cast<char*>(memory.base)),
+      mem_type_(memory.type),
+      mem_size_(static_cast<uint32_t>(size)),
+      mem_page_(static_cast<uint32_t>((page_size ? page_size : size))),
+#if defined(OS_NACL)
+      vm_page_size_(4096U),  // SysInfo is not built for NACL.
+#else
+      vm_page_size_(SysInfo::VMAllocationGranularity()),
+#endif
+      readonly_(readonly),
+      corrupt_(0),
+      allocs_histogram_(nullptr),
+      used_histogram_(nullptr),
+      errors_histogram_(nullptr) {
+  // These asserts ensure that the structures are 32/64-bit agnostic and meet
+  // all the requirements of use within the allocator. They access private
+  // definitions and so cannot be moved to the global scope.
+  static_assert(sizeof(PersistentMemoryAllocator::BlockHeader) == 16,
+                "struct is not portable across different natural word widths");
+  static_assert(sizeof(PersistentMemoryAllocator::SharedMetadata) == 64,
+                "struct is not portable across different natural word widths");
+
+  static_assert(sizeof(BlockHeader) % kAllocAlignment == 0,
+                "BlockHeader is not a multiple of kAllocAlignment");
+  static_assert(sizeof(SharedMetadata) % kAllocAlignment == 0,
+                "SharedMetadata is not a multiple of kAllocAlignment");
+  static_assert(kReferenceQueue % kAllocAlignment == 0,
+                "\"queue\" is not aligned properly; must be at end of struct");
+
+  // Ensure that memory segment is of acceptable size.
+  CHECK(IsMemoryAcceptable(memory.base, size, page_size, readonly));
+
+  // These atomics operate inter-process and so must be lock-free. The local
+  // casts are to make sure it can be evaluated at compile time to a constant.
+  CHECK(((SharedMetadata*)nullptr)->freeptr.is_lock_free());
+  CHECK(((SharedMetadata*)nullptr)->flags.is_lock_free());
+  CHECK(((BlockHeader*)nullptr)->next.is_lock_free());
+  CHECK(corrupt_.is_lock_free());
+
+  if (shared_meta()->cookie != kGlobalCookie) {
+    if (readonly) {
+      SetCorrupt();
+      return;
+    }
+
+    // This block is only executed when a completely new memory segment is
+    // being initialized. It's unshared and single-threaded...
+    volatile BlockHeader* const first_block =
+        reinterpret_cast<volatile BlockHeader*>(mem_base_ +
+                                                sizeof(SharedMetadata));
+    if (shared_meta()->cookie != 0 ||
+        shared_meta()->size != 0 ||
+        shared_meta()->version != 0 ||
+        shared_meta()->freeptr.load(std::memory_order_relaxed) != 0 ||
+        shared_meta()->flags.load(std::memory_order_relaxed) != 0 ||
+        shared_meta()->id != 0 ||
+        shared_meta()->name != 0 ||
+        shared_meta()->tailptr != 0 ||
+        shared_meta()->queue.cookie != 0 ||
+        shared_meta()->queue.next.load(std::memory_order_relaxed) != 0 ||
+        first_block->size != 0 ||
+        first_block->cookie != 0 ||
+        first_block->type_id.load(std::memory_order_relaxed) != 0 ||
+        first_block->next != 0) {
+      // ...or something malicious has been playing with the metadata.
+      SetCorrupt();
+    }
+
+    // This is still safe to do even if corruption has been detected.
+    shared_meta()->cookie = kGlobalCookie;
+    shared_meta()->size = mem_size_;
+    shared_meta()->page_size = mem_page_;
+    shared_meta()->version = kGlobalVersion;
+    shared_meta()->id = id;
+    shared_meta()->freeptr.store(sizeof(SharedMetadata),
+                                 std::memory_order_release);
+
+    // Set up the queue of iterable allocations.
+    shared_meta()->queue.size = sizeof(BlockHeader);
+    shared_meta()->queue.cookie = kBlockCookieQueue;
+    shared_meta()->queue.next.store(kReferenceQueue, std::memory_order_release);
+    shared_meta()->tailptr.store(kReferenceQueue, std::memory_order_release);
+
+    // Allocate space for the name so other processes can learn it.
+    if (!name.empty()) {
+      const size_t name_length = name.length() + 1;
+      shared_meta()->name = Allocate(name_length, 0);
+      char* name_cstr = GetAsArray<char>(shared_meta()->name, 0, name_length);
+      if (name_cstr)
+        memcpy(name_cstr, name.data(), name.length());
+    }
+
+    shared_meta()->memory_state.store(MEMORY_INITIALIZED,
+                                      std::memory_order_release);
+  } else {
+    if (shared_meta()->size == 0 || shared_meta()->version != kGlobalVersion ||
+        shared_meta()->freeptr.load(std::memory_order_relaxed) == 0 ||
+        shared_meta()->tailptr == 0 || shared_meta()->queue.cookie == 0 ||
+        shared_meta()->queue.next.load(std::memory_order_relaxed) == 0) {
+      SetCorrupt();
+    }
+    if (!readonly) {
+      // The allocator is attaching to a previously initialized segment of
+      // memory. If the initialization parameters differ, make the best of it
+      // by reducing the local construction parameters to match those of
+      // the actual memory area. This ensures that the local object never
+      // tries to write outside of the original bounds.
+      // Because the fields are const to ensure that no code other than the
+      // constructor makes changes to them as well as to give optimization
+      // hints to the compiler, it's necessary to const-cast them for changes
+      // here.
+      if (shared_meta()->size < mem_size_)
+        *const_cast<uint32_t*>(&mem_size_) = shared_meta()->size;
+      if (shared_meta()->page_size < mem_page_)
+        *const_cast<uint32_t*>(&mem_page_) = shared_meta()->page_size;
+
+      // Ensure that settings are still valid after the above adjustments.
+      if (!IsMemoryAcceptable(memory.base, mem_size_, mem_page_, readonly))
+        SetCorrupt();
+    }
+  }
+}
+
+PersistentMemoryAllocator::~PersistentMemoryAllocator() {
+  // It's strictly forbidden to do any memory access here in case there is
+  // some issue with the underlying memory segment. The "Local" allocator
+  // makes use of this to allow deletion of the segment on the heap from
+  // within its destructor.
+}
+
+uint64_t PersistentMemoryAllocator::Id() const {
+  return shared_meta()->id;
+}
+
+const char* PersistentMemoryAllocator::Name() const {
+  Reference name_ref = shared_meta()->name;
+  const char* name_cstr =
+      GetAsArray<char>(name_ref, 0, PersistentMemoryAllocator::kSizeAny);
+  if (!name_cstr)
+    return "";
+
+  size_t name_length = GetAllocSize(name_ref);
+  if (name_cstr[name_length - 1] != '\0') {
+    NOTREACHED();
+    SetCorrupt();
+    return "";
+  }
+
+  return name_cstr;
+}
+
+void PersistentMemoryAllocator::CreateTrackingHistograms(
+    base::StringPiece name) {
+  if (name.empty() || readonly_)
+    return;
+  std::string name_string = name.as_string();
+
+#if 0
+  // This histogram wasn't being used so has been disabled. It is left here
+  // in case development of a new use of the allocator could benefit from
+  // recording (temporarily and locally) the allocation sizes.
+  DCHECK(!allocs_histogram_);
+  allocs_histogram_ = Histogram::FactoryGet(
+      "UMA.PersistentAllocator." + name_string + ".Allocs", 1, 10000, 50,
+      HistogramBase::kUmaTargetedHistogramFlag);
+#endif
+
+  DCHECK(!used_histogram_);
+  used_histogram_ = LinearHistogram::FactoryGet(
+      "UMA.PersistentAllocator." + name_string + ".UsedPct", 1, 101, 21,
+      HistogramBase::kUmaTargetedHistogramFlag);
+
+  DCHECK(!errors_histogram_);
+  errors_histogram_ = SparseHistogram::FactoryGet(
+      "UMA.PersistentAllocator." + name_string + ".Errors",
+      HistogramBase::kUmaTargetedHistogramFlag);
+}
+
+void PersistentMemoryAllocator::Flush(bool sync) {
+  FlushPartial(used(), sync);
+}
+
+void PersistentMemoryAllocator::SetMemoryState(uint8_t memory_state) {
+  shared_meta()->memory_state.store(memory_state, std::memory_order_relaxed);
+  FlushPartial(sizeof(SharedMetadata), false);
+}
+
+uint8_t PersistentMemoryAllocator::GetMemoryState() const {
+  return shared_meta()->memory_state.load(std::memory_order_relaxed);
+}
+
+size_t PersistentMemoryAllocator::used() const {
+  return std::min(shared_meta()->freeptr.load(std::memory_order_relaxed),
+                  mem_size_);
+}
+
+PersistentMemoryAllocator::Reference PersistentMemoryAllocator::GetAsReference(
+    const void* memory,
+    uint32_t type_id) const {
+  uintptr_t address = reinterpret_cast<uintptr_t>(memory);
+  if (address < reinterpret_cast<uintptr_t>(mem_base_))
+    return kReferenceNull;
+
+  uintptr_t offset = address - reinterpret_cast<uintptr_t>(mem_base_);
+  if (offset >= mem_size_ || offset < sizeof(BlockHeader))
+    return kReferenceNull;
+
+  Reference ref = static_cast<Reference>(offset) - sizeof(BlockHeader);
+  if (!GetBlockData(ref, type_id, kSizeAny))
+    return kReferenceNull;
+
+  return ref;
+}
+
+size_t PersistentMemoryAllocator::GetAllocSize(Reference ref) const {
+  const volatile BlockHeader* const block = GetBlock(ref, 0, 0, false, false);
+  if (!block)
+    return 0;
+  uint32_t size = block->size;
+  // Header was verified by GetBlock() but a malicious actor could change
+  // the value between there and here. Check it again.
+  if (size <= sizeof(BlockHeader) || ref + size > mem_size_) {
+    SetCorrupt();
+    return 0;
+  }
+  return size - sizeof(BlockHeader);
+}
+
+uint32_t PersistentMemoryAllocator::GetType(Reference ref) const {
+  const volatile BlockHeader* const block = GetBlock(ref, 0, 0, false, false);
+  if (!block)
+    return 0;
+  return block->type_id.load(std::memory_order_relaxed);
+}
+
+bool PersistentMemoryAllocator::ChangeType(Reference ref,
+                                           uint32_t to_type_id,
+                                           uint32_t from_type_id,
+                                           bool clear) {
+  DCHECK(!readonly_);
+  volatile BlockHeader* const block = GetBlock(ref, 0, 0, false, false);
+  if (!block)
+    return false;
+
+  // "Strong" exchanges are used below because there is no loop that can retry
+  // in the wake of spurious failures possible with "weak" exchanges. It is,
+  // in aggregate, an "acquire-release" operation so no memory accesses can be
+  // reordered either before or after this method (since changes based on type
+  // could happen on either side).
+
+  if (clear) {
+    // If clearing the memory, first change it to the "transitioning" type so
+    // there can be no confusion by other threads. After the memory is cleared,
+    // it can be changed to its final type.
+    if (!block->type_id.compare_exchange_strong(
+            from_type_id, kTypeIdTransitioning, std::memory_order_acquire,
+            std::memory_order_acquire)) {
+      // Existing type wasn't what was expected: fail (with no changes)
+      return false;
+    }
+
+    // Clear the memory in an atomic manner. Using "release" stores force
+    // every write to be done after the ones before it. This is better than
+    // using memset because (a) it supports "volatile" and (b) it creates a
+    // reliable pattern upon which other threads may rely.
+    volatile std::atomic<int>* data =
+        reinterpret_cast<volatile std::atomic<int>*>(
+            reinterpret_cast<volatile char*>(block) + sizeof(BlockHeader));
+    const uint32_t words = (block->size - sizeof(BlockHeader)) / sizeof(int);
+    DCHECK_EQ(0U, (block->size - sizeof(BlockHeader)) % sizeof(int));
+    for (uint32_t i = 0; i < words; ++i) {
+      data->store(0, std::memory_order_release);
+      ++data;
+    }
+
+    // If the destination type is "transitioning" then skip the final exchange.
+    if (to_type_id == kTypeIdTransitioning)
+      return true;
+
+    // Finish the change to the desired type.
+    from_type_id = kTypeIdTransitioning;  // Exchange needs modifiable original.
+    bool success = block->type_id.compare_exchange_strong(
+        from_type_id, to_type_id, std::memory_order_release,
+        std::memory_order_relaxed);
+    DCHECK(success);  // Should never fail.
+    return success;
+  }
+
+  // One step change to the new type. Will return false if the existing value
+  // doesn't match what is expected.
+  return block->type_id.compare_exchange_strong(from_type_id, to_type_id,
+                                                std::memory_order_acq_rel,
+                                                std::memory_order_acquire);
+}
+
+PersistentMemoryAllocator::Reference PersistentMemoryAllocator::Allocate(
+    size_t req_size,
+    uint32_t type_id) {
+  Reference ref = AllocateImpl(req_size, type_id);
+  if (ref) {
+    // Success: Record this allocation in usage stats (if active).
+    if (allocs_histogram_)
+      allocs_histogram_->Add(static_cast<HistogramBase::Sample>(req_size));
+  } else {
+    // Failure: Record an allocation of zero for tracking.
+    if (allocs_histogram_)
+      allocs_histogram_->Add(0);
+  }
+  return ref;
+}
+
+PersistentMemoryAllocator::Reference PersistentMemoryAllocator::AllocateImpl(
+    size_t req_size,
+    uint32_t type_id) {
+  DCHECK(!readonly_);
+
+  // Validate req_size to ensure it won't overflow when used as 32-bit value.
+  if (req_size > kSegmentMaxSize - sizeof(BlockHeader)) {
+    NOTREACHED();
+    return kReferenceNull;
+  }
+
+  // Round up the requested size, plus header, to the next allocation alignment.
+  uint32_t size = static_cast<uint32_t>(req_size + sizeof(BlockHeader));
+  size = (size + (kAllocAlignment - 1)) & ~(kAllocAlignment - 1);
+  if (size <= sizeof(BlockHeader) || size > mem_page_) {
+    NOTREACHED();
+    return kReferenceNull;
+  }
+
+  // Get the current start of unallocated memory. Other threads may
+  // update this at any time and cause us to retry these operations.
+  // This value should be treated as "const" to avoid confusion through
+  // the code below but recognize that any failed compare-exchange operation
+  // involving it will cause it to be loaded with a more recent value. The
+  // code should either exit or restart the loop in that case.
+  /* const */ uint32_t freeptr =
+      shared_meta()->freeptr.load(std::memory_order_acquire);
+
+  // Allocation is lockless so we do all our caculation and then, if saving
+  // indicates a change has occurred since we started, scrap everything and
+  // start over.
+  for (;;) {
+    if (IsCorrupt())
+      return kReferenceNull;
+
+    if (freeptr + size > mem_size_) {
+      SetFlag(&shared_meta()->flags, kFlagFull);
+      return kReferenceNull;
+    }
+
+    // Get pointer to the "free" block. If something has been allocated since
+    // the load of freeptr above, it is still safe as nothing will be written
+    // to that location until after the compare-exchange below.
+    volatile BlockHeader* const block = GetBlock(freeptr, 0, 0, false, true);
+    if (!block) {
+      SetCorrupt();
+      return kReferenceNull;
+    }
+
+    // An allocation cannot cross page boundaries. If it would, create a
+    // "wasted" block and begin again at the top of the next page. This
+    // area could just be left empty but we fill in the block header just
+    // for completeness sake.
+    const uint32_t page_free = mem_page_ - freeptr % mem_page_;
+    if (size > page_free) {
+      if (page_free <= sizeof(BlockHeader)) {
+        SetCorrupt();
+        return kReferenceNull;
+      }
+      const uint32_t new_freeptr = freeptr + page_free;
+      if (shared_meta()->freeptr.compare_exchange_strong(
+              freeptr, new_freeptr, std::memory_order_acq_rel,
+              std::memory_order_acquire)) {
+        block->size = page_free;
+        block->cookie = kBlockCookieWasted;
+      }
+      continue;
+    }
+
+    // Don't leave a slice at the end of a page too small for anything. This
+    // can result in an allocation up to two alignment-sizes greater than the
+    // minimum required by requested-size + header + alignment.
+    if (page_free - size < sizeof(BlockHeader) + kAllocAlignment)
+      size = page_free;
+
+    const uint32_t new_freeptr = freeptr + size;
+    if (new_freeptr > mem_size_) {
+      SetCorrupt();
+      return kReferenceNull;
+    }
+
+    // Save our work. Try again if another thread has completed an allocation
+    // while we were processing. A "weak" exchange would be permissable here
+    // because the code will just loop and try again but the above processing
+    // is significant so make the extra effort of a "strong" exchange.
+    if (!shared_meta()->freeptr.compare_exchange_strong(
+            freeptr, new_freeptr, std::memory_order_acq_rel,
+            std::memory_order_acquire)) {
+      continue;
+    }
+
+    // Given that all memory was zeroed before ever being given to an instance
+    // of this class and given that we only allocate in a monotomic fashion
+    // going forward, it must be that the newly allocated block is completely
+    // full of zeros. If we find anything in the block header that is NOT a
+    // zero then something must have previously run amuck through memory,
+    // writing beyond the allocated space and into unallocated space.
+    if (block->size != 0 ||
+        block->cookie != kBlockCookieFree ||
+        block->type_id.load(std::memory_order_relaxed) != 0 ||
+        block->next.load(std::memory_order_relaxed) != 0) {
+      SetCorrupt();
+      return kReferenceNull;
+    }
+
+    // Make sure the memory exists by writing to the first byte of every memory
+    // page it touches beyond the one containing the block header itself.
+    // As the underlying storage is often memory mapped from disk or shared
+    // space, sometimes things go wrong and those address don't actually exist
+    // leading to a SIGBUS (or Windows equivalent) at some arbitrary location
+    // in the code. This should concentrate all those failures into this
+    // location for easy tracking and, eventually, proper handling.
+    volatile char* mem_end = reinterpret_cast<volatile char*>(block) + size;
+    volatile char* mem_begin = reinterpret_cast<volatile char*>(
+        (reinterpret_cast<uintptr_t>(block) + sizeof(BlockHeader) +
+         (vm_page_size_ - 1)) &
+        ~static_cast<uintptr_t>(vm_page_size_ - 1));
+    for (volatile char* memory = mem_begin; memory < mem_end;
+         memory += vm_page_size_) {
+      // It's required that a memory segment start as all zeros and thus the
+      // newly allocated block is all zeros at this point. Thus, writing a
+      // zero to it allows testing that the memory exists without actually
+      // changing its contents. The compiler doesn't know about the requirement
+      // and so cannot optimize-away these writes.
+      *memory = 0;
+    }
+
+    // Load information into the block header. There is no "release" of the
+    // data here because this memory can, currently, be seen only by the thread
+    // performing the allocation. When it comes time to share this, the thread
+    // will call MakeIterable() which does the release operation.
+    block->size = size;
+    block->cookie = kBlockCookieAllocated;
+    block->type_id.store(type_id, std::memory_order_relaxed);
+    return freeptr;
+  }
+}
+
+void PersistentMemoryAllocator::GetMemoryInfo(MemoryInfo* meminfo) const {
+  uint32_t remaining = std::max(
+      mem_size_ - shared_meta()->freeptr.load(std::memory_order_relaxed),
+      (uint32_t)sizeof(BlockHeader));
+  meminfo->total = mem_size_;
+  meminfo->free = remaining - sizeof(BlockHeader);
+}
+
+void PersistentMemoryAllocator::MakeIterable(Reference ref) {
+  DCHECK(!readonly_);
+  if (IsCorrupt())
+    return;
+  volatile BlockHeader* block = GetBlock(ref, 0, 0, false, false);
+  if (!block)  // invalid reference
+    return;
+  if (block->next.load(std::memory_order_acquire) != 0)  // Already iterable.
+    return;
+  block->next.store(kReferenceQueue, std::memory_order_release);  // New tail.
+
+  // Try to add this block to the tail of the queue. May take multiple tries.
+  // If so, tail will be automatically updated with a more recent value during
+  // compare-exchange operations.
+  uint32_t tail = shared_meta()->tailptr.load(std::memory_order_acquire);
+  for (;;) {
+    // Acquire the current tail-pointer released by previous call to this
+    // method and validate it.
+    block = GetBlock(tail, 0, 0, true, false);
+    if (!block) {
+      SetCorrupt();
+      return;
+    }
+
+    // Try to insert the block at the tail of the queue. The tail node always
+    // has an existing value of kReferenceQueue; if that is somehow not the
+    // existing value then another thread has acted in the meantime. A "strong"
+    // exchange is necessary so the "else" block does not get executed when
+    // that is not actually the case (which can happen with a "weak" exchange).
+    uint32_t next = kReferenceQueue;  // Will get replaced with existing value.
+    if (block->next.compare_exchange_strong(next, ref,
+                                            std::memory_order_acq_rel,
+                                            std::memory_order_acquire)) {
+      // Update the tail pointer to the new offset. If the "else" clause did
+      // not exist, then this could be a simple Release_Store to set the new
+      // value but because it does, it's possible that other threads could add
+      // one or more nodes at the tail before reaching this point. We don't
+      // have to check the return value because it either operates correctly
+      // or the exact same operation has already been done (by the "else"
+      // clause) on some other thread.
+      shared_meta()->tailptr.compare_exchange_strong(tail, ref,
+                                                     std::memory_order_release,
+                                                     std::memory_order_relaxed);
+      return;
+    } else {
+      // In the unlikely case that a thread crashed or was killed between the
+      // update of "next" and the update of "tailptr", it is necessary to
+      // perform the operation that would have been done. There's no explicit
+      // check for crash/kill which means that this operation may also happen
+      // even when the other thread is in perfect working order which is what
+      // necessitates the CompareAndSwap above.
+      shared_meta()->tailptr.compare_exchange_strong(tail, next,
+                                                     std::memory_order_acq_rel,
+                                                     std::memory_order_acquire);
+    }
+  }
+}
+
+// The "corrupted" state is held both locally and globally (shared). The
+// shared flag can't be trusted since a malicious actor could overwrite it.
+// Because corruption can be detected during read-only operations such as
+// iteration, this method may be called by other "const" methods. In this
+// case, it's safe to discard the constness and modify the local flag and
+// maybe even the shared flag if the underlying data isn't actually read-only.
+void PersistentMemoryAllocator::SetCorrupt() const {
+  if (!corrupt_.load(std::memory_order_relaxed) &&
+      !CheckFlag(
+          const_cast<volatile std::atomic<uint32_t>*>(&shared_meta()->flags),
+          kFlagCorrupt)) {
+    LOG(ERROR) << "Corruption detected in shared-memory segment.";
+    RecordError(kMemoryIsCorrupt);
+  }
+
+  corrupt_.store(true, std::memory_order_relaxed);
+  if (!readonly_) {
+    SetFlag(const_cast<volatile std::atomic<uint32_t>*>(&shared_meta()->flags),
+            kFlagCorrupt);
+  }
+}
+
+bool PersistentMemoryAllocator::IsCorrupt() const {
+  if (corrupt_.load(std::memory_order_relaxed) ||
+      CheckFlag(&shared_meta()->flags, kFlagCorrupt)) {
+    SetCorrupt();  // Make sure all indicators are set.
+    return true;
+  }
+  return false;
+}
+
+bool PersistentMemoryAllocator::IsFull() const {
+  return CheckFlag(&shared_meta()->flags, kFlagFull);
+}
+
+// Dereference a block |ref| and ensure that it's valid for the desired
+// |type_id| and |size|. |special| indicates that we may try to access block
+// headers not available to callers but still accessed by this module. By
+// having internal dereferences go through this same function, the allocator
+// is hardened against corruption.
+const volatile PersistentMemoryAllocator::BlockHeader*
+PersistentMemoryAllocator::GetBlock(Reference ref, uint32_t type_id,
+                                    uint32_t size, bool queue_ok,
+                                    bool free_ok) const {
+  // Handle special cases.
+  if (ref == kReferenceQueue && queue_ok)
+    return reinterpret_cast<const volatile BlockHeader*>(mem_base_ + ref);
+
+  // Validation of parameters.
+  if (ref < sizeof(SharedMetadata))
+    return nullptr;
+  if (ref % kAllocAlignment != 0)
+    return nullptr;
+  size += sizeof(BlockHeader);
+  if (ref + size > mem_size_)
+    return nullptr;
+
+  // Validation of referenced block-header.
+  if (!free_ok) {
+    const volatile BlockHeader* const block =
+        reinterpret_cast<volatile BlockHeader*>(mem_base_ + ref);
+    if (block->cookie != kBlockCookieAllocated)
+      return nullptr;
+    if (block->size < size)
+      return nullptr;
+    if (ref + block->size > mem_size_)
+      return nullptr;
+    if (type_id != 0 &&
+        block->type_id.load(std::memory_order_relaxed) != type_id) {
+      return nullptr;
+    }
+  }
+
+  // Return pointer to block data.
+  return reinterpret_cast<const volatile BlockHeader*>(mem_base_ + ref);
+}
+
+void PersistentMemoryAllocator::FlushPartial(size_t length, bool sync) {
+  // Generally there is nothing to do as every write is done through volatile
+  // memory with atomic instructions to guarantee consistency. This (virtual)
+  // method exists so that derivced classes can do special things, such as
+  // tell the OS to write changes to disk now rather than when convenient.
+}
+
+void PersistentMemoryAllocator::RecordError(int error) const {
+  if (errors_histogram_)
+    errors_histogram_->Add(error);
+}
+
+const volatile void* PersistentMemoryAllocator::GetBlockData(
+    Reference ref,
+    uint32_t type_id,
+    uint32_t size) const {
+  DCHECK(size > 0);
+  const volatile BlockHeader* block =
+      GetBlock(ref, type_id, size, false, false);
+  if (!block)
+    return nullptr;
+  return reinterpret_cast<const volatile char*>(block) + sizeof(BlockHeader);
+}
+
+void PersistentMemoryAllocator::UpdateTrackingHistograms() {
+  DCHECK(!readonly_);
+  if (used_histogram_) {
+    MemoryInfo meminfo;
+    GetMemoryInfo(&meminfo);
+    HistogramBase::Sample used_percent = static_cast<HistogramBase::Sample>(
+        ((meminfo.total - meminfo.free) * 100ULL / meminfo.total));
+    used_histogram_->Add(used_percent);
+  }
+}
+
+
+//----- LocalPersistentMemoryAllocator -----------------------------------------
+
+LocalPersistentMemoryAllocator::LocalPersistentMemoryAllocator(
+    size_t size,
+    uint64_t id,
+    base::StringPiece name)
+    : PersistentMemoryAllocator(AllocateLocalMemory(size),
+                                size, 0, id, name, false) {}
+
+LocalPersistentMemoryAllocator::~LocalPersistentMemoryAllocator() {
+  DeallocateLocalMemory(const_cast<char*>(mem_base_), mem_size_, mem_type_);
+}
+
+// static
+PersistentMemoryAllocator::Memory
+LocalPersistentMemoryAllocator::AllocateLocalMemory(size_t size) {
+  void* address;
+
+#if defined(OS_WIN)
+  address =
+      ::VirtualAlloc(nullptr, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+  if (address)
+    return Memory(address, MEM_VIRTUAL);
+  UmaHistogramSparse("UMA.LocalPersistentMemoryAllocator.Failures.Win",
+                     ::GetLastError());
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  // MAP_ANON is deprecated on Linux but MAP_ANONYMOUS is not universal on Mac.
+  // MAP_SHARED is not available on Linux <2.4 but required on Mac.
+  address = ::mmap(nullptr, size, PROT_READ | PROT_WRITE,
+                   MAP_ANON | MAP_SHARED, -1, 0);
+  if (address != MAP_FAILED)
+    return Memory(address, MEM_VIRTUAL);
+  UmaHistogramSparse("UMA.LocalPersistentMemoryAllocator.Failures.Posix",
+                     errno);
+#else
+#error This architecture is not (yet) supported.
+#endif
+
+  // As a last resort, just allocate the memory from the heap. This will
+  // achieve the same basic result but the acquired memory has to be
+  // explicitly zeroed and thus realized immediately (i.e. all pages are
+  // added to the process now istead of only when first accessed).
+  address = malloc(size);
+  DPCHECK(address);
+  memset(address, 0, size);
+  return Memory(address, MEM_MALLOC);
+}
+
+// static
+void LocalPersistentMemoryAllocator::DeallocateLocalMemory(void* memory,
+                                                           size_t size,
+                                                           MemoryType type) {
+  if (type == MEM_MALLOC) {
+    free(memory);
+    return;
+  }
+
+  DCHECK_EQ(MEM_VIRTUAL, type);
+#if defined(OS_WIN)
+  BOOL success = ::VirtualFree(memory, 0, MEM_DECOMMIT);
+  DCHECK(success);
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  int result = ::munmap(memory, size);
+  DCHECK_EQ(0, result);
+#else
+#error This architecture is not (yet) supported.
+#endif
+}
+
+
+//----- SharedPersistentMemoryAllocator ----------------------------------------
+
+SharedPersistentMemoryAllocator::SharedPersistentMemoryAllocator(
+    std::unique_ptr<SharedMemory> memory,
+    uint64_t id,
+    base::StringPiece name,
+    bool read_only)
+    : PersistentMemoryAllocator(
+          Memory(static_cast<uint8_t*>(memory->memory()), MEM_SHARED),
+          memory->mapped_size(),
+          0,
+          id,
+          name,
+          read_only),
+      shared_memory_(std::move(memory)) {}
+
+SharedPersistentMemoryAllocator::~SharedPersistentMemoryAllocator() = default;
+
+// static
+bool SharedPersistentMemoryAllocator::IsSharedMemoryAcceptable(
+    const SharedMemory& memory) {
+  return IsMemoryAcceptable(memory.memory(), memory.mapped_size(), 0, false);
+}
+
+
+#if !defined(OS_NACL)
+//----- FilePersistentMemoryAllocator ------------------------------------------
+
+FilePersistentMemoryAllocator::FilePersistentMemoryAllocator(
+    std::unique_ptr<MemoryMappedFile> file,
+    size_t max_size,
+    uint64_t id,
+    base::StringPiece name,
+    bool read_only)
+    : PersistentMemoryAllocator(
+          Memory(const_cast<uint8_t*>(file->data()), MEM_FILE),
+          max_size != 0 ? max_size : file->length(),
+          0,
+          id,
+          name,
+          read_only),
+      mapped_file_(std::move(file)) {}
+
+FilePersistentMemoryAllocator::~FilePersistentMemoryAllocator() = default;
+
+// static
+bool FilePersistentMemoryAllocator::IsFileAcceptable(
+    const MemoryMappedFile& file,
+    bool read_only) {
+  return IsMemoryAcceptable(file.data(), file.length(), 0, read_only);
+}
+
+void FilePersistentMemoryAllocator::FlushPartial(size_t length, bool sync) {
+  if (sync)
+    AssertBlockingAllowed();
+  if (IsReadonly())
+    return;
+
+#if defined(OS_WIN)
+  // Windows doesn't support asynchronous flush.
+  AssertBlockingAllowed();
+  BOOL success = ::FlushViewOfFile(data(), length);
+  DPCHECK(success);
+#elif defined(OS_MACOSX)
+  // On OSX, "invalidate" removes all cached pages, forcing a re-read from
+  // disk. That's not applicable to "flush" so omit it.
+  int result =
+      ::msync(const_cast<void*>(data()), length, sync ? MS_SYNC : MS_ASYNC);
+  DCHECK_NE(EINVAL, result);
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  // On POSIX, "invalidate" forces _other_ processes to recognize what has
+  // been written to disk and so is applicable to "flush".
+  int result = ::msync(const_cast<void*>(data()), length,
+                       MS_INVALIDATE | (sync ? MS_SYNC : MS_ASYNC));
+  DCHECK_NE(EINVAL, result);
+#else
+#error Unsupported OS.
+#endif
+}
+#endif  // !defined(OS_NACL)
+
+//----- DelayedPersistentAllocation --------------------------------------------
+
+// Forwarding constructors.
+DelayedPersistentAllocation::DelayedPersistentAllocation(
+    PersistentMemoryAllocator* allocator,
+    subtle::Atomic32* ref,
+    uint32_t type,
+    size_t size,
+    bool make_iterable)
+    : DelayedPersistentAllocation(
+          allocator,
+          reinterpret_cast<std::atomic<Reference>*>(ref),
+          type,
+          size,
+          0,
+          make_iterable) {}
+
+DelayedPersistentAllocation::DelayedPersistentAllocation(
+    PersistentMemoryAllocator* allocator,
+    subtle::Atomic32* ref,
+    uint32_t type,
+    size_t size,
+    size_t offset,
+    bool make_iterable)
+    : DelayedPersistentAllocation(
+          allocator,
+          reinterpret_cast<std::atomic<Reference>*>(ref),
+          type,
+          size,
+          offset,
+          make_iterable) {}
+
+DelayedPersistentAllocation::DelayedPersistentAllocation(
+    PersistentMemoryAllocator* allocator,
+    std::atomic<Reference>* ref,
+    uint32_t type,
+    size_t size,
+    bool make_iterable)
+    : DelayedPersistentAllocation(allocator,
+                                  ref,
+                                  type,
+                                  size,
+                                  0,
+                                  make_iterable) {}
+
+// Real constructor.
+DelayedPersistentAllocation::DelayedPersistentAllocation(
+    PersistentMemoryAllocator* allocator,
+    std::atomic<Reference>* ref,
+    uint32_t type,
+    size_t size,
+    size_t offset,
+    bool make_iterable)
+    : allocator_(allocator),
+      type_(type),
+      size_(checked_cast<uint32_t>(size)),
+      offset_(checked_cast<uint32_t>(offset)),
+      make_iterable_(make_iterable),
+      reference_(ref) {
+  DCHECK(allocator_);
+  DCHECK_NE(0U, type_);
+  DCHECK_LT(0U, size_);
+  DCHECK(reference_);
+}
+
+DelayedPersistentAllocation::~DelayedPersistentAllocation() = default;
+
+void* DelayedPersistentAllocation::Get() const {
+  // Relaxed operations are acceptable here because it's not protecting the
+  // contents of the allocation in any way.
+  Reference ref = reference_->load(std::memory_order_acquire);
+  if (!ref) {
+    ref = allocator_->Allocate(size_, type_);
+    if (!ref)
+      return nullptr;
+
+    // Store the new reference in its proper location using compare-and-swap.
+    // Use a "strong" exchange to ensure no false-negatives since the operation
+    // cannot be retried.
+    Reference existing = 0;  // Must be mutable; receives actual value.
+    if (reference_->compare_exchange_strong(existing, ref,
+                                            std::memory_order_release,
+                                            std::memory_order_relaxed)) {
+      if (make_iterable_)
+        allocator_->MakeIterable(ref);
+    } else {
+      // Failure indicates that something else has raced ahead, performed the
+      // allocation, and stored its reference. Purge the allocation that was
+      // just done and use the other one instead.
+      DCHECK_EQ(type_, allocator_->GetType(existing));
+      DCHECK_LE(size_, allocator_->GetAllocSize(existing));
+      allocator_->ChangeType(ref, 0, type_, /*clear=*/false);
+      ref = existing;
+    }
+  }
+
+  char* mem = allocator_->GetAsArray<char>(ref, type_, size_);
+  if (!mem) {
+    // This should never happen but be tolerant if it does as corruption from
+    // the outside is something to guard against.
+    NOTREACHED();
+    return nullptr;
+  }
+  return mem + offset_;
+}
+
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.h b/native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.h
new file mode 100644
index 0000000..978a362
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.h
@@ -0,0 +1,872 @@
+// Copyright (c) 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
+#define BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
+
+#include <stdint.h>
+
+#include <atomic>
+#include <memory>
+#include <type_traits>
+
+#include "base/atomicops.h"
+#include "base/base_export.h"
+#include "base/files/file_path.h"
+#include "base/gtest_prod_util.h"
+#include "base/macros.h"
+#include "base/strings/string_piece.h"
+
+namespace base {
+
+class HistogramBase;
+class MemoryMappedFile;
+class SharedMemory;
+
+// Simple allocator for pieces of a memory block that may be persistent
+// to some storage or shared across multiple processes. This class resides
+// under base/metrics because it was written for that purpose. It is,
+// however, fully general-purpose and can be freely moved to base/memory
+// if other uses are found.
+//
+// This class provides for thread-secure (i.e. safe against other threads
+// or processes that may be compromised and thus have malicious intent)
+// allocation of memory within a designated block and also a mechanism by
+// which other threads can learn of these allocations.
+//
+// There is (currently) no way to release an allocated block of data because
+// doing so would risk invalidating pointers held by other processes and
+// greatly complicate the allocation algorithm.
+//
+// Construction of this object can accept new, clean (i.e. zeroed) memory
+// or previously initialized memory. In the first case, construction must
+// be allowed to complete before letting other allocators attach to the same
+// segment. In other words, don't share the segment until at least one
+// allocator has been attached to it.
+//
+// Note that memory not in active use is not accessed so it is possible to
+// use virtual memory, including memory-mapped files, as backing storage with
+// the OS "pinning" new (zeroed) physical RAM pages only as they are needed.
+//
+// OBJECTS: Although the allocator can be used in a "malloc" sense, fetching
+// character arrays and manipulating that memory manually, the better way is
+// generally to use the "object" methods to create and manage allocations. In
+// this way the sizing, type-checking, and construction are all automatic. For
+// this to work, however, every type of stored object must define two public
+// "constexpr" values, kPersistentTypeId and kExpectedInstanceSize, as such:
+//
+// struct MyPersistentObjectType {
+//     // SHA1(MyPersistentObjectType): Increment this if structure changes!
+//     static constexpr uint32_t kPersistentTypeId = 0x3E15F6DE + 1;
+//
+//     // Expected size for 32/64-bit check. Update this if structure changes!
+//     static constexpr size_t kExpectedInstanceSize = 20;
+//
+//     ...
+// };
+//
+// kPersistentTypeId: This value is an arbitrary identifier that allows the
+//   identification of these objects in the allocator, including the ability
+//   to find them via iteration. The number is arbitrary but using the first
+//   four bytes of the SHA1 hash of the type name means that there shouldn't
+//   be any conflicts with other types that may also be stored in the memory.
+//   The fully qualified name (e.g. base::debug::MyPersistentObjectType) could
+//   be used to generate the hash if the type name seems common. Use a command
+//   like this to get the hash: echo -n "MyPersistentObjectType" | sha1sum
+//   If the structure layout changes, ALWAYS increment this number so that
+//   newer versions of the code don't try to interpret persistent data written
+//   by older versions with a different layout.
+//
+// kExpectedInstanceSize: This value is the hard-coded number that matches
+//   what sizeof(T) would return. By providing it explicitly, the allocator can
+//   verify that the structure is compatible between both 32-bit and 64-bit
+//   versions of the code.
+//
+// Using New manages the memory and then calls the default constructor for the
+// object. Given that objects are persistent, no destructor is ever called
+// automatically though a caller can explicitly call Delete to destruct it and
+// change the type to something indicating it is no longer in use.
+//
+// Though persistent memory segments are transferrable between programs built
+// for different natural word widths, they CANNOT be exchanged between CPUs
+// of different endianess. Attempts to do so will simply see the existing data
+// as corrupt and refuse to access any of it.
+class BASE_EXPORT PersistentMemoryAllocator {
+ public:
+  typedef uint32_t Reference;
+
+  // These states are used to indicate the overall condition of the memory
+  // segment irrespective of what is stored within it. Because the data is
+  // often persistent and thus needs to be readable by different versions of
+  // a program, these values are fixed and can never change.
+  enum MemoryState : uint8_t {
+    // Persistent memory starts all zeros and so shows "uninitialized".
+    MEMORY_UNINITIALIZED = 0,
+
+    // The header has been written and the memory is ready for use.
+    MEMORY_INITIALIZED = 1,
+
+    // The data should be considered deleted. This would be set when the
+    // allocator is being cleaned up. If file-backed, the file is likely
+    // to be deleted but since deletion can fail for a variety of reasons,
+    // having this extra status means a future reader can realize what
+    // should have happened.
+    MEMORY_DELETED = 2,
+
+    // Outside code can create states starting with this number; these too
+    // must also never change between code versions.
+    MEMORY_USER_DEFINED = 100,
+  };
+
+  // Iterator for going through all iterable memory records in an allocator.
+  // Like the allocator itself, iterators are lock-free and thread-secure.
+  // That means that multiple threads can share an iterator and the same
+  // reference will not be returned twice.
+  //
+  // The order of the items returned by an iterator matches the order in which
+  // MakeIterable() was called on them. Once an allocation is made iterable,
+  // it is always such so the only possible difference between successive
+  // iterations is for more to be added to the end.
+  //
+  // Iteration, in general, is tolerant of corrupted memory. It will return
+  // what it can and stop only when corruption forces it to. Bad corruption
+  // could cause the same object to be returned many times but it will
+  // eventually quit.
+  class BASE_EXPORT Iterator {
+   public:
+    // Constructs an iterator on a given |allocator|, starting at the beginning.
+    // The allocator must live beyond the lifetime of the iterator. This class
+    // has read-only access to the allocator (hence "const") but the returned
+    // references can be used on a read/write version, too.
+    explicit Iterator(const PersistentMemoryAllocator* allocator);
+
+    // As above but resuming from the |starting_after| reference. The first call
+    // to GetNext() will return the next object found after that reference. The
+    // reference must be to an "iterable" object; references to non-iterable
+    // objects (those that never had MakeIterable() called for them) will cause
+    // a run-time error.
+    Iterator(const PersistentMemoryAllocator* allocator,
+             Reference starting_after);
+
+    // Resets the iterator back to the beginning.
+    void Reset();
+
+    // Resets the iterator, resuming from the |starting_after| reference.
+    void Reset(Reference starting_after);
+
+    // Returns the previously retrieved reference, or kReferenceNull if none.
+    // If constructor or reset with a starting_after location, this will return
+    // that value.
+    Reference GetLast();
+
+    // Gets the next iterable, storing that type in |type_return|. The actual
+    // return value is a reference to the allocation inside the allocator or
+    // zero if there are no more. GetNext() may still be called again at a
+    // later time to retrieve any new allocations that have been added.
+    Reference GetNext(uint32_t* type_return);
+
+    // Similar to above but gets the next iterable of a specific |type_match|.
+    // This should not be mixed with calls to GetNext() because any allocations
+    // skipped here due to a type mis-match will never be returned by later
+    // calls to GetNext() meaning it's possible to completely miss entries.
+    Reference GetNextOfType(uint32_t type_match);
+
+    // As above but works using object type.
+    template <typename T>
+    Reference GetNextOfType() {
+      return GetNextOfType(T::kPersistentTypeId);
+    }
+
+    // As above but works using objects and returns null if not found.
+    template <typename T>
+    const T* GetNextOfObject() {
+      return GetAsObject<T>(GetNextOfType<T>());
+    }
+
+    // Converts references to objects. This is a convenience method so that
+    // users of the iterator don't need to also have their own pointer to the
+    // allocator over which the iterator runs in order to retrieve objects.
+    // Because the iterator is not read/write, only "const" objects can be
+    // fetched. Non-const objects can be fetched using the reference on a
+    // non-const (external) pointer to the same allocator (or use const_cast
+    // to remove the qualifier).
+    template <typename T>
+    const T* GetAsObject(Reference ref) const {
+      return allocator_->GetAsObject<T>(ref);
+    }
+
+    // Similar to GetAsObject() but converts references to arrays of things.
+    template <typename T>
+    const T* GetAsArray(Reference ref, uint32_t type_id, size_t count) const {
+      return allocator_->GetAsArray<T>(ref, type_id, count);
+    }
+
+    // Convert a generic pointer back into a reference. A null reference will
+    // be returned if |memory| is not inside the persistent segment or does not
+    // point to an object of the specified |type_id|.
+    Reference GetAsReference(const void* memory, uint32_t type_id) const {
+      return allocator_->GetAsReference(memory, type_id);
+    }
+
+    // As above but convert an object back into a reference.
+    template <typename T>
+    Reference GetAsReference(const T* obj) const {
+      return allocator_->GetAsReference(obj);
+    }
+
+   private:
+    // Weak-pointer to memory allocator being iterated over.
+    const PersistentMemoryAllocator* allocator_;
+
+    // The last record that was returned.
+    std::atomic<Reference> last_record_;
+
+    // The number of records found; used for detecting loops.
+    std::atomic<uint32_t> record_count_;
+
+    DISALLOW_COPY_AND_ASSIGN(Iterator);
+  };
+
+  // Returned information about the internal state of the heap.
+  struct MemoryInfo {
+    size_t total;
+    size_t free;
+  };
+
+  enum : Reference {
+    // A common "null" reference value.
+    kReferenceNull = 0,
+  };
+
+  enum : uint32_t {
+    // A value that will match any type when doing lookups.
+    kTypeIdAny = 0x00000000,
+
+    // A value indicating that the type is in transition. Work is being done
+    // on the contents to prepare it for a new type to come.
+    kTypeIdTransitioning = 0xFFFFFFFF,
+  };
+
+  enum : size_t {
+    kSizeAny = 1  // Constant indicating that any array size is acceptable.
+  };
+
+  // This is the standard file extension (suitable for being passed to the
+  // AddExtension() method of base::FilePath) for dumps of persistent memory.
+  static const base::FilePath::CharType kFileExtension[];
+
+  // The allocator operates on any arbitrary block of memory. Creation and
+  // persisting or sharing of that block with another process is the
+  // responsibility of the caller. The allocator needs to know only the
+  // block's |base| address, the total |size| of the block, and any internal
+  // |page| size (zero if not paged) across which allocations should not span.
+  // The |id| is an arbitrary value the caller can use to identify a
+  // particular memory segment. It will only be loaded during the initial
+  // creation of the segment and can be checked by the caller for consistency.
+  // The |name|, if provided, is used to distinguish histograms for this
+  // allocator. Only the primary owner of the segment should define this value;
+  // other processes can learn it from the shared state. If the underlying
+  // memory is |readonly| then no changes will be made to it. The resulting
+  // object should be stored as a "const" pointer.
+  //
+  // PersistentMemoryAllocator does NOT take ownership of the memory block.
+  // The caller must manage it and ensure it stays available throughout the
+  // lifetime of this object.
+  //
+  // Memory segments for sharing must have had an allocator attached to them
+  // before actually being shared. If the memory segment was just created, it
+  // should be zeroed before being passed here. If it was an existing segment,
+  // the values here will be compared to copies stored in the shared segment
+  // as a guard against corruption.
+  //
+  // Make sure that the memory segment is acceptable (see IsMemoryAcceptable()
+  // method below) before construction if the definition of the segment can
+  // vary in any way at run-time. Invalid memory segments will cause a crash.
+  PersistentMemoryAllocator(void* base, size_t size, size_t page_size,
+                            uint64_t id, base::StringPiece name,
+                            bool readonly);
+  virtual ~PersistentMemoryAllocator();
+
+  // Check if memory segment is acceptable for creation of an Allocator. This
+  // doesn't do any analysis of the data and so doesn't guarantee that the
+  // contents are valid, just that the paramaters won't cause the program to
+  // abort. The IsCorrupt() method will report detection of data problems
+  // found during construction and general operation.
+  static bool IsMemoryAcceptable(const void* data, size_t size,
+                                 size_t page_size, bool readonly);
+
+  // Get the internal identifier for this persistent memory segment.
+  uint64_t Id() const;
+
+  // Get the internal name of this allocator (possibly an empty string).
+  const char* Name() const;
+
+  // Is this segment open only for read?
+  bool IsReadonly() const { return readonly_; }
+
+  // Manage the saved state of the memory.
+  void SetMemoryState(uint8_t memory_state);
+  uint8_t GetMemoryState() const;
+
+  // Create internal histograms for tracking memory use and allocation sizes
+  // for allocator of |name| (which can simply be the result of Name()). This
+  // is done seperately from construction for situations such as when the
+  // histograms will be backed by memory provided by this very allocator.
+  //
+  // IMPORTANT: Callers must update tools/metrics/histograms/histograms.xml
+  // with the following histograms:
+  //    UMA.PersistentAllocator.name.Errors
+  //    UMA.PersistentAllocator.name.UsedPct
+  void CreateTrackingHistograms(base::StringPiece name);
+
+  // Flushes the persistent memory to any backing store. This typically does
+  // nothing but is used by the FilePersistentMemoryAllocator to inform the
+  // OS that all the data should be sent to the disk immediately. This is
+  // useful in the rare case where something has just been stored that needs
+  // to survive a hard shutdown of the machine like from a power failure.
+  // The |sync| parameter indicates if this call should block until the flush
+  // is complete but is only advisory and may or may not have an effect
+  // depending on the capabilities of the OS. Synchronous flushes are allowed
+  // only from theads that are allowed to do I/O but since |sync| is only
+  // advisory, all flushes should be done on IO-capable threads.
+  void Flush(bool sync);
+
+  // Direct access to underlying memory segment. If the segment is shared
+  // across threads or processes, reading data through these values does
+  // not guarantee consistency. Use with care. Do not write.
+  const void* data() const { return const_cast<const char*>(mem_base_); }
+  size_t length() const { return mem_size_; }
+  size_t size() const { return mem_size_; }
+  size_t used() const;
+
+  // Get an object referenced by a |ref|. For safety reasons, the |type_id|
+  // code and size-of(|T|) are compared to ensure the reference is valid
+  // and cannot return an object outside of the memory segment. A |type_id| of
+  // kTypeIdAny (zero) will match any though the size is still checked. NULL is
+  // returned if any problem is detected, such as corrupted storage or incorrect
+  // parameters. Callers MUST check that the returned value is not-null EVERY
+  // TIME before accessing it or risk crashing! Once dereferenced, the pointer
+  // is safe to reuse forever.
+  //
+  // It is essential that the object be of a fixed size. All fields must be of
+  // a defined type that does not change based on the compiler or the CPU
+  // natural word size. Acceptable are char, float, double, and (u)intXX_t.
+  // Unacceptable are int, bool, and wchar_t which are implementation defined
+  // with regards to their size.
+  //
+  // Alignment must also be consistent. A uint64_t after a uint32_t will pad
+  // differently between 32 and 64 bit architectures. Either put the bigger
+  // elements first, group smaller elements into blocks the size of larger
+  // elements, or manually insert padding fields as appropriate for the
+  // largest architecture, including at the end.
+  //
+  // To protected against mistakes, all objects must have the attribute
+  // |kExpectedInstanceSize| (static constexpr size_t)  that is a hard-coded
+  // numerical value -- NNN, not sizeof(T) -- that can be tested. If the
+  // instance size is not fixed, at least one build will fail.
+  //
+  // If the size of a structure changes, the type-ID used to recognize it
+  // should also change so later versions of the code don't try to read
+  // incompatible structures from earlier versions.
+  //
+  // NOTE: Though this method will guarantee that an object of the specified
+  // type can be accessed without going outside the bounds of the memory
+  // segment, it makes no guarantees of the validity of the data within the
+  // object itself. If it is expected that the contents of the segment could
+  // be compromised with malicious intent, the object must be hardened as well.
+  //
+  // Though the persistent data may be "volatile" if it is shared with
+  // other processes, such is not necessarily the case. The internal
+  // "volatile" designation is discarded so as to not propagate the viral
+  // nature of that keyword to the caller. It can add it back, if necessary,
+  // based on knowledge of how the allocator is being used.
+  template <typename T>
+  T* GetAsObject(Reference ref) {
+    static_assert(std::is_standard_layout<T>::value, "only standard objects");
+    static_assert(!std::is_array<T>::value, "use GetAsArray<>()");
+    static_assert(T::kExpectedInstanceSize == sizeof(T), "inconsistent size");
+    return const_cast<T*>(reinterpret_cast<volatile T*>(
+        GetBlockData(ref, T::kPersistentTypeId, sizeof(T))));
+  }
+  template <typename T>
+  const T* GetAsObject(Reference ref) const {
+    static_assert(std::is_standard_layout<T>::value, "only standard objects");
+    static_assert(!std::is_array<T>::value, "use GetAsArray<>()");
+    static_assert(T::kExpectedInstanceSize == sizeof(T), "inconsistent size");
+    return const_cast<const T*>(reinterpret_cast<const volatile T*>(
+        GetBlockData(ref, T::kPersistentTypeId, sizeof(T))));
+  }
+
+  // Like GetAsObject but get an array of simple, fixed-size types.
+  //
+  // Use a |count| of the required number of array elements, or kSizeAny.
+  // GetAllocSize() can be used to calculate the upper bound but isn't reliable
+  // because padding can make space for extra elements that were not written.
+  //
+  // Remember that an array of char is a string but may not be NUL terminated.
+  //
+  // There are no compile-time or run-time checks to ensure 32/64-bit size
+  // compatibilty when using these accessors. Only use fixed-size types such
+  // as char, float, double, or (u)intXX_t.
+  template <typename T>
+  T* GetAsArray(Reference ref, uint32_t type_id, size_t count) {
+    static_assert(std::is_fundamental<T>::value, "use GetAsObject<>()");
+    return const_cast<T*>(reinterpret_cast<volatile T*>(
+        GetBlockData(ref, type_id, count * sizeof(T))));
+  }
+  template <typename T>
+  const T* GetAsArray(Reference ref, uint32_t type_id, size_t count) const {
+    static_assert(std::is_fundamental<T>::value, "use GetAsObject<>()");
+    return const_cast<const char*>(reinterpret_cast<const volatile T*>(
+        GetBlockData(ref, type_id, count * sizeof(T))));
+  }
+
+  // Get the corresponding reference for an object held in persistent memory.
+  // If the |memory| is not valid or the type does not match, a kReferenceNull
+  // result will be returned.
+  Reference GetAsReference(const void* memory, uint32_t type_id) const;
+
+  // Get the number of bytes allocated to a block. This is useful when storing
+  // arrays in order to validate the ending boundary. The returned value will
+  // include any padding added to achieve the required alignment and so could
+  // be larger than given in the original Allocate() request.
+  size_t GetAllocSize(Reference ref) const;
+
+  // Access the internal "type" of an object. This generally isn't necessary
+  // but can be used to "clear" the type and so effectively mark it as deleted
+  // even though the memory stays valid and allocated. Changing the type is
+  // an atomic compare/exchange and so requires knowing the existing value.
+  // It will return false if the existing type is not what is expected.
+  //
+  // Changing the type doesn't mean the data is compatible with the new type.
+  // Passing true for |clear| will zero the memory after the type has been
+  // changed away from |from_type_id| but before it becomes |to_type_id| meaning
+  // that it is done in a manner that is thread-safe. Memory is guaranteed to
+  // be zeroed atomically by machine-word in a monotonically increasing order.
+  //
+  // It will likely be necessary to reconstruct the type before it can be used.
+  // Changing the type WILL NOT invalidate existing pointers to the data, either
+  // in this process or others, so changing the data structure could have
+  // unpredicatable results. USE WITH CARE!
+  uint32_t GetType(Reference ref) const;
+  bool ChangeType(Reference ref,
+                  uint32_t to_type_id,
+                  uint32_t from_type_id,
+                  bool clear);
+
+  // Allocated objects can be added to an internal list that can then be
+  // iterated over by other processes. If an allocated object can be found
+  // another way, such as by having its reference within a different object
+  // that will be made iterable, then this call is not necessary. This always
+  // succeeds unless corruption is detected; check IsCorrupted() to find out.
+  // Once an object is made iterable, its position in iteration can never
+  // change; new iterable objects will always be added after it in the series.
+  // Changing the type does not alter its "iterable" status.
+  void MakeIterable(Reference ref);
+
+  // Get the information about the amount of free space in the allocator. The
+  // amount of free space should be treated as approximate due to extras from
+  // alignment and metadata. Concurrent allocations from other threads will
+  // also make the true amount less than what is reported.
+  void GetMemoryInfo(MemoryInfo* meminfo) const;
+
+  // If there is some indication that the memory has become corrupted,
+  // calling this will attempt to prevent further damage by indicating to
+  // all processes that something is not as expected.
+  void SetCorrupt() const;
+
+  // This can be called to determine if corruption has been detected in the
+  // segment, possibly my a malicious actor. Once detected, future allocations
+  // will fail and iteration may not locate all objects.
+  bool IsCorrupt() const;
+
+  // Flag set if an allocation has failed because the memory segment was full.
+  bool IsFull() const;
+
+  // Update those "tracking" histograms which do not get updates during regular
+  // operation, such as how much memory is currently used. This should be
+  // called before such information is to be displayed or uploaded.
+  void UpdateTrackingHistograms();
+
+  // While the above works much like malloc & free, these next methods provide
+  // an "object" interface similar to new and delete.
+
+  // Reserve space in the memory segment of the desired |size| and |type_id|.
+  // A return value of zero indicates the allocation failed, otherwise the
+  // returned reference can be used by any process to get a real pointer via
+  // the GetAsObject() or GetAsArray calls. The actual allocated size may be
+  // larger and will always be a multiple of 8 bytes (64 bits).
+  Reference Allocate(size_t size, uint32_t type_id);
+
+  // Allocate and construct an object in persistent memory. The type must have
+  // both (size_t) kExpectedInstanceSize and (uint32_t) kPersistentTypeId
+  // static constexpr fields that are used to ensure compatibility between
+  // software versions. An optional size parameter can be specified to force
+  // the allocation to be bigger than the size of the object; this is useful
+  // when the last field is actually variable length.
+  template <typename T>
+  T* New(size_t size) {
+    if (size < sizeof(T))
+      size = sizeof(T);
+    Reference ref = Allocate(size, T::kPersistentTypeId);
+    void* mem =
+        const_cast<void*>(GetBlockData(ref, T::kPersistentTypeId, size));
+    if (!mem)
+      return nullptr;
+    DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(mem) & (alignof(T) - 1));
+    return new (mem) T();
+  }
+  template <typename T>
+  T* New() {
+    return New<T>(sizeof(T));
+  }
+
+  // Similar to New, above, but construct the object out of an existing memory
+  // block and of an expected type. If |clear| is true, memory will be zeroed
+  // before construction. Though this is not standard object behavior, it
+  // is present to match with new allocations that always come from zeroed
+  // memory. Anything previously present simply ceases to exist; no destructor
+  // is called for it so explicitly Delete() the old object first if need be.
+  // Calling this will not invalidate existing pointers to the object, either
+  // in this process or others, so changing the object could have unpredictable
+  // results. USE WITH CARE!
+  template <typename T>
+  T* New(Reference ref, uint32_t from_type_id, bool clear) {
+    DCHECK_LE(sizeof(T), GetAllocSize(ref)) << "alloc not big enough for obj";
+    // Make sure the memory is appropriate. This won't be used until after
+    // the type is changed but checking first avoids the possibility of having
+    // to change the type back.
+    void* mem = const_cast<void*>(GetBlockData(ref, 0, sizeof(T)));
+    if (!mem)
+      return nullptr;
+    // Ensure the allocator's internal alignment is sufficient for this object.
+    // This protects against coding errors in the allocator.
+    DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(mem) & (alignof(T) - 1));
+    // Change the type, clearing the memory if so desired. The new type is
+    // "transitioning" so that there is no race condition with the construction
+    // of the object should another thread be simultaneously iterating over
+    // data. This will "acquire" the memory so no changes get reordered before
+    // it.
+    if (!ChangeType(ref, kTypeIdTransitioning, from_type_id, clear))
+      return nullptr;
+    // Construct an object of the desired type on this memory, just as if
+    // New() had been called to create it.
+    T* obj = new (mem) T();
+    // Finally change the type to the desired one. This will "release" all of
+    // the changes above and so provide a consistent view to other threads.
+    bool success =
+        ChangeType(ref, T::kPersistentTypeId, kTypeIdTransitioning, false);
+    DCHECK(success);
+    return obj;
+  }
+
+  // Deletes an object by destructing it and then changing the type to a
+  // different value (default 0).
+  template <typename T>
+  void Delete(T* obj, uint32_t new_type) {
+    // Get the reference for the object.
+    Reference ref = GetAsReference<T>(obj);
+    // First change the type to "transitioning" so there is no race condition
+    // where another thread could find the object through iteration while it
+    // is been destructed. This will "acquire" the memory so no changes get
+    // reordered before it. It will fail if |ref| is invalid.
+    if (!ChangeType(ref, kTypeIdTransitioning, T::kPersistentTypeId, false))
+      return;
+    // Destruct the object.
+    obj->~T();
+    // Finally change the type to the desired value. This will "release" all
+    // the changes above.
+    bool success = ChangeType(ref, new_type, kTypeIdTransitioning, false);
+    DCHECK(success);
+  }
+  template <typename T>
+  void Delete(T* obj) {
+    Delete<T>(obj, 0);
+  }
+
+  // As above but works with objects allocated from persistent memory.
+  template <typename T>
+  Reference GetAsReference(const T* obj) const {
+    return GetAsReference(obj, T::kPersistentTypeId);
+  }
+
+  // As above but works with an object allocated from persistent memory.
+  template <typename T>
+  void MakeIterable(const T* obj) {
+    MakeIterable(GetAsReference<T>(obj));
+  }
+
+ protected:
+  enum MemoryType {
+    MEM_EXTERNAL,
+    MEM_MALLOC,
+    MEM_VIRTUAL,
+    MEM_SHARED,
+    MEM_FILE,
+  };
+
+  struct Memory {
+    Memory(void* b, MemoryType t) : base(b), type(t) {}
+
+    void* base;
+    MemoryType type;
+  };
+
+  // Constructs the allocator. Everything is the same as the public allocator
+  // except |memory| which is a structure with additional information besides
+  // the base address.
+  PersistentMemoryAllocator(Memory memory, size_t size, size_t page_size,
+                            uint64_t id, base::StringPiece name,
+                            bool readonly);
+
+  // Implementation of Flush that accepts how much to flush.
+  virtual void FlushPartial(size_t length, bool sync);
+
+  volatile char* const mem_base_;  // Memory base. (char so sizeof guaranteed 1)
+  const MemoryType mem_type_;      // Type of memory allocation.
+  const uint32_t mem_size_;        // Size of entire memory segment.
+  const uint32_t mem_page_;        // Page size allocations shouldn't cross.
+
+ private:
+  struct SharedMetadata;
+  struct BlockHeader;
+  static const uint32_t kAllocAlignment;
+  static const Reference kReferenceQueue;
+
+  // The shared metadata is always located at the top of the memory segment.
+  // These convenience functions eliminate constant casting of the base
+  // pointer within the code.
+  const SharedMetadata* shared_meta() const {
+    return reinterpret_cast<const SharedMetadata*>(
+        const_cast<const char*>(mem_base_));
+  }
+  SharedMetadata* shared_meta() {
+    return reinterpret_cast<SharedMetadata*>(const_cast<char*>(mem_base_));
+  }
+
+  // Actual method for doing the allocation.
+  Reference AllocateImpl(size_t size, uint32_t type_id);
+
+  // Get the block header associated with a specific reference.
+  const volatile BlockHeader* GetBlock(Reference ref, uint32_t type_id,
+                                       uint32_t size, bool queue_ok,
+                                       bool free_ok) const;
+  volatile BlockHeader* GetBlock(Reference ref, uint32_t type_id, uint32_t size,
+                                 bool queue_ok, bool free_ok) {
+      return const_cast<volatile BlockHeader*>(
+          const_cast<const PersistentMemoryAllocator*>(this)->GetBlock(
+              ref, type_id, size, queue_ok, free_ok));
+  }
+
+  // Get the actual data within a block associated with a specific reference.
+  const volatile void* GetBlockData(Reference ref, uint32_t type_id,
+                                    uint32_t size) const;
+  volatile void* GetBlockData(Reference ref, uint32_t type_id,
+                              uint32_t size) {
+      return const_cast<volatile void*>(
+          const_cast<const PersistentMemoryAllocator*>(this)->GetBlockData(
+              ref, type_id, size));
+  }
+
+  // Record an error in the internal histogram.
+  void RecordError(int error) const;
+
+  const size_t vm_page_size_;          // The page size used by the OS.
+  const bool readonly_;                // Indicates access to read-only memory.
+  mutable std::atomic<bool> corrupt_;  // Local version of "corrupted" flag.
+
+  HistogramBase* allocs_histogram_;  // Histogram recording allocs.
+  HistogramBase* used_histogram_;    // Histogram recording used space.
+  HistogramBase* errors_histogram_;  // Histogram recording errors.
+
+  friend class PersistentMemoryAllocatorTest;
+  FRIEND_TEST_ALL_PREFIXES(PersistentMemoryAllocatorTest, AllocateAndIterate);
+  DISALLOW_COPY_AND_ASSIGN(PersistentMemoryAllocator);
+};
+
+
+// This allocator uses a local memory block it allocates from the general
+// heap. It is generally used when some kind of "death rattle" handler will
+// save the contents to persistent storage during process shutdown. It is
+// also useful for testing.
+class BASE_EXPORT LocalPersistentMemoryAllocator
+    : public PersistentMemoryAllocator {
+ public:
+  LocalPersistentMemoryAllocator(size_t size, uint64_t id,
+                                 base::StringPiece name);
+  ~LocalPersistentMemoryAllocator() override;
+
+ private:
+  // Allocates a block of local memory of the specified |size|, ensuring that
+  // the memory will not be physically allocated until accessed and will read
+  // as zero when that happens.
+  static Memory AllocateLocalMemory(size_t size);
+
+  // Deallocates a block of local |memory| of the specified |size|.
+  static void DeallocateLocalMemory(void* memory, size_t size, MemoryType type);
+
+  DISALLOW_COPY_AND_ASSIGN(LocalPersistentMemoryAllocator);
+};
+
+
+// This allocator takes a shared-memory object and performs allocation from
+// it. The memory must be previously mapped via Map() or MapAt(). The allocator
+// takes ownership of the memory object.
+class BASE_EXPORT SharedPersistentMemoryAllocator
+    : public PersistentMemoryAllocator {
+ public:
+  SharedPersistentMemoryAllocator(std::unique_ptr<SharedMemory> memory,
+                                  uint64_t id,
+                                  base::StringPiece name,
+                                  bool read_only);
+  ~SharedPersistentMemoryAllocator() override;
+
+  SharedMemory* shared_memory() { return shared_memory_.get(); }
+
+  // Ensure that the memory isn't so invalid that it would crash when passing it
+  // to the allocator. This doesn't guarantee the data is valid, just that it
+  // won't cause the program to abort. The existing IsCorrupt() call will handle
+  // the rest.
+  static bool IsSharedMemoryAcceptable(const SharedMemory& memory);
+
+ private:
+  std::unique_ptr<SharedMemory> shared_memory_;
+
+  DISALLOW_COPY_AND_ASSIGN(SharedPersistentMemoryAllocator);
+};
+
+
+#if !defined(OS_NACL)  // NACL doesn't support any kind of file access in build.
+// This allocator takes a memory-mapped file object and performs allocation
+// from it. The allocator takes ownership of the file object.
+class BASE_EXPORT FilePersistentMemoryAllocator
+    : public PersistentMemoryAllocator {
+ public:
+  // A |max_size| of zero will use the length of the file as the maximum
+  // size. The |file| object must have been already created with sufficient
+  // permissions (read, read/write, or read/write/extend).
+  FilePersistentMemoryAllocator(std::unique_ptr<MemoryMappedFile> file,
+                                size_t max_size,
+                                uint64_t id,
+                                base::StringPiece name,
+                                bool read_only);
+  ~FilePersistentMemoryAllocator() override;
+
+  // Ensure that the file isn't so invalid that it would crash when passing it
+  // to the allocator. This doesn't guarantee the file is valid, just that it
+  // won't cause the program to abort. The existing IsCorrupt() call will handle
+  // the rest.
+  static bool IsFileAcceptable(const MemoryMappedFile& file, bool read_only);
+
+ protected:
+  // PersistentMemoryAllocator:
+  void FlushPartial(size_t length, bool sync) override;
+
+ private:
+  std::unique_ptr<MemoryMappedFile> mapped_file_;
+
+  DISALLOW_COPY_AND_ASSIGN(FilePersistentMemoryAllocator);
+};
+#endif  // !defined(OS_NACL)
+
+// An allocation that is defined but not executed until required at a later
+// time. This allows for potential users of an allocation to be decoupled
+// from the logic that defines it. In addition, there can be multiple users
+// of the same allocation or any region thereof that are guaranteed to always
+// use the same space. It's okay to copy/move these objects.
+//
+// This is a top-level class instead of an inner class of the PMA so that it
+// can be forward-declared in other header files without the need to include
+// the full contents of this file.
+class BASE_EXPORT DelayedPersistentAllocation {
+ public:
+  using Reference = PersistentMemoryAllocator::Reference;
+
+  // Creates a delayed allocation using the specified |allocator|. When
+  // needed, the memory will be allocated using the specified |type| and
+  // |size|. If |offset| is given, the returned pointer will be at that
+  // offset into the segment; this allows combining allocations into a
+  // single persistent segment to reduce overhead and means an "all or
+  // nothing" request. Note that |size| is always the total memory size
+  // and |offset| is just indicating the start of a block within it.  If
+  // |make_iterable| was true, the allocation will made iterable when it
+  // is created; already existing allocations are not changed.
+  //
+  // Once allocated, a reference to the segment will be stored at |ref|.
+  // This shared location must be initialized to zero (0); it is checked
+  // with every Get() request to see if the allocation has already been
+  // done. If reading |ref| outside of this object, be sure to do an
+  // "acquire" load. Don't write to it -- leave that to this object.
+  //
+  // For convenience, methods taking both Atomic32 and std::atomic<Reference>
+  // are defined.
+  DelayedPersistentAllocation(PersistentMemoryAllocator* allocator,
+                              subtle::Atomic32* ref,
+                              uint32_t type,
+                              size_t size,
+                              bool make_iterable);
+  DelayedPersistentAllocation(PersistentMemoryAllocator* allocator,
+                              subtle::Atomic32* ref,
+                              uint32_t type,
+                              size_t size,
+                              size_t offset,
+                              bool make_iterable);
+  DelayedPersistentAllocation(PersistentMemoryAllocator* allocator,
+                              std::atomic<Reference>* ref,
+                              uint32_t type,
+                              size_t size,
+                              bool make_iterable);
+  DelayedPersistentAllocation(PersistentMemoryAllocator* allocator,
+                              std::atomic<Reference>* ref,
+                              uint32_t type,
+                              size_t size,
+                              size_t offset,
+                              bool make_iterable);
+  ~DelayedPersistentAllocation();
+
+  // Gets a pointer to the defined allocation. This will realize the request
+  // and update the reference provided during construction. The memory will
+  // be zeroed the first time it is returned, after that it is shared with
+  // all other Get() requests and so shows any changes made to it elsewhere.
+  //
+  // If the allocation fails for any reason, null will be returned. This works
+  // even on "const" objects because the allocation is already defined, just
+  // delayed.
+  void* Get() const;
+
+  // Gets the internal reference value. If this returns a non-zero value then
+  // a subsequent call to Get() will do nothing but convert that reference into
+  // a memory location -- useful for accessing an existing allocation without
+  // creating one unnecessarily.
+  Reference reference() const {
+    return reference_->load(std::memory_order_relaxed);
+  }
+
+ private:
+  // The underlying object that does the actual allocation of memory. Its
+  // lifetime must exceed that of all DelayedPersistentAllocation objects
+  // that use it.
+  PersistentMemoryAllocator* const allocator_;
+
+  // The desired type and size of the allocated segment plus the offset
+  // within it for the defined request.
+  const uint32_t type_;
+  const uint32_t size_;
+  const uint32_t offset_;
+
+  // Flag indicating if allocation should be made iterable when done.
+  const bool make_iterable_;
+
+  // The location at which a reference to the allocated segment is to be
+  // stored once the allocation is complete. If multiple delayed allocations
+  // share the same pointer then an allocation on one will amount to an
+  // allocation for all.
+  volatile std::atomic<Reference>* const reference_;
+
+  // No DISALLOW_COPY_AND_ASSIGN as it's okay to copy/move these objects.
+};
+
+}  // namespace base
+
+#endif  // BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/sparse_histogram.h b/native/zucchini/vendor/libchrome/base/metrics/sparse_histogram.h
new file mode 100644
index 0000000..913762c
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/metrics/sparse_histogram.h
@@ -0,0 +1,108 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_METRICS_SPARSE_HISTOGRAM_H_
+#define BASE_METRICS_SPARSE_HISTOGRAM_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include "base/base_export.h"
+#include "base/macros.h"
+#include "base/metrics/histogram_base.h"
+#include "base/metrics/histogram_samples.h"
+#include "base/synchronization/lock.h"
+
+namespace base {
+
+class HistogramSamples;
+class PersistentHistogramAllocator;
+class Pickle;
+class PickleIterator;
+
+class BASE_EXPORT SparseHistogram : public HistogramBase {
+ public:
+  // If there's one with same name, return the existing one. If not, create a
+  // new one.
+  static HistogramBase* FactoryGet(const std::string& name, int32_t flags);
+
+  // Create a histogram using data in persistent storage. The allocator must
+  // live longer than the created sparse histogram.
+  static std::unique_ptr<HistogramBase> PersistentCreate(
+      PersistentHistogramAllocator* allocator,
+      const char* name,
+      HistogramSamples::Metadata* meta,
+      HistogramSamples::Metadata* logged_meta);
+
+  ~SparseHistogram() override;
+
+  // HistogramBase implementation:
+  uint64_t name_hash() const override;
+  HistogramType GetHistogramType() const override;
+  bool HasConstructionArguments(Sample expected_minimum,
+                                Sample expected_maximum,
+                                uint32_t expected_bucket_count) const override;
+  void Add(Sample value) override;
+  void AddCount(Sample value, int count) override;
+  void AddSamples(const HistogramSamples& samples) override;
+  bool AddSamplesFromPickle(base::PickleIterator* iter) override;
+  std::unique_ptr<HistogramSamples> SnapshotSamples() const override;
+  std::unique_ptr<HistogramSamples> SnapshotDelta() override;
+  std::unique_ptr<HistogramSamples> SnapshotFinalDelta() const override;
+  void WriteHTMLGraph(std::string* output) const override;
+  void WriteAscii(std::string* output) const override;
+
+ protected:
+  // HistogramBase implementation:
+  void SerializeInfoImpl(base::Pickle* pickle) const override;
+
+ private:
+  // Clients should always use FactoryGet to create SparseHistogram.
+  explicit SparseHistogram(const char* name);
+
+  SparseHistogram(PersistentHistogramAllocator* allocator,
+                  const char* name,
+                  HistogramSamples::Metadata* meta,
+                  HistogramSamples::Metadata* logged_meta);
+
+  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
+      base::PickleIterator* iter);
+  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
+
+  void GetParameters(DictionaryValue* params) const override;
+  void GetCountAndBucketData(Count* count,
+                             int64_t* sum,
+                             ListValue* buckets) const override;
+
+  // Helpers for emitting Ascii graphic.  Each method appends data to output.
+  void WriteAsciiImpl(bool graph_it,
+                      const std::string& newline,
+                      std::string* output) const;
+
+  // Write a common header message describing this histogram.
+  void WriteAsciiHeader(const Count total_count,
+                        std::string* output) const;
+
+  // For constuctor calling.
+  friend class SparseHistogramTest;
+
+  // Protects access to |samples_|.
+  mutable base::Lock lock_;
+
+  // Flag to indicate if PrepareFinalDelta has been previously called.
+  mutable bool final_delta_created_ = false;
+
+  std::unique_ptr<HistogramSamples> unlogged_samples_;
+  std::unique_ptr<HistogramSamples> logged_samples_;
+
+  DISALLOW_COPY_AND_ASSIGN(SparseHistogram);
+};
+
+}  // namespace base
+
+#endif  // BASE_METRICS_SPARSE_HISTOGRAM_H_
diff --git a/native/zucchini/vendor/libchrome/base/no_destructor.h b/native/zucchini/vendor/libchrome/base/no_destructor.h
new file mode 100644
index 0000000..aabc6e6
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/no_destructor.h
@@ -0,0 +1,99 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_NO_DESTRUCTOR_H_
+#define BASE_NO_DESTRUCTOR_H_
+
+#include <new>
+#include <utility>
+
+namespace base {
+
+// A wrapper that makes it easy to create an object of type T with static
+// storage duration that:
+// - is only constructed on first access
+// - never invokes the destructor
+// in order to satisfy the styleguide ban on global constructors and
+// destructors.
+//
+// Runtime constant example:
+// const std::string& GetLineSeparator() {
+//  // Forwards to std::string(size_t, char, const Allocator&) constructor.
+//   static const base::NoDestructor<std::string> s(5, '-');
+//   return *s;
+// }
+//
+// More complex initialization with a lambda:
+// const std::string& GetSessionNonce() {
+//   static const base::NoDestructor<std::string> nonce([] {
+//     std::string s(16);
+//     crypto::RandString(s.data(), s.size());
+//     return s;
+//   }());
+//   return *nonce;
+// }
+//
+// NoDestructor<T> stores the object inline, so it also avoids a pointer
+// indirection and a malloc. Also note that since C++11 static local variable
+// initialization is thread-safe and so is this pattern. Code should prefer to
+// use NoDestructor<T> over:
+// - The CR_DEFINE_STATIC_LOCAL() helper macro.
+// - A function scoped static T* or T& that is dynamically initialized.
+// - A global base::LazyInstance<T>.
+//
+// Note that since the destructor is never run, this *will* leak memory if used
+// as a stack or member variable. Furthermore, a NoDestructor<T> should never
+// have global scope as that may require a static initializer.
+template <typename T>
+class NoDestructor {
+ public:
+  // Not constexpr; just write static constexpr T x = ...; if the value should
+  // be a constexpr.
+  template <typename... Args>
+  explicit NoDestructor(Args&&... args) {
+    new (storage_) T(std::forward<Args>(args)...);
+  }
+
+  // Allows copy and move construction of the contained type, to allow
+  // construction from an initializer list, e.g. for std::vector.
+  explicit NoDestructor(const T& x) { new (storage_) T(x); }
+  explicit NoDestructor(T&& x) { new (storage_) T(std::move(x)); }
+
+  NoDestructor(const NoDestructor&) = delete;
+  NoDestructor& operator=(const NoDestructor&) = delete;
+
+  ~NoDestructor() = default;
+
+  const T& operator*() const { return *get(); }
+  T& operator*() { return *get(); }
+
+  const T* operator->() const { return get(); }
+  T* operator->() { return get(); }
+
+  const T* get() const { return reinterpret_cast<const T*>(storage_); }
+  T* get() { return reinterpret_cast<T*>(storage_); }
+
+ private:
+  alignas(T) char storage_[sizeof(T)];
+
+#if defined(LEAK_SANITIZER)
+  // TODO(https://crbug.com/812277): This is a hack to work around the fact
+  // that LSan doesn't seem to treat NoDestructor as a root for reachability
+  // analysis. This means that code like this:
+  //   static base::NoDestructor<std::vector<int>> v({1, 2, 3});
+  // is considered a leak. Using the standard leak sanitizer annotations to
+  // suppress leaks doesn't work: std::vector is implicitly constructed before
+  // calling the base::NoDestructor constructor.
+  //
+  // Unfortunately, I haven't been able to demonstrate this issue in simpler
+  // reproductions: until that's resolved, hold an explicit pointer to the
+  // placement-new'd object in leak sanitizer mode to help LSan realize that
+  // objects allocated by the contained type are still reachable.
+  T* storage_ptr_ = reinterpret_cast<T*>(storage_);
+#endif  // defined(LEAK_SANITIZER)
+};
+
+}  // namespace base
+
+#endif  // BASE_NO_DESTRUCTOR_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/checked_math.h b/native/zucchini/vendor/libchrome/base/numerics/checked_math.h
new file mode 100644
index 0000000..ede3344
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/numerics/checked_math.h
@@ -0,0 +1,393 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_NUMERICS_CHECKED_MATH_H_
+#define BASE_NUMERICS_CHECKED_MATH_H_
+
+#include <stddef.h>
+
+#include <limits>
+#include <type_traits>
+
+#include "base/numerics/checked_math_impl.h"
+
+namespace base {
+namespace internal {
+
+template <typename T>
+class CheckedNumeric {
+  static_assert(std::is_arithmetic<T>::value,
+                "CheckedNumeric<T>: T must be a numeric type.");
+
+ public:
+  using type = T;
+
+  constexpr CheckedNumeric() = default;
+
+  // Copy constructor.
+  template <typename Src>
+  constexpr CheckedNumeric(const CheckedNumeric<Src>& rhs)
+      : state_(rhs.state_.value(), rhs.IsValid()) {}
+
+  template <typename Src>
+  friend class CheckedNumeric;
+
+  // This is not an explicit constructor because we implicitly upgrade regular
+  // numerics to CheckedNumerics to make them easier to use.
+  template <typename Src>
+  constexpr CheckedNumeric(Src value)  // NOLINT(runtime/explicit)
+      : state_(value) {
+    static_assert(std::is_arithmetic<Src>::value, "Argument must be numeric.");
+  }
+
+  // This is not an explicit constructor because we want a seamless conversion
+  // from StrictNumeric types.
+  template <typename Src>
+  constexpr CheckedNumeric(
+      StrictNumeric<Src> value)  // NOLINT(runtime/explicit)
+      : state_(static_cast<Src>(value)) {}
+
+  // IsValid() - The public API to test if a CheckedNumeric is currently valid.
+  // A range checked destination type can be supplied using the Dst template
+  // parameter.
+  template <typename Dst = T>
+  constexpr bool IsValid() const {
+    return state_.is_valid() &&
+           IsValueInRangeForNumericType<Dst>(state_.value());
+  }
+
+  // AssignIfValid(Dst) - Assigns the underlying value if it is currently valid
+  // and is within the range supported by the destination type. Returns true if
+  // successful and false otherwise.
+  template <typename Dst>
+#if defined(__clang__) || defined(__GNUC__)
+  __attribute__((warn_unused_result))
+#elif defined(_MSC_VER)
+  _Check_return_
+#endif
+  constexpr bool
+  AssignIfValid(Dst* result) const {
+    return BASE_NUMERICS_LIKELY(IsValid<Dst>())
+               ? ((*result = static_cast<Dst>(state_.value())), true)
+               : false;
+  }
+
+  // ValueOrDie() - The primary accessor for the underlying value. If the
+  // current state is not valid it will CHECK and crash.
+  // A range checked destination type can be supplied using the Dst template
+  // parameter, which will trigger a CHECK if the value is not in bounds for
+  // the destination.
+  // The CHECK behavior can be overridden by supplying a handler as a
+  // template parameter, for test code, etc. However, the handler cannot access
+  // the underlying value, and it is not available through other means.
+  template <typename Dst = T, class CheckHandler = CheckOnFailure>
+  constexpr StrictNumeric<Dst> ValueOrDie() const {
+    return BASE_NUMERICS_LIKELY(IsValid<Dst>())
+               ? static_cast<Dst>(state_.value())
+               : CheckHandler::template HandleFailure<Dst>();
+  }
+
+  // ValueOrDefault(T default_value) - A convenience method that returns the
+  // current value if the state is valid, and the supplied default_value for
+  // any other state.
+  // A range checked destination type can be supplied using the Dst template
+  // parameter. WARNING: This function may fail to compile or CHECK at runtime
+  // if the supplied default_value is not within range of the destination type.
+  template <typename Dst = T, typename Src>
+  constexpr StrictNumeric<Dst> ValueOrDefault(const Src default_value) const {
+    return BASE_NUMERICS_LIKELY(IsValid<Dst>())
+               ? static_cast<Dst>(state_.value())
+               : checked_cast<Dst>(default_value);
+  }
+
+  // Returns a checked numeric of the specified type, cast from the current
+  // CheckedNumeric. If the current state is invalid or the destination cannot
+  // represent the result then the returned CheckedNumeric will be invalid.
+  template <typename Dst>
+  constexpr CheckedNumeric<typename UnderlyingType<Dst>::type> Cast() const {
+    return *this;
+  }
+
+  // This friend method is available solely for providing more detailed logging
+  // in the the tests. Do not implement it in production code, because the
+  // underlying values may change at any time.
+  template <typename U>
+  friend U GetNumericValueForTest(const CheckedNumeric<U>& src);
+
+  // Prototypes for the supported arithmetic operator overloads.
+  template <typename Src>
+  constexpr CheckedNumeric& operator+=(const Src rhs);
+  template <typename Src>
+  constexpr CheckedNumeric& operator-=(const Src rhs);
+  template <typename Src>
+  constexpr CheckedNumeric& operator*=(const Src rhs);
+  template <typename Src>
+  constexpr CheckedNumeric& operator/=(const Src rhs);
+  template <typename Src>
+  constexpr CheckedNumeric& operator%=(const Src rhs);
+  template <typename Src>
+  constexpr CheckedNumeric& operator<<=(const Src rhs);
+  template <typename Src>
+  constexpr CheckedNumeric& operator>>=(const Src rhs);
+  template <typename Src>
+  constexpr CheckedNumeric& operator&=(const Src rhs);
+  template <typename Src>
+  constexpr CheckedNumeric& operator|=(const Src rhs);
+  template <typename Src>
+  constexpr CheckedNumeric& operator^=(const Src rhs);
+
+  constexpr CheckedNumeric operator-() const {
+    // The negation of two's complement int min is int min, so we simply
+    // check for that in the constexpr case.
+    // We use an optimized code path for a known run-time variable.
+    return MustTreatAsConstexpr(state_.value()) || !std::is_signed<T>::value ||
+                   std::is_floating_point<T>::value
+               ? CheckedNumeric<T>(
+                     NegateWrapper(state_.value()),
+                     IsValid() && (!std::is_signed<T>::value ||
+                                   std::is_floating_point<T>::value ||
+                                   NegateWrapper(state_.value()) !=
+                                       std::numeric_limits<T>::lowest()))
+               : FastRuntimeNegate();
+  }
+
+  constexpr CheckedNumeric operator~() const {
+    return CheckedNumeric<decltype(InvertWrapper(T()))>(
+        InvertWrapper(state_.value()), IsValid());
+  }
+
+  constexpr CheckedNumeric Abs() const {
+    return !IsValueNegative(state_.value()) ? *this : -*this;
+  }
+
+  template <typename U>
+  constexpr CheckedNumeric<typename MathWrapper<CheckedMaxOp, T, U>::type> Max(
+      const U rhs) const {
+    using R = typename UnderlyingType<U>::type;
+    using result_type = typename MathWrapper<CheckedMaxOp, T, U>::type;
+    // TODO(jschuh): This can be converted to the MathOp version and remain
+    // constexpr once we have C++14 support.
+    return CheckedNumeric<result_type>(
+        static_cast<result_type>(
+            IsGreater<T, R>::Test(state_.value(), Wrapper<U>::value(rhs))
+                ? state_.value()
+                : Wrapper<U>::value(rhs)),
+        state_.is_valid() && Wrapper<U>::is_valid(rhs));
+  }
+
+  template <typename U>
+  constexpr CheckedNumeric<typename MathWrapper<CheckedMinOp, T, U>::type> Min(
+      const U rhs) const {
+    using R = typename UnderlyingType<U>::type;
+    using result_type = typename MathWrapper<CheckedMinOp, T, U>::type;
+    // TODO(jschuh): This can be converted to the MathOp version and remain
+    // constexpr once we have C++14 support.
+    return CheckedNumeric<result_type>(
+        static_cast<result_type>(
+            IsLess<T, R>::Test(state_.value(), Wrapper<U>::value(rhs))
+                ? state_.value()
+                : Wrapper<U>::value(rhs)),
+        state_.is_valid() && Wrapper<U>::is_valid(rhs));
+  }
+
+  // This function is available only for integral types. It returns an unsigned
+  // integer of the same width as the source type, containing the absolute value
+  // of the source, and properly handling signed min.
+  constexpr CheckedNumeric<typename UnsignedOrFloatForSize<T>::type>
+  UnsignedAbs() const {
+    return CheckedNumeric<typename UnsignedOrFloatForSize<T>::type>(
+        SafeUnsignedAbs(state_.value()), state_.is_valid());
+  }
+
+  constexpr CheckedNumeric& operator++() {
+    *this += 1;
+    return *this;
+  }
+
+  constexpr CheckedNumeric operator++(int) {
+    CheckedNumeric value = *this;
+    *this += 1;
+    return value;
+  }
+
+  constexpr CheckedNumeric& operator--() {
+    *this -= 1;
+    return *this;
+  }
+
+  constexpr CheckedNumeric operator--(int) {
+    CheckedNumeric value = *this;
+    *this -= 1;
+    return value;
+  }
+
+  // These perform the actual math operations on the CheckedNumerics.
+  // Binary arithmetic operations.
+  template <template <typename, typename, typename> class M,
+            typename L,
+            typename R>
+  static constexpr CheckedNumeric MathOp(const L lhs, const R rhs) {
+    using Math = typename MathWrapper<M, L, R>::math;
+    T result = 0;
+    bool is_valid =
+        Wrapper<L>::is_valid(lhs) && Wrapper<R>::is_valid(rhs) &&
+        Math::Do(Wrapper<L>::value(lhs), Wrapper<R>::value(rhs), &result);
+    return CheckedNumeric<T>(result, is_valid);
+  }
+
+  // Assignment arithmetic operations.
+  template <template <typename, typename, typename> class M, typename R>
+  constexpr CheckedNumeric& MathOp(const R rhs) {
+    using Math = typename MathWrapper<M, T, R>::math;
+    T result = 0;  // Using T as the destination saves a range check.
+    bool is_valid = state_.is_valid() && Wrapper<R>::is_valid(rhs) &&
+                    Math::Do(state_.value(), Wrapper<R>::value(rhs), &result);
+    *this = CheckedNumeric<T>(result, is_valid);
+    return *this;
+  }
+
+ private:
+  CheckedNumericState<T> state_;
+
+  CheckedNumeric FastRuntimeNegate() const {
+    T result;
+    bool success = CheckedSubOp<T, T>::Do(T(0), state_.value(), &result);
+    return CheckedNumeric<T>(result, IsValid() && success);
+  }
+
+  template <typename Src>
+  constexpr CheckedNumeric(Src value, bool is_valid)
+      : state_(value, is_valid) {}
+
+  // These wrappers allow us to handle state the same way for both
+  // CheckedNumeric and POD arithmetic types.
+  template <typename Src>
+  struct Wrapper {
+    static constexpr bool is_valid(Src) { return true; }
+    static constexpr Src value(Src value) { return value; }
+  };
+
+  template <typename Src>
+  struct Wrapper<CheckedNumeric<Src>> {
+    static constexpr bool is_valid(const CheckedNumeric<Src> v) {
+      return v.IsValid();
+    }
+    static constexpr Src value(const CheckedNumeric<Src> v) {
+      return v.state_.value();
+    }
+  };
+
+  template <typename Src>
+  struct Wrapper<StrictNumeric<Src>> {
+    static constexpr bool is_valid(const StrictNumeric<Src>) { return true; }
+    static constexpr Src value(const StrictNumeric<Src> v) {
+      return static_cast<Src>(v);
+    }
+  };
+};
+
+// Convenience functions to avoid the ugly template disambiguator syntax.
+template <typename Dst, typename Src>
+constexpr bool IsValidForType(const CheckedNumeric<Src> value) {
+  return value.template IsValid<Dst>();
+}
+
+template <typename Dst, typename Src>
+constexpr StrictNumeric<Dst> ValueOrDieForType(
+    const CheckedNumeric<Src> value) {
+  return value.template ValueOrDie<Dst>();
+}
+
+template <typename Dst, typename Src, typename Default>
+constexpr StrictNumeric<Dst> ValueOrDefaultForType(
+    const CheckedNumeric<Src> value,
+    const Default default_value) {
+  return value.template ValueOrDefault<Dst>(default_value);
+}
+
+// Convience wrapper to return a new CheckedNumeric from the provided arithmetic
+// or CheckedNumericType.
+template <typename T>
+constexpr CheckedNumeric<typename UnderlyingType<T>::type> MakeCheckedNum(
+    const T value) {
+  return value;
+}
+
+// These implement the variadic wrapper for the math operations.
+template <template <typename, typename, typename> class M,
+          typename L,
+          typename R>
+constexpr CheckedNumeric<typename MathWrapper<M, L, R>::type> CheckMathOp(
+    const L lhs,
+    const R rhs) {
+  using Math = typename MathWrapper<M, L, R>::math;
+  return CheckedNumeric<typename Math::result_type>::template MathOp<M>(lhs,
+                                                                        rhs);
+}
+
+// General purpose wrapper template for arithmetic operations.
+template <template <typename, typename, typename> class M,
+          typename L,
+          typename R,
+          typename... Args>
+constexpr CheckedNumeric<typename ResultType<M, L, R, Args...>::type>
+CheckMathOp(const L lhs, const R rhs, const Args... args) {
+  return CheckMathOp<M>(CheckMathOp<M>(lhs, rhs), args...);
+}
+
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Add, +, +=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Sub, -, -=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Mul, *, *=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Div, /, /=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Mod, %, %=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Lsh, <<, <<=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Rsh, >>, >>=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, And, &, &=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Or, |, |=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Xor, ^, ^=)
+BASE_NUMERIC_ARITHMETIC_VARIADIC(Checked, Check, Max)
+BASE_NUMERIC_ARITHMETIC_VARIADIC(Checked, Check, Min)
+
+// These are some extra StrictNumeric operators to support simple pointer
+// arithmetic with our result types. Since wrapping on a pointer is always
+// bad, we trigger the CHECK condition here.
+template <typename L, typename R>
+L* operator+(L* lhs, const StrictNumeric<R> rhs) {
+  uintptr_t result = CheckAdd(reinterpret_cast<uintptr_t>(lhs),
+                              CheckMul(sizeof(L), static_cast<R>(rhs)))
+                         .template ValueOrDie<uintptr_t>();
+  return reinterpret_cast<L*>(result);
+}
+
+template <typename L, typename R>
+L* operator-(L* lhs, const StrictNumeric<R> rhs) {
+  uintptr_t result = CheckSub(reinterpret_cast<uintptr_t>(lhs),
+                              CheckMul(sizeof(L), static_cast<R>(rhs)))
+                         .template ValueOrDie<uintptr_t>();
+  return reinterpret_cast<L*>(result);
+}
+
+}  // namespace internal
+
+using internal::CheckedNumeric;
+using internal::IsValidForType;
+using internal::ValueOrDieForType;
+using internal::ValueOrDefaultForType;
+using internal::MakeCheckedNum;
+using internal::CheckMax;
+using internal::CheckMin;
+using internal::CheckAdd;
+using internal::CheckSub;
+using internal::CheckMul;
+using internal::CheckDiv;
+using internal::CheckMod;
+using internal::CheckLsh;
+using internal::CheckRsh;
+using internal::CheckAnd;
+using internal::CheckOr;
+using internal::CheckXor;
+
+}  // namespace base
+
+#endif  // BASE_NUMERICS_CHECKED_MATH_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/checked_math_impl.h b/native/zucchini/vendor/libchrome/base/numerics/checked_math_impl.h
new file mode 100644
index 0000000..e083389
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/numerics/checked_math_impl.h
@@ -0,0 +1,567 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_NUMERICS_CHECKED_MATH_IMPL_H_
+#define BASE_NUMERICS_CHECKED_MATH_IMPL_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <climits>
+#include <cmath>
+#include <cstdlib>
+#include <limits>
+#include <type_traits>
+
+#include "base/numerics/safe_conversions.h"
+#include "base/numerics/safe_math_shared_impl.h"
+
+namespace base {
+namespace internal {
+
+template <typename T>
+constexpr bool CheckedAddImpl(T x, T y, T* result) {
+  static_assert(std::is_integral<T>::value, "Type must be integral");
+  // Since the value of x+y is undefined if we have a signed type, we compute
+  // it using the unsigned type of the same size.
+  using UnsignedDst = typename std::make_unsigned<T>::type;
+  using SignedDst = typename std::make_signed<T>::type;
+  UnsignedDst ux = static_cast<UnsignedDst>(x);
+  UnsignedDst uy = static_cast<UnsignedDst>(y);
+  UnsignedDst uresult = static_cast<UnsignedDst>(ux + uy);
+  *result = static_cast<T>(uresult);
+  // Addition is valid if the sign of (x + y) is equal to either that of x or
+  // that of y.
+  return (std::is_signed<T>::value)
+             ? static_cast<SignedDst>((uresult ^ ux) & (uresult ^ uy)) >= 0
+             : uresult >= uy;  // Unsigned is either valid or underflow.
+}
+
+template <typename T, typename U, class Enable = void>
+struct CheckedAddOp {};
+
+template <typename T, typename U>
+struct CheckedAddOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename MaxExponentPromotion<T, U>::type;
+  template <typename V>
+  static constexpr bool Do(T x, U y, V* result) {
+    // TODO(jschuh) Make this "constexpr if" once we're C++17.
+    if (CheckedAddFastOp<T, U>::is_supported)
+      return CheckedAddFastOp<T, U>::Do(x, y, result);
+
+    // Double the underlying type up to a full machine word.
+    using FastPromotion = typename FastIntegerArithmeticPromotion<T, U>::type;
+    using Promotion =
+        typename std::conditional<(IntegerBitsPlusSign<FastPromotion>::value >
+                                   IntegerBitsPlusSign<intptr_t>::value),
+                                  typename BigEnoughPromotion<T, U>::type,
+                                  FastPromotion>::type;
+    // Fail if either operand is out of range for the promoted type.
+    // TODO(jschuh): This could be made to work for a broader range of values.
+    if (BASE_NUMERICS_UNLIKELY(!IsValueInRangeForNumericType<Promotion>(x) ||
+                               !IsValueInRangeForNumericType<Promotion>(y))) {
+      return false;
+    }
+
+    Promotion presult = {};
+    bool is_valid = true;
+    if (IsIntegerArithmeticSafe<Promotion, T, U>::value) {
+      presult = static_cast<Promotion>(x) + static_cast<Promotion>(y);
+    } else {
+      is_valid = CheckedAddImpl(static_cast<Promotion>(x),
+                                static_cast<Promotion>(y), &presult);
+    }
+    *result = static_cast<V>(presult);
+    return is_valid && IsValueInRangeForNumericType<V>(presult);
+  }
+};
+
+template <typename T>
+constexpr bool CheckedSubImpl(T x, T y, T* result) {
+  static_assert(std::is_integral<T>::value, "Type must be integral");
+  // Since the value of x+y is undefined if we have a signed type, we compute
+  // it using the unsigned type of the same size.
+  using UnsignedDst = typename std::make_unsigned<T>::type;
+  using SignedDst = typename std::make_signed<T>::type;
+  UnsignedDst ux = static_cast<UnsignedDst>(x);
+  UnsignedDst uy = static_cast<UnsignedDst>(y);
+  UnsignedDst uresult = static_cast<UnsignedDst>(ux - uy);
+  *result = static_cast<T>(uresult);
+  // Subtraction is valid if either x and y have same sign, or (x-y) and x have
+  // the same sign.
+  return (std::is_signed<T>::value)
+             ? static_cast<SignedDst>((uresult ^ ux) & (ux ^ uy)) >= 0
+             : x >= y;
+}
+
+template <typename T, typename U, class Enable = void>
+struct CheckedSubOp {};
+
+template <typename T, typename U>
+struct CheckedSubOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename MaxExponentPromotion<T, U>::type;
+  template <typename V>
+  static constexpr bool Do(T x, U y, V* result) {
+    // TODO(jschuh) Make this "constexpr if" once we're C++17.
+    if (CheckedSubFastOp<T, U>::is_supported)
+      return CheckedSubFastOp<T, U>::Do(x, y, result);
+
+    // Double the underlying type up to a full machine word.
+    using FastPromotion = typename FastIntegerArithmeticPromotion<T, U>::type;
+    using Promotion =
+        typename std::conditional<(IntegerBitsPlusSign<FastPromotion>::value >
+                                   IntegerBitsPlusSign<intptr_t>::value),
+                                  typename BigEnoughPromotion<T, U>::type,
+                                  FastPromotion>::type;
+    // Fail if either operand is out of range for the promoted type.
+    // TODO(jschuh): This could be made to work for a broader range of values.
+    if (BASE_NUMERICS_UNLIKELY(!IsValueInRangeForNumericType<Promotion>(x) ||
+                               !IsValueInRangeForNumericType<Promotion>(y))) {
+      return false;
+    }
+
+    Promotion presult = {};
+    bool is_valid = true;
+    if (IsIntegerArithmeticSafe<Promotion, T, U>::value) {
+      presult = static_cast<Promotion>(x) - static_cast<Promotion>(y);
+    } else {
+      is_valid = CheckedSubImpl(static_cast<Promotion>(x),
+                                static_cast<Promotion>(y), &presult);
+    }
+    *result = static_cast<V>(presult);
+    return is_valid && IsValueInRangeForNumericType<V>(presult);
+  }
+};
+
+template <typename T>
+constexpr bool CheckedMulImpl(T x, T y, T* result) {
+  static_assert(std::is_integral<T>::value, "Type must be integral");
+  // Since the value of x*y is potentially undefined if we have a signed type,
+  // we compute it using the unsigned type of the same size.
+  using UnsignedDst = typename std::make_unsigned<T>::type;
+  using SignedDst = typename std::make_signed<T>::type;
+  const UnsignedDst ux = SafeUnsignedAbs(x);
+  const UnsignedDst uy = SafeUnsignedAbs(y);
+  UnsignedDst uresult = static_cast<UnsignedDst>(ux * uy);
+  const bool is_negative =
+      std::is_signed<T>::value && static_cast<SignedDst>(x ^ y) < 0;
+  *result = is_negative ? 0 - uresult : uresult;
+  // We have a fast out for unsigned identity or zero on the second operand.
+  // After that it's an unsigned overflow check on the absolute value, with
+  // a +1 bound for a negative result.
+  return uy <= UnsignedDst(!std::is_signed<T>::value || is_negative) ||
+         ux <= (std::numeric_limits<T>::max() + UnsignedDst(is_negative)) / uy;
+}
+
+template <typename T, typename U, class Enable = void>
+struct CheckedMulOp {};
+
+template <typename T, typename U>
+struct CheckedMulOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename MaxExponentPromotion<T, U>::type;
+  template <typename V>
+  static constexpr bool Do(T x, U y, V* result) {
+    // TODO(jschuh) Make this "constexpr if" once we're C++17.
+    if (CheckedMulFastOp<T, U>::is_supported)
+      return CheckedMulFastOp<T, U>::Do(x, y, result);
+
+    using Promotion = typename FastIntegerArithmeticPromotion<T, U>::type;
+    // Verify the destination type can hold the result (always true for 0).
+    if (BASE_NUMERICS_UNLIKELY((!IsValueInRangeForNumericType<Promotion>(x) ||
+                                !IsValueInRangeForNumericType<Promotion>(y)) &&
+                               x && y)) {
+      return false;
+    }
+
+    Promotion presult = {};
+    bool is_valid = true;
+    if (CheckedMulFastOp<Promotion, Promotion>::is_supported) {
+      // The fast op may be available with the promoted type.
+      is_valid = CheckedMulFastOp<Promotion, Promotion>::Do(x, y, &presult);
+    } else if (IsIntegerArithmeticSafe<Promotion, T, U>::value) {
+      presult = static_cast<Promotion>(x) * static_cast<Promotion>(y);
+    } else {
+      is_valid = CheckedMulImpl(static_cast<Promotion>(x),
+                                static_cast<Promotion>(y), &presult);
+    }
+    *result = static_cast<V>(presult);
+    return is_valid && IsValueInRangeForNumericType<V>(presult);
+  }
+};
+
+// Division just requires a check for a zero denominator or an invalid negation
+// on signed min/-1.
+template <typename T, typename U, class Enable = void>
+struct CheckedDivOp {};
+
+template <typename T, typename U>
+struct CheckedDivOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename MaxExponentPromotion<T, U>::type;
+  template <typename V>
+  static constexpr bool Do(T x, U y, V* result) {
+    if (BASE_NUMERICS_UNLIKELY(!y))
+      return false;
+
+    // The overflow check can be compiled away if we don't have the exact
+    // combination of types needed to trigger this case.
+    using Promotion = typename BigEnoughPromotion<T, U>::type;
+    if (BASE_NUMERICS_UNLIKELY(
+            (std::is_signed<T>::value && std::is_signed<U>::value &&
+             IsTypeInRangeForNumericType<T, Promotion>::value &&
+             static_cast<Promotion>(x) ==
+                 std::numeric_limits<Promotion>::lowest() &&
+             y == static_cast<U>(-1)))) {
+      return false;
+    }
+
+    // This branch always compiles away if the above branch wasn't removed.
+    if (BASE_NUMERICS_UNLIKELY((!IsValueInRangeForNumericType<Promotion>(x) ||
+                                !IsValueInRangeForNumericType<Promotion>(y)) &&
+                               x)) {
+      return false;
+    }
+
+    Promotion presult = Promotion(x) / Promotion(y);
+    *result = static_cast<V>(presult);
+    return IsValueInRangeForNumericType<V>(presult);
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct CheckedModOp {};
+
+template <typename T, typename U>
+struct CheckedModOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename MaxExponentPromotion<T, U>::type;
+  template <typename V>
+  static constexpr bool Do(T x, U y, V* result) {
+    using Promotion = typename BigEnoughPromotion<T, U>::type;
+    if (BASE_NUMERICS_LIKELY(y)) {
+      Promotion presult = static_cast<Promotion>(x) % static_cast<Promotion>(y);
+      *result = static_cast<Promotion>(presult);
+      return IsValueInRangeForNumericType<V>(presult);
+    }
+    return false;
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct CheckedLshOp {};
+
+// Left shift. Shifts less than 0 or greater than or equal to the number
+// of bits in the promoted type are undefined. Shifts of negative values
+// are undefined. Otherwise it is defined when the result fits.
+template <typename T, typename U>
+struct CheckedLshOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = T;
+  template <typename V>
+  static constexpr bool Do(T x, U shift, V* result) {
+    // Disallow negative numbers and verify the shift is in bounds.
+    if (BASE_NUMERICS_LIKELY(!IsValueNegative(x) &&
+                             as_unsigned(shift) <
+                                 as_unsigned(std::numeric_limits<T>::digits))) {
+      // Shift as unsigned to avoid undefined behavior.
+      *result = static_cast<V>(as_unsigned(x) << shift);
+      // If the shift can be reversed, we know it was valid.
+      return *result >> shift == x;
+    }
+
+    // Handle the legal corner-case of a full-width signed shift of zero.
+    return std::is_signed<T>::value && !x &&
+           as_unsigned(shift) == as_unsigned(std::numeric_limits<T>::digits);
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct CheckedRshOp {};
+
+// Right shift. Shifts less than 0 or greater than or equal to the number
+// of bits in the promoted type are undefined. Otherwise, it is always defined,
+// but a right shift of a negative value is implementation-dependent.
+template <typename T, typename U>
+struct CheckedRshOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = T;
+  template <typename V>
+  static bool Do(T x, U shift, V* result) {
+    // Use the type conversion push negative values out of range.
+    if (BASE_NUMERICS_LIKELY(as_unsigned(shift) <
+                             IntegerBitsPlusSign<T>::value)) {
+      T tmp = x >> shift;
+      *result = static_cast<V>(tmp);
+      return IsValueInRangeForNumericType<V>(tmp);
+    }
+    return false;
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct CheckedAndOp {};
+
+// For simplicity we support only unsigned integer results.
+template <typename T, typename U>
+struct CheckedAndOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename std::make_unsigned<
+      typename MaxExponentPromotion<T, U>::type>::type;
+  template <typename V>
+  static constexpr bool Do(T x, U y, V* result) {
+    result_type tmp = static_cast<result_type>(x) & static_cast<result_type>(y);
+    *result = static_cast<V>(tmp);
+    return IsValueInRangeForNumericType<V>(tmp);
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct CheckedOrOp {};
+
+// For simplicity we support only unsigned integers.
+template <typename T, typename U>
+struct CheckedOrOp<T,
+                   U,
+                   typename std::enable_if<std::is_integral<T>::value &&
+                                           std::is_integral<U>::value>::type> {
+  using result_type = typename std::make_unsigned<
+      typename MaxExponentPromotion<T, U>::type>::type;
+  template <typename V>
+  static constexpr bool Do(T x, U y, V* result) {
+    result_type tmp = static_cast<result_type>(x) | static_cast<result_type>(y);
+    *result = static_cast<V>(tmp);
+    return IsValueInRangeForNumericType<V>(tmp);
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct CheckedXorOp {};
+
+// For simplicity we support only unsigned integers.
+template <typename T, typename U>
+struct CheckedXorOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename std::make_unsigned<
+      typename MaxExponentPromotion<T, U>::type>::type;
+  template <typename V>
+  static constexpr bool Do(T x, U y, V* result) {
+    result_type tmp = static_cast<result_type>(x) ^ static_cast<result_type>(y);
+    *result = static_cast<V>(tmp);
+    return IsValueInRangeForNumericType<V>(tmp);
+  }
+};
+
+// Max doesn't really need to be implemented this way because it can't fail,
+// but it makes the code much cleaner to use the MathOp wrappers.
+template <typename T, typename U, class Enable = void>
+struct CheckedMaxOp {};
+
+template <typename T, typename U>
+struct CheckedMaxOp<
+    T,
+    U,
+    typename std::enable_if<std::is_arithmetic<T>::value &&
+                            std::is_arithmetic<U>::value>::type> {
+  using result_type = typename MaxExponentPromotion<T, U>::type;
+  template <typename V>
+  static constexpr bool Do(T x, U y, V* result) {
+    result_type tmp = IsGreater<T, U>::Test(x, y) ? static_cast<result_type>(x)
+                                                  : static_cast<result_type>(y);
+    *result = static_cast<V>(tmp);
+    return IsValueInRangeForNumericType<V>(tmp);
+  }
+};
+
+// Min doesn't really need to be implemented this way because it can't fail,
+// but it makes the code much cleaner to use the MathOp wrappers.
+template <typename T, typename U, class Enable = void>
+struct CheckedMinOp {};
+
+template <typename T, typename U>
+struct CheckedMinOp<
+    T,
+    U,
+    typename std::enable_if<std::is_arithmetic<T>::value &&
+                            std::is_arithmetic<U>::value>::type> {
+  using result_type = typename LowestValuePromotion<T, U>::type;
+  template <typename V>
+  static constexpr bool Do(T x, U y, V* result) {
+    result_type tmp = IsLess<T, U>::Test(x, y) ? static_cast<result_type>(x)
+                                               : static_cast<result_type>(y);
+    *result = static_cast<V>(tmp);
+    return IsValueInRangeForNumericType<V>(tmp);
+  }
+};
+
+// This is just boilerplate that wraps the standard floating point arithmetic.
+// A macro isn't the nicest solution, but it beats rewriting these repeatedly.
+#define BASE_FLOAT_ARITHMETIC_OPS(NAME, OP)                              \
+  template <typename T, typename U>                                      \
+  struct Checked##NAME##Op<                                              \
+      T, U,                                                              \
+      typename std::enable_if<std::is_floating_point<T>::value ||        \
+                              std::is_floating_point<U>::value>::type> { \
+    using result_type = typename MaxExponentPromotion<T, U>::type;       \
+    template <typename V>                                                \
+    static constexpr bool Do(T x, U y, V* result) {                      \
+      using Promotion = typename MaxExponentPromotion<T, U>::type;       \
+      Promotion presult = x OP y;                                        \
+      *result = static_cast<V>(presult);                                 \
+      return IsValueInRangeForNumericType<V>(presult);                   \
+    }                                                                    \
+  };
+
+BASE_FLOAT_ARITHMETIC_OPS(Add, +)
+BASE_FLOAT_ARITHMETIC_OPS(Sub, -)
+BASE_FLOAT_ARITHMETIC_OPS(Mul, *)
+BASE_FLOAT_ARITHMETIC_OPS(Div, /)
+
+#undef BASE_FLOAT_ARITHMETIC_OPS
+
+// Floats carry around their validity state with them, but integers do not. So,
+// we wrap the underlying value in a specialization in order to hide that detail
+// and expose an interface via accessors.
+enum NumericRepresentation {
+  NUMERIC_INTEGER,
+  NUMERIC_FLOATING,
+  NUMERIC_UNKNOWN
+};
+
+template <typename NumericType>
+struct GetNumericRepresentation {
+  static const NumericRepresentation value =
+      std::is_integral<NumericType>::value
+          ? NUMERIC_INTEGER
+          : (std::is_floating_point<NumericType>::value ? NUMERIC_FLOATING
+                                                        : NUMERIC_UNKNOWN);
+};
+
+template <typename T,
+          NumericRepresentation type = GetNumericRepresentation<T>::value>
+class CheckedNumericState {};
+
+// Integrals require quite a bit of additional housekeeping to manage state.
+template <typename T>
+class CheckedNumericState<T, NUMERIC_INTEGER> {
+ private:
+  // is_valid_ precedes value_ because member intializers in the constructors
+  // are evaluated in field order, and is_valid_ must be read when initializing
+  // value_.
+  bool is_valid_;
+  T value_;
+
+  // Ensures that a type conversion does not trigger undefined behavior.
+  template <typename Src>
+  static constexpr T WellDefinedConversionOrZero(const Src value,
+                                                 const bool is_valid) {
+    using SrcType = typename internal::UnderlyingType<Src>::type;
+    return (std::is_integral<SrcType>::value || is_valid)
+               ? static_cast<T>(value)
+               : static_cast<T>(0);
+  }
+
+ public:
+  template <typename Src, NumericRepresentation type>
+  friend class CheckedNumericState;
+
+  constexpr CheckedNumericState() : is_valid_(true), value_(0) {}
+
+  template <typename Src>
+  constexpr CheckedNumericState(Src value, bool is_valid)
+      : is_valid_(is_valid && IsValueInRangeForNumericType<T>(value)),
+        value_(WellDefinedConversionOrZero(value, is_valid_)) {
+    static_assert(std::is_arithmetic<Src>::value, "Argument must be numeric.");
+  }
+
+  // Copy constructor.
+  template <typename Src>
+  constexpr CheckedNumericState(const CheckedNumericState<Src>& rhs)
+      : is_valid_(rhs.IsValid()),
+        value_(WellDefinedConversionOrZero(rhs.value(), is_valid_)) {}
+
+  template <typename Src>
+  constexpr explicit CheckedNumericState(Src value)
+      : is_valid_(IsValueInRangeForNumericType<T>(value)),
+        value_(WellDefinedConversionOrZero(value, is_valid_)) {}
+
+  constexpr bool is_valid() const { return is_valid_; }
+  constexpr T value() const { return value_; }
+};
+
+// Floating points maintain their own validity, but need translation wrappers.
+template <typename T>
+class CheckedNumericState<T, NUMERIC_FLOATING> {
+ private:
+  T value_;
+
+  // Ensures that a type conversion does not trigger undefined behavior.
+  template <typename Src>
+  static constexpr T WellDefinedConversionOrNaN(const Src value,
+                                                const bool is_valid) {
+    using SrcType = typename internal::UnderlyingType<Src>::type;
+    return (StaticDstRangeRelationToSrcRange<T, SrcType>::value ==
+                NUMERIC_RANGE_CONTAINED ||
+            is_valid)
+               ? static_cast<T>(value)
+               : std::numeric_limits<T>::quiet_NaN();
+  }
+
+ public:
+  template <typename Src, NumericRepresentation type>
+  friend class CheckedNumericState;
+
+  constexpr CheckedNumericState() : value_(0.0) {}
+
+  template <typename Src>
+  constexpr CheckedNumericState(Src value, bool is_valid)
+      : value_(WellDefinedConversionOrNaN(value, is_valid)) {}
+
+  template <typename Src>
+  constexpr explicit CheckedNumericState(Src value)
+      : value_(WellDefinedConversionOrNaN(
+            value,
+            IsValueInRangeForNumericType<T>(value))) {}
+
+  // Copy constructor.
+  template <typename Src>
+  constexpr CheckedNumericState(const CheckedNumericState<Src>& rhs)
+      : value_(WellDefinedConversionOrNaN(
+            rhs.value(),
+            rhs.is_valid() && IsValueInRangeForNumericType<T>(rhs.value()))) {}
+
+  constexpr bool is_valid() const {
+    // Written this way because std::isfinite is not reliably constexpr.
+    return MustTreatAsConstexpr(value_)
+               ? value_ <= std::numeric_limits<T>::max() &&
+                     value_ >= std::numeric_limits<T>::lowest()
+               : std::isfinite(value_);
+  }
+  constexpr T value() const { return value_; }
+};
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_NUMERICS_CHECKED_MATH_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/clamped_math.h b/native/zucchini/vendor/libchrome/base/numerics/clamped_math.h
new file mode 100644
index 0000000..b184363
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/numerics/clamped_math.h
@@ -0,0 +1,262 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_NUMERICS_CLAMPED_MATH_H_
+#define BASE_NUMERICS_CLAMPED_MATH_H_
+
+#include <stddef.h>
+
+#include <limits>
+#include <type_traits>
+
+#include "base/numerics/clamped_math_impl.h"
+
+namespace base {
+namespace internal {
+
+template <typename T>
+class ClampedNumeric {
+  static_assert(std::is_arithmetic<T>::value,
+                "ClampedNumeric<T>: T must be a numeric type.");
+
+ public:
+  using type = T;
+
+  constexpr ClampedNumeric() : value_(0) {}
+
+  // Copy constructor.
+  template <typename Src>
+  constexpr ClampedNumeric(const ClampedNumeric<Src>& rhs)
+      : value_(saturated_cast<T>(rhs.value_)) {}
+
+  template <typename Src>
+  friend class ClampedNumeric;
+
+  // This is not an explicit constructor because we implicitly upgrade regular
+  // numerics to ClampedNumerics to make them easier to use.
+  template <typename Src>
+  constexpr ClampedNumeric(Src value)  // NOLINT(runtime/explicit)
+      : value_(saturated_cast<T>(value)) {
+    static_assert(std::is_arithmetic<Src>::value, "Argument must be numeric.");
+  }
+
+  // This is not an explicit constructor because we want a seamless conversion
+  // from StrictNumeric types.
+  template <typename Src>
+  constexpr ClampedNumeric(
+      StrictNumeric<Src> value)  // NOLINT(runtime/explicit)
+      : value_(saturated_cast<T>(static_cast<Src>(value))) {}
+
+  // Returns a ClampedNumeric of the specified type, cast from the current
+  // ClampedNumeric, and saturated to the destination type.
+  template <typename Dst>
+  constexpr ClampedNumeric<typename UnderlyingType<Dst>::type> Cast() const {
+    return *this;
+  }
+
+  // Prototypes for the supported arithmetic operator overloads.
+  template <typename Src>
+  constexpr ClampedNumeric& operator+=(const Src rhs);
+  template <typename Src>
+  constexpr ClampedNumeric& operator-=(const Src rhs);
+  template <typename Src>
+  constexpr ClampedNumeric& operator*=(const Src rhs);
+  template <typename Src>
+  constexpr ClampedNumeric& operator/=(const Src rhs);
+  template <typename Src>
+  constexpr ClampedNumeric& operator%=(const Src rhs);
+  template <typename Src>
+  constexpr ClampedNumeric& operator<<=(const Src rhs);
+  template <typename Src>
+  constexpr ClampedNumeric& operator>>=(const Src rhs);
+  template <typename Src>
+  constexpr ClampedNumeric& operator&=(const Src rhs);
+  template <typename Src>
+  constexpr ClampedNumeric& operator|=(const Src rhs);
+  template <typename Src>
+  constexpr ClampedNumeric& operator^=(const Src rhs);
+
+  constexpr ClampedNumeric operator-() const {
+    // The negation of two's complement int min is int min, so that's the
+    // only overflow case where we will saturate.
+    return ClampedNumeric<T>(SaturatedNegWrapper(value_));
+  }
+
+  constexpr ClampedNumeric operator~() const {
+    return ClampedNumeric<decltype(InvertWrapper(T()))>(InvertWrapper(value_));
+  }
+
+  constexpr ClampedNumeric Abs() const {
+    // The negation of two's complement int min is int min, so that's the
+    // only overflow case where we will saturate.
+    return ClampedNumeric<T>(SaturatedAbsWrapper(value_));
+  }
+
+  template <typename U>
+  constexpr ClampedNumeric<typename MathWrapper<ClampedMaxOp, T, U>::type> Max(
+      const U rhs) const {
+    using result_type = typename MathWrapper<ClampedMaxOp, T, U>::type;
+    return ClampedNumeric<result_type>(
+        ClampedMaxOp<T, U>::Do(value_, Wrapper<U>::value(rhs)));
+  }
+
+  template <typename U>
+  constexpr ClampedNumeric<typename MathWrapper<ClampedMinOp, T, U>::type> Min(
+      const U rhs) const {
+    using result_type = typename MathWrapper<ClampedMinOp, T, U>::type;
+    return ClampedNumeric<result_type>(
+        ClampedMinOp<T, U>::Do(value_, Wrapper<U>::value(rhs)));
+  }
+
+  // This function is available only for integral types. It returns an unsigned
+  // integer of the same width as the source type, containing the absolute value
+  // of the source, and properly handling signed min.
+  constexpr ClampedNumeric<typename UnsignedOrFloatForSize<T>::type>
+  UnsignedAbs() const {
+    return ClampedNumeric<typename UnsignedOrFloatForSize<T>::type>(
+        SafeUnsignedAbs(value_));
+  }
+
+  constexpr ClampedNumeric& operator++() {
+    *this += 1;
+    return *this;
+  }
+
+  constexpr ClampedNumeric operator++(int) {
+    ClampedNumeric value = *this;
+    *this += 1;
+    return value;
+  }
+
+  constexpr ClampedNumeric& operator--() {
+    *this -= 1;
+    return *this;
+  }
+
+  constexpr ClampedNumeric operator--(int) {
+    ClampedNumeric value = *this;
+    *this -= 1;
+    return value;
+  }
+
+  // These perform the actual math operations on the ClampedNumerics.
+  // Binary arithmetic operations.
+  template <template <typename, typename, typename> class M,
+            typename L,
+            typename R>
+  static constexpr ClampedNumeric MathOp(const L lhs, const R rhs) {
+    using Math = typename MathWrapper<M, L, R>::math;
+    return ClampedNumeric<T>(
+        Math::template Do<T>(Wrapper<L>::value(lhs), Wrapper<R>::value(rhs)));
+  }
+
+  // Assignment arithmetic operations.
+  template <template <typename, typename, typename> class M, typename R>
+  constexpr ClampedNumeric& MathOp(const R rhs) {
+    using Math = typename MathWrapper<M, T, R>::math;
+    *this =
+        ClampedNumeric<T>(Math::template Do<T>(value_, Wrapper<R>::value(rhs)));
+    return *this;
+  }
+
+  template <typename Dst>
+  constexpr operator Dst() const {
+    return saturated_cast<typename ArithmeticOrUnderlyingEnum<Dst>::type>(
+        value_);
+  }
+
+  // This method extracts the raw integer value without saturating it to the
+  // destination type as the conversion operator does. This is useful when
+  // e.g. assigning to an auto type or passing as a deduced template parameter.
+  constexpr T RawValue() const { return value_; }
+
+ private:
+  T value_;
+
+  // These wrappers allow us to handle state the same way for both
+  // ClampedNumeric and POD arithmetic types.
+  template <typename Src>
+  struct Wrapper {
+    static constexpr Src value(Src value) {
+      return static_cast<typename UnderlyingType<Src>::type>(value);
+    }
+  };
+};
+
+// Convience wrapper to return a new ClampedNumeric from the provided arithmetic
+// or ClampedNumericType.
+template <typename T>
+constexpr ClampedNumeric<typename UnderlyingType<T>::type> MakeClampedNum(
+    const T value) {
+  return value;
+}
+
+// Overload the ostream output operator to make logging work nicely.
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const ClampedNumeric<T>& value) {
+  os << static_cast<T>(value);
+  return os;
+}
+
+// These implement the variadic wrapper for the math operations.
+template <template <typename, typename, typename> class M,
+          typename L,
+          typename R>
+constexpr ClampedNumeric<typename MathWrapper<M, L, R>::type> ClampMathOp(
+    const L lhs,
+    const R rhs) {
+  using Math = typename MathWrapper<M, L, R>::math;
+  return ClampedNumeric<typename Math::result_type>::template MathOp<M>(lhs,
+                                                                        rhs);
+}
+
+// General purpose wrapper template for arithmetic operations.
+template <template <typename, typename, typename> class M,
+          typename L,
+          typename R,
+          typename... Args>
+constexpr ClampedNumeric<typename ResultType<M, L, R, Args...>::type>
+ClampMathOp(const L lhs, const R rhs, const Args... args) {
+  return ClampMathOp<M>(ClampMathOp<M>(lhs, rhs), args...);
+}
+
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Add, +, +=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Sub, -, -=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Mul, *, *=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Div, /, /=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Mod, %, %=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Lsh, <<, <<=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Rsh, >>, >>=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, And, &, &=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Or, |, |=)
+BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Xor, ^, ^=)
+BASE_NUMERIC_ARITHMETIC_VARIADIC(Clamped, Clamp, Max)
+BASE_NUMERIC_ARITHMETIC_VARIADIC(Clamped, Clamp, Min)
+BASE_NUMERIC_COMPARISON_OPERATORS(Clamped, IsLess, <);
+BASE_NUMERIC_COMPARISON_OPERATORS(Clamped, IsLessOrEqual, <=);
+BASE_NUMERIC_COMPARISON_OPERATORS(Clamped, IsGreater, >);
+BASE_NUMERIC_COMPARISON_OPERATORS(Clamped, IsGreaterOrEqual, >=);
+BASE_NUMERIC_COMPARISON_OPERATORS(Clamped, IsEqual, ==);
+BASE_NUMERIC_COMPARISON_OPERATORS(Clamped, IsNotEqual, !=);
+
+}  // namespace internal
+
+using internal::ClampedNumeric;
+using internal::MakeClampedNum;
+using internal::ClampMax;
+using internal::ClampMin;
+using internal::ClampAdd;
+using internal::ClampSub;
+using internal::ClampMul;
+using internal::ClampDiv;
+using internal::ClampMod;
+using internal::ClampLsh;
+using internal::ClampRsh;
+using internal::ClampAnd;
+using internal::ClampOr;
+using internal::ClampXor;
+
+}  // namespace base
+
+#endif  // BASE_NUMERICS_CLAMPED_MATH_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/clamped_math_impl.h b/native/zucchini/vendor/libchrome/base/numerics/clamped_math_impl.h
new file mode 100644
index 0000000..303a7e9
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/numerics/clamped_math_impl.h
@@ -0,0 +1,341 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_NUMERICS_CLAMPED_MATH_IMPL_H_
+#define BASE_NUMERICS_CLAMPED_MATH_IMPL_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <climits>
+#include <cmath>
+#include <cstdlib>
+#include <limits>
+#include <type_traits>
+
+#include "base/numerics/checked_math.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/numerics/safe_math_shared_impl.h"
+
+namespace base {
+namespace internal {
+
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value &&
+                                  std::is_signed<T>::value>::type* = nullptr>
+constexpr T SaturatedNegWrapper(T value) {
+  return MustTreatAsConstexpr(value) || !ClampedNegFastOp<T>::is_supported
+             ? (NegateWrapper(value) != std::numeric_limits<T>::lowest()
+                    ? NegateWrapper(value)
+                    : std::numeric_limits<T>::max())
+             : ClampedNegFastOp<T>::Do(value);
+}
+
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value &&
+                                  !std::is_signed<T>::value>::type* = nullptr>
+constexpr T SaturatedNegWrapper(T value) {
+  return T(0);
+}
+
+template <
+    typename T,
+    typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
+constexpr T SaturatedNegWrapper(T value) {
+  return -value;
+}
+
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+constexpr T SaturatedAbsWrapper(T value) {
+  // The calculation below is a static identity for unsigned types, but for
+  // signed integer types it provides a non-branching, saturated absolute value.
+  // This works because SafeUnsignedAbs() returns an unsigned type, which can
+  // represent the absolute value of all negative numbers of an equal-width
+  // integer type. The call to IsValueNegative() then detects overflow in the
+  // special case of numeric_limits<T>::min(), by evaluating the bit pattern as
+  // a signed integer value. If it is the overflow case, we end up subtracting
+  // one from the unsigned result, thus saturating to numeric_limits<T>::max().
+  return static_cast<T>(SafeUnsignedAbs(value) -
+                        IsValueNegative<T>(SafeUnsignedAbs(value)));
+}
+
+template <
+    typename T,
+    typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
+constexpr T SaturatedAbsWrapper(T value) {
+  return value < 0 ? -value : value;
+}
+
+template <typename T, typename U, class Enable = void>
+struct ClampedAddOp {};
+
+template <typename T, typename U>
+struct ClampedAddOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename MaxExponentPromotion<T, U>::type;
+  template <typename V = result_type>
+  static constexpr V Do(T x, U y) {
+    if (ClampedAddFastOp<T, U>::is_supported)
+      return ClampedAddFastOp<T, U>::template Do<V>(x, y);
+
+    static_assert(std::is_same<V, result_type>::value ||
+                      IsTypeInRangeForNumericType<U, V>::value,
+                  "The saturation result cannot be determined from the "
+                  "provided types.");
+    const V saturated = CommonMaxOrMin<V>(IsValueNegative(y));
+    V result = {};
+    return BASE_NUMERICS_LIKELY((CheckedAddOp<T, U>::Do(x, y, &result)))
+               ? result
+               : saturated;
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct ClampedSubOp {};
+
+template <typename T, typename U>
+struct ClampedSubOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename MaxExponentPromotion<T, U>::type;
+  template <typename V = result_type>
+  static constexpr V Do(T x, U y) {
+    // TODO(jschuh) Make this "constexpr if" once we're C++17.
+    if (ClampedSubFastOp<T, U>::is_supported)
+      return ClampedSubFastOp<T, U>::template Do<V>(x, y);
+
+    static_assert(std::is_same<V, result_type>::value ||
+                      IsTypeInRangeForNumericType<U, V>::value,
+                  "The saturation result cannot be determined from the "
+                  "provided types.");
+    const V saturated = CommonMaxOrMin<V>(!IsValueNegative(y));
+    V result = {};
+    return BASE_NUMERICS_LIKELY((CheckedSubOp<T, U>::Do(x, y, &result)))
+               ? result
+               : saturated;
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct ClampedMulOp {};
+
+template <typename T, typename U>
+struct ClampedMulOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename MaxExponentPromotion<T, U>::type;
+  template <typename V = result_type>
+  static constexpr V Do(T x, U y) {
+    // TODO(jschuh) Make this "constexpr if" once we're C++17.
+    if (ClampedMulFastOp<T, U>::is_supported)
+      return ClampedMulFastOp<T, U>::template Do<V>(x, y);
+
+    V result = {};
+    const V saturated =
+        CommonMaxOrMin<V>(IsValueNegative(x) ^ IsValueNegative(y));
+    return BASE_NUMERICS_LIKELY((CheckedMulOp<T, U>::Do(x, y, &result)))
+               ? result
+               : saturated;
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct ClampedDivOp {};
+
+template <typename T, typename U>
+struct ClampedDivOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename MaxExponentPromotion<T, U>::type;
+  template <typename V = result_type>
+  static constexpr V Do(T x, U y) {
+    V result = {};
+    if (BASE_NUMERICS_LIKELY((CheckedDivOp<T, U>::Do(x, y, &result))))
+      return result;
+    // Saturation goes to max, min, or NaN (if x is zero).
+    return x ? CommonMaxOrMin<V>(IsValueNegative(x) ^ IsValueNegative(y))
+             : SaturationDefaultLimits<V>::NaN();
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct ClampedModOp {};
+
+template <typename T, typename U>
+struct ClampedModOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename MaxExponentPromotion<T, U>::type;
+  template <typename V = result_type>
+  static constexpr V Do(T x, U y) {
+    V result = {};
+    return BASE_NUMERICS_LIKELY((CheckedModOp<T, U>::Do(x, y, &result)))
+               ? result
+               : x;
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct ClampedLshOp {};
+
+// Left shift. Non-zero values saturate in the direction of the sign. A zero
+// shifted by any value always results in zero.
+template <typename T, typename U>
+struct ClampedLshOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = T;
+  template <typename V = result_type>
+  static constexpr V Do(T x, U shift) {
+    static_assert(!std::is_signed<U>::value, "Shift value must be unsigned.");
+    if (BASE_NUMERICS_LIKELY(shift < std::numeric_limits<T>::digits)) {
+      // Shift as unsigned to avoid undefined behavior.
+      V result = static_cast<V>(as_unsigned(x) << shift);
+      // If the shift can be reversed, we know it was valid.
+      if (BASE_NUMERICS_LIKELY(result >> shift == x))
+        return result;
+    }
+    return x ? CommonMaxOrMin<V>(IsValueNegative(x)) : 0;
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct ClampedRshOp {};
+
+// Right shift. Negative values saturate to -1. Positive or 0 saturates to 0.
+template <typename T, typename U>
+struct ClampedRshOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = T;
+  template <typename V = result_type>
+  static constexpr V Do(T x, U shift) {
+    static_assert(!std::is_signed<U>::value, "Shift value must be unsigned.");
+    // Signed right shift is odd, because it saturates to -1 or 0.
+    const V saturated = as_unsigned(V(0)) - IsValueNegative(x);
+    return BASE_NUMERICS_LIKELY(shift < IntegerBitsPlusSign<T>::value)
+               ? saturated_cast<V>(x >> shift)
+               : saturated;
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct ClampedAndOp {};
+
+template <typename T, typename U>
+struct ClampedAndOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename std::make_unsigned<
+      typename MaxExponentPromotion<T, U>::type>::type;
+  template <typename V>
+  static constexpr V Do(T x, U y) {
+    return static_cast<result_type>(x) & static_cast<result_type>(y);
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct ClampedOrOp {};
+
+// For simplicity we promote to unsigned integers.
+template <typename T, typename U>
+struct ClampedOrOp<T,
+                   U,
+                   typename std::enable_if<std::is_integral<T>::value &&
+                                           std::is_integral<U>::value>::type> {
+  using result_type = typename std::make_unsigned<
+      typename MaxExponentPromotion<T, U>::type>::type;
+  template <typename V>
+  static constexpr V Do(T x, U y) {
+    return static_cast<result_type>(x) | static_cast<result_type>(y);
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct ClampedXorOp {};
+
+// For simplicity we support only unsigned integers.
+template <typename T, typename U>
+struct ClampedXorOp<T,
+                    U,
+                    typename std::enable_if<std::is_integral<T>::value &&
+                                            std::is_integral<U>::value>::type> {
+  using result_type = typename std::make_unsigned<
+      typename MaxExponentPromotion<T, U>::type>::type;
+  template <typename V>
+  static constexpr V Do(T x, U y) {
+    return static_cast<result_type>(x) ^ static_cast<result_type>(y);
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct ClampedMaxOp {};
+
+template <typename T, typename U>
+struct ClampedMaxOp<
+    T,
+    U,
+    typename std::enable_if<std::is_arithmetic<T>::value &&
+                            std::is_arithmetic<U>::value>::type> {
+  using result_type = typename MaxExponentPromotion<T, U>::type;
+  template <typename V = result_type>
+  static constexpr V Do(T x, U y) {
+    return IsGreater<T, U>::Test(x, y) ? saturated_cast<V>(x)
+                                       : saturated_cast<V>(y);
+  }
+};
+
+template <typename T, typename U, class Enable = void>
+struct ClampedMinOp {};
+
+template <typename T, typename U>
+struct ClampedMinOp<
+    T,
+    U,
+    typename std::enable_if<std::is_arithmetic<T>::value &&
+                            std::is_arithmetic<U>::value>::type> {
+  using result_type = typename LowestValuePromotion<T, U>::type;
+  template <typename V = result_type>
+  static constexpr V Do(T x, U y) {
+    return IsLess<T, U>::Test(x, y) ? saturated_cast<V>(x)
+                                    : saturated_cast<V>(y);
+  }
+};
+
+// This is just boilerplate that wraps the standard floating point arithmetic.
+// A macro isn't the nicest solution, but it beats rewriting these repeatedly.
+#define BASE_FLOAT_ARITHMETIC_OPS(NAME, OP)                              \
+  template <typename T, typename U>                                      \
+  struct Clamped##NAME##Op<                                              \
+      T, U,                                                              \
+      typename std::enable_if<std::is_floating_point<T>::value ||        \
+                              std::is_floating_point<U>::value>::type> { \
+    using result_type = typename MaxExponentPromotion<T, U>::type;       \
+    template <typename V = result_type>                                  \
+    static constexpr V Do(T x, U y) {                                    \
+      return saturated_cast<V>(x OP y);                                  \
+    }                                                                    \
+  };
+
+BASE_FLOAT_ARITHMETIC_OPS(Add, +)
+BASE_FLOAT_ARITHMETIC_OPS(Sub, -)
+BASE_FLOAT_ARITHMETIC_OPS(Mul, *)
+BASE_FLOAT_ARITHMETIC_OPS(Div, /)
+
+#undef BASE_FLOAT_ARITHMETIC_OPS
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_NUMERICS_CLAMPED_MATH_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/safe_conversions.h b/native/zucchini/vendor/libchrome/base/numerics/safe_conversions.h
new file mode 100644
index 0000000..9284f8f
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/numerics/safe_conversions.h
@@ -0,0 +1,344 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_NUMERICS_SAFE_CONVERSIONS_H_
+#define BASE_NUMERICS_SAFE_CONVERSIONS_H_
+
+#include <stddef.h>
+
+#include <limits>
+#include <ostream>
+#include <type_traits>
+
+#include "base/numerics/safe_conversions_impl.h"
+
+#if !defined(__native_client__) && (defined(__ARMEL__) || defined(__arch64__))
+#include "base/numerics/safe_conversions_arm_impl.h"
+#define BASE_HAS_OPTIMIZED_SAFE_CONVERSIONS (1)
+#else
+#define BASE_HAS_OPTIMIZED_SAFE_CONVERSIONS (0)
+#endif
+
+namespace base {
+namespace internal {
+
+#if !BASE_HAS_OPTIMIZED_SAFE_CONVERSIONS
+template <typename Dst, typename Src>
+struct SaturateFastAsmOp {
+  static const bool is_supported = false;
+  static constexpr Dst Do(Src) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<Dst>();
+  }
+};
+#endif  // BASE_HAS_OPTIMIZED_SAFE_CONVERSIONS
+#undef BASE_HAS_OPTIMIZED_SAFE_CONVERSIONS
+
+// The following special case a few specific integer conversions where we can
+// eke out better performance than range checking.
+template <typename Dst, typename Src, typename Enable = void>
+struct IsValueInRangeFastOp {
+  static const bool is_supported = false;
+  static constexpr bool Do(Src value) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<bool>();
+  }
+};
+
+// Signed to signed range comparison.
+template <typename Dst, typename Src>
+struct IsValueInRangeFastOp<
+    Dst,
+    Src,
+    typename std::enable_if<
+        std::is_integral<Dst>::value && std::is_integral<Src>::value &&
+        std::is_signed<Dst>::value && std::is_signed<Src>::value &&
+        !IsTypeInRangeForNumericType<Dst, Src>::value>::type> {
+  static const bool is_supported = true;
+
+  static constexpr bool Do(Src value) {
+    // Just downcast to the smaller type, sign extend it back to the original
+    // type, and then see if it matches the original value.
+    return value == static_cast<Dst>(value);
+  }
+};
+
+// Signed to unsigned range comparison.
+template <typename Dst, typename Src>
+struct IsValueInRangeFastOp<
+    Dst,
+    Src,
+    typename std::enable_if<
+        std::is_integral<Dst>::value && std::is_integral<Src>::value &&
+        !std::is_signed<Dst>::value && std::is_signed<Src>::value &&
+        !IsTypeInRangeForNumericType<Dst, Src>::value>::type> {
+  static const bool is_supported = true;
+
+  static constexpr bool Do(Src value) {
+    // We cast a signed as unsigned to overflow negative values to the top,
+    // then compare against whichever maximum is smaller, as our upper bound.
+    return as_unsigned(value) <= as_unsigned(CommonMax<Src, Dst>());
+  }
+};
+
+// Convenience function that returns true if the supplied value is in range
+// for the destination type.
+template <typename Dst, typename Src>
+constexpr bool IsValueInRangeForNumericType(Src value) {
+  using SrcType = typename internal::UnderlyingType<Src>::type;
+  return internal::IsValueInRangeFastOp<Dst, SrcType>::is_supported
+             ? internal::IsValueInRangeFastOp<Dst, SrcType>::Do(
+                   static_cast<SrcType>(value))
+             : internal::DstRangeRelationToSrcRange<Dst>(
+                   static_cast<SrcType>(value))
+                   .IsValid();
+}
+
+// checked_cast<> is analogous to static_cast<> for numeric types,
+// except that it CHECKs that the specified numeric conversion will not
+// overflow or underflow. NaN source will always trigger a CHECK.
+template <typename Dst,
+          class CheckHandler = internal::CheckOnFailure,
+          typename Src>
+constexpr Dst checked_cast(Src value) {
+  // This throws a compile-time error on evaluating the constexpr if it can be
+  // determined at compile-time as failing, otherwise it will CHECK at runtime.
+  using SrcType = typename internal::UnderlyingType<Src>::type;
+  return BASE_NUMERICS_LIKELY((IsValueInRangeForNumericType<Dst>(value)))
+             ? static_cast<Dst>(static_cast<SrcType>(value))
+             : CheckHandler::template HandleFailure<Dst>();
+}
+
+// Default boundaries for integral/float: max/infinity, lowest/-infinity, 0/NaN.
+// You may provide your own limits (e.g. to saturated_cast) so long as you
+// implement all of the static constexpr member functions in the class below.
+template <typename T>
+struct SaturationDefaultLimits : public std::numeric_limits<T> {
+  static constexpr T NaN() {
+    return std::numeric_limits<T>::has_quiet_NaN
+               ? std::numeric_limits<T>::quiet_NaN()
+               : T();
+  }
+  using std::numeric_limits<T>::max;
+  static constexpr T Overflow() {
+    return std::numeric_limits<T>::has_infinity
+               ? std::numeric_limits<T>::infinity()
+               : std::numeric_limits<T>::max();
+  }
+  using std::numeric_limits<T>::lowest;
+  static constexpr T Underflow() {
+    return std::numeric_limits<T>::has_infinity
+               ? std::numeric_limits<T>::infinity() * -1
+               : std::numeric_limits<T>::lowest();
+  }
+};
+
+template <typename Dst, template <typename> class S, typename Src>
+constexpr Dst saturated_cast_impl(Src value, RangeCheck constraint) {
+  // For some reason clang generates much better code when the branch is
+  // structured exactly this way, rather than a sequence of checks.
+  return !constraint.IsOverflowFlagSet()
+             ? (!constraint.IsUnderflowFlagSet() ? static_cast<Dst>(value)
+                                                 : S<Dst>::Underflow())
+             // Skip this check for integral Src, which cannot be NaN.
+             : (std::is_integral<Src>::value || !constraint.IsUnderflowFlagSet()
+                    ? S<Dst>::Overflow()
+                    : S<Dst>::NaN());
+}
+
+// We can reduce the number of conditions and get slightly better performance
+// for normal signed and unsigned integer ranges. And in the specific case of
+// Arm, we can use the optimized saturation instructions.
+template <typename Dst, typename Src, typename Enable = void>
+struct SaturateFastOp {
+  static const bool is_supported = false;
+  static constexpr Dst Do(Src value) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<Dst>();
+  }
+};
+
+template <typename Dst, typename Src>
+struct SaturateFastOp<
+    Dst,
+    Src,
+    typename std::enable_if<std::is_integral<Src>::value &&
+                            std::is_integral<Dst>::value>::type> {
+  static const bool is_supported = true;
+  static Dst Do(Src value) {
+    if (SaturateFastAsmOp<Dst, Src>::is_supported)
+      return SaturateFastAsmOp<Dst, Src>::Do(value);
+
+    // The exact order of the following is structured to hit the correct
+    // optimization heuristics across compilers. Do not change without
+    // checking the emitted code.
+    Dst saturated = CommonMaxOrMin<Dst, Src>(
+        IsMaxInRangeForNumericType<Dst, Src>() ||
+        (!IsMinInRangeForNumericType<Dst, Src>() && IsValueNegative(value)));
+    return BASE_NUMERICS_LIKELY(IsValueInRangeForNumericType<Dst>(value))
+               ? static_cast<Dst>(value)
+               : saturated;
+  }
+};
+
+// saturated_cast<> is analogous to static_cast<> for numeric types, except
+// that the specified numeric conversion will saturate by default rather than
+// overflow or underflow, and NaN assignment to an integral will return 0.
+// All boundary condition behaviors can be overriden with a custom handler.
+template <typename Dst,
+          template <typename> class SaturationHandler = SaturationDefaultLimits,
+          typename Src>
+constexpr Dst saturated_cast(Src value) {
+  using SrcType = typename UnderlyingType<Src>::type;
+  return !IsCompileTimeConstant(value) &&
+                 SaturateFastOp<Dst, SrcType>::is_supported &&
+                 std::is_same<SaturationHandler<Dst>,
+                              SaturationDefaultLimits<Dst>>::value
+             ? SaturateFastOp<Dst, SrcType>::Do(static_cast<SrcType>(value))
+             : saturated_cast_impl<Dst, SaturationHandler, SrcType>(
+                   static_cast<SrcType>(value),
+                   DstRangeRelationToSrcRange<Dst, SaturationHandler, SrcType>(
+                       static_cast<SrcType>(value)));
+}
+
+// strict_cast<> is analogous to static_cast<> for numeric types, except that
+// it will cause a compile failure if the destination type is not large enough
+// to contain any value in the source type. It performs no runtime checking.
+template <typename Dst, typename Src>
+constexpr Dst strict_cast(Src value) {
+  using SrcType = typename UnderlyingType<Src>::type;
+  static_assert(UnderlyingType<Src>::is_numeric, "Argument must be numeric.");
+  static_assert(std::is_arithmetic<Dst>::value, "Result must be numeric.");
+
+  // If you got here from a compiler error, it's because you tried to assign
+  // from a source type to a destination type that has insufficient range.
+  // The solution may be to change the destination type you're assigning to,
+  // and use one large enough to represent the source.
+  // Alternatively, you may be better served with the checked_cast<> or
+  // saturated_cast<> template functions for your particular use case.
+  static_assert(StaticDstRangeRelationToSrcRange<Dst, SrcType>::value ==
+                    NUMERIC_RANGE_CONTAINED,
+                "The source type is out of range for the destination type. "
+                "Please see strict_cast<> comments for more information.");
+
+  return static_cast<Dst>(static_cast<SrcType>(value));
+}
+
+// Some wrappers to statically check that a type is in range.
+template <typename Dst, typename Src, class Enable = void>
+struct IsNumericRangeContained {
+  static const bool value = false;
+};
+
+template <typename Dst, typename Src>
+struct IsNumericRangeContained<
+    Dst,
+    Src,
+    typename std::enable_if<ArithmeticOrUnderlyingEnum<Dst>::value &&
+                            ArithmeticOrUnderlyingEnum<Src>::value>::type> {
+  static const bool value = StaticDstRangeRelationToSrcRange<Dst, Src>::value ==
+                            NUMERIC_RANGE_CONTAINED;
+};
+
+// StrictNumeric implements compile time range checking between numeric types by
+// wrapping assignment operations in a strict_cast. This class is intended to be
+// used for function arguments and return types, to ensure the destination type
+// can always contain the source type. This is essentially the same as enforcing
+// -Wconversion in gcc and C4302 warnings on MSVC, but it can be applied
+// incrementally at API boundaries, making it easier to convert code so that it
+// compiles cleanly with truncation warnings enabled.
+// This template should introduce no runtime overhead, but it also provides no
+// runtime checking of any of the associated mathematical operations. Use
+// CheckedNumeric for runtime range checks of the actual value being assigned.
+template <typename T>
+class StrictNumeric {
+ public:
+  using type = T;
+
+  constexpr StrictNumeric() : value_(0) {}
+
+  // Copy constructor.
+  template <typename Src>
+  constexpr StrictNumeric(const StrictNumeric<Src>& rhs)
+      : value_(strict_cast<T>(rhs.value_)) {}
+
+  // This is not an explicit constructor because we implicitly upgrade regular
+  // numerics to StrictNumerics to make them easier to use.
+  template <typename Src>
+  constexpr StrictNumeric(Src value)  // NOLINT(runtime/explicit)
+      : value_(strict_cast<T>(value)) {}
+
+  // If you got here from a compiler error, it's because you tried to assign
+  // from a source type to a destination type that has insufficient range.
+  // The solution may be to change the destination type you're assigning to,
+  // and use one large enough to represent the source.
+  // If you're assigning from a CheckedNumeric<> class, you may be able to use
+  // the AssignIfValid() member function, specify a narrower destination type to
+  // the member value functions (e.g. val.template ValueOrDie<Dst>()), use one
+  // of the value helper functions (e.g. ValueOrDieForType<Dst>(val)).
+  // If you've encountered an _ambiguous overload_ you can use a static_cast<>
+  // to explicitly cast the result to the destination type.
+  // If none of that works, you may be better served with the checked_cast<> or
+  // saturated_cast<> template functions for your particular use case.
+  template <typename Dst,
+            typename std::enable_if<
+                IsNumericRangeContained<Dst, T>::value>::type* = nullptr>
+  constexpr operator Dst() const {
+    return static_cast<typename ArithmeticOrUnderlyingEnum<Dst>::type>(value_);
+  }
+
+ private:
+  const T value_;
+};
+
+// Convience wrapper returns a StrictNumeric from the provided arithmetic type.
+template <typename T>
+constexpr StrictNumeric<typename UnderlyingType<T>::type> MakeStrictNum(
+    const T value) {
+  return value;
+}
+
+// Overload the ostream output operator to make logging work nicely.
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const StrictNumeric<T>& value) {
+  os << static_cast<T>(value);
+  return os;
+}
+
+#define BASE_NUMERIC_COMPARISON_OPERATORS(CLASS, NAME, OP)              \
+  template <typename L, typename R,                                     \
+            typename std::enable_if<                                    \
+                internal::Is##CLASS##Op<L, R>::value>::type* = nullptr> \
+  constexpr bool operator OP(const L lhs, const R rhs) {                \
+    return SafeCompare<NAME, typename UnderlyingType<L>::type,          \
+                       typename UnderlyingType<R>::type>(lhs, rhs);     \
+  }
+
+BASE_NUMERIC_COMPARISON_OPERATORS(Strict, IsLess, <);
+BASE_NUMERIC_COMPARISON_OPERATORS(Strict, IsLessOrEqual, <=);
+BASE_NUMERIC_COMPARISON_OPERATORS(Strict, IsGreater, >);
+BASE_NUMERIC_COMPARISON_OPERATORS(Strict, IsGreaterOrEqual, >=);
+BASE_NUMERIC_COMPARISON_OPERATORS(Strict, IsEqual, ==);
+BASE_NUMERIC_COMPARISON_OPERATORS(Strict, IsNotEqual, !=);
+
+};  // namespace internal
+
+using internal::as_signed;
+using internal::as_unsigned;
+using internal::checked_cast;
+using internal::strict_cast;
+using internal::saturated_cast;
+using internal::SafeUnsignedAbs;
+using internal::StrictNumeric;
+using internal::MakeStrictNum;
+using internal::IsValueInRangeForNumericType;
+using internal::IsTypeInRangeForNumericType;
+using internal::IsValueNegative;
+
+// Explicitly make a shorter size_t alias for convenience.
+using SizeT = StrictNumeric<size_t>;
+
+}  // namespace base
+
+#endif  // BASE_NUMERICS_SAFE_CONVERSIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/safe_conversions_impl.h b/native/zucchini/vendor/libchrome/base/numerics/safe_conversions_impl.h
new file mode 100644
index 0000000..2516204
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/numerics/safe_conversions_impl.h
@@ -0,0 +1,850 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_
+#define BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_
+
+#include <stdint.h>
+
+#include <limits>
+#include <type_traits>
+
+#if defined(__GNUC__) || defined(__clang__)
+#define BASE_NUMERICS_LIKELY(x) __builtin_expect(!!(x), 1)
+#define BASE_NUMERICS_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+#define BASE_NUMERICS_LIKELY(x) (x)
+#define BASE_NUMERICS_UNLIKELY(x) (x)
+#endif
+
+namespace base {
+namespace internal {
+
+// The std library doesn't provide a binary max_exponent for integers, however
+// we can compute an analog using std::numeric_limits<>::digits.
+template <typename NumericType>
+struct MaxExponent {
+  static const int value = std::is_floating_point<NumericType>::value
+                               ? std::numeric_limits<NumericType>::max_exponent
+                               : std::numeric_limits<NumericType>::digits + 1;
+};
+
+// The number of bits (including the sign) in an integer. Eliminates sizeof
+// hacks.
+template <typename NumericType>
+struct IntegerBitsPlusSign {
+  static const int value = std::numeric_limits<NumericType>::digits +
+                           std::is_signed<NumericType>::value;
+};
+
+// Helper templates for integer manipulations.
+
+template <typename Integer>
+struct PositionOfSignBit {
+  static const size_t value = IntegerBitsPlusSign<Integer>::value - 1;
+};
+
+// Determines if a numeric value is negative without throwing compiler
+// warnings on: unsigned(value) < 0.
+template <typename T,
+          typename std::enable_if<std::is_signed<T>::value>::type* = nullptr>
+constexpr bool IsValueNegative(T value) {
+  static_assert(std::is_arithmetic<T>::value, "Argument must be numeric.");
+  return value < 0;
+}
+
+template <typename T,
+          typename std::enable_if<!std::is_signed<T>::value>::type* = nullptr>
+constexpr bool IsValueNegative(T) {
+  static_assert(std::is_arithmetic<T>::value, "Argument must be numeric.");
+  return false;
+}
+
+// This performs a fast negation, returning a signed value. It works on unsigned
+// arguments, but probably doesn't do what you want for any unsigned value
+// larger than max / 2 + 1 (i.e. signed min cast to unsigned).
+template <typename T>
+constexpr typename std::make_signed<T>::type ConditionalNegate(
+    T x,
+    bool is_negative) {
+  static_assert(std::is_integral<T>::value, "Type must be integral");
+  using SignedT = typename std::make_signed<T>::type;
+  using UnsignedT = typename std::make_unsigned<T>::type;
+  return static_cast<SignedT>(
+      (static_cast<UnsignedT>(x) ^ -SignedT(is_negative)) + is_negative);
+}
+
+// This performs a safe, absolute value via unsigned overflow.
+template <typename T>
+constexpr typename std::make_unsigned<T>::type SafeUnsignedAbs(T value) {
+  static_assert(std::is_integral<T>::value, "Type must be integral");
+  using UnsignedT = typename std::make_unsigned<T>::type;
+  return IsValueNegative(value) ? 0 - static_cast<UnsignedT>(value)
+                                : static_cast<UnsignedT>(value);
+}
+
+// This allows us to switch paths on known compile-time constants.
+#if defined(__clang__) || defined(__GNUC__)
+constexpr bool CanDetectCompileTimeConstant() {
+  return true;
+}
+template <typename T>
+constexpr bool IsCompileTimeConstant(const T v) {
+  return __builtin_constant_p(v);
+}
+#else
+constexpr bool CanDetectCompileTimeConstant() {
+  return false;
+}
+template <typename T>
+constexpr bool IsCompileTimeConstant(const T) {
+  return false;
+}
+#endif
+template <typename T>
+constexpr bool MustTreatAsConstexpr(const T v) {
+  // Either we can't detect a compile-time constant, and must always use the
+  // constexpr path, or we know we have a compile-time constant.
+  return !CanDetectCompileTimeConstant() || IsCompileTimeConstant(v);
+}
+
+// Forces a crash, like a CHECK(false). Used for numeric boundary errors.
+// Also used in a constexpr template to trigger a compilation failure on
+// an error condition.
+struct CheckOnFailure {
+  template <typename T>
+  static T HandleFailure() {
+#if defined(_MSC_VER)
+    __debugbreak();
+#elif defined(__GNUC__) || defined(__clang__)
+    __builtin_trap();
+#else
+    ((void)(*(volatile char*)0 = 0));
+#endif
+    return T();
+  }
+};
+
+enum IntegerRepresentation {
+  INTEGER_REPRESENTATION_UNSIGNED,
+  INTEGER_REPRESENTATION_SIGNED
+};
+
+// A range for a given nunmeric Src type is contained for a given numeric Dst
+// type if both numeric_limits<Src>::max() <= numeric_limits<Dst>::max() and
+// numeric_limits<Src>::lowest() >= numeric_limits<Dst>::lowest() are true.
+// We implement this as template specializations rather than simple static
+// comparisons to ensure type correctness in our comparisons.
+enum NumericRangeRepresentation {
+  NUMERIC_RANGE_NOT_CONTAINED,
+  NUMERIC_RANGE_CONTAINED
+};
+
+// Helper templates to statically determine if our destination type can contain
+// maximum and minimum values represented by the source type.
+
+template <typename Dst,
+          typename Src,
+          IntegerRepresentation DstSign = std::is_signed<Dst>::value
+                                              ? INTEGER_REPRESENTATION_SIGNED
+                                              : INTEGER_REPRESENTATION_UNSIGNED,
+          IntegerRepresentation SrcSign = std::is_signed<Src>::value
+                                              ? INTEGER_REPRESENTATION_SIGNED
+                                              : INTEGER_REPRESENTATION_UNSIGNED>
+struct StaticDstRangeRelationToSrcRange;
+
+// Same sign: Dst is guaranteed to contain Src only if its range is equal or
+// larger.
+template <typename Dst, typename Src, IntegerRepresentation Sign>
+struct StaticDstRangeRelationToSrcRange<Dst, Src, Sign, Sign> {
+  static const NumericRangeRepresentation value =
+      MaxExponent<Dst>::value >= MaxExponent<Src>::value
+          ? NUMERIC_RANGE_CONTAINED
+          : NUMERIC_RANGE_NOT_CONTAINED;
+};
+
+// Unsigned to signed: Dst is guaranteed to contain source only if its range is
+// larger.
+template <typename Dst, typename Src>
+struct StaticDstRangeRelationToSrcRange<Dst,
+                                        Src,
+                                        INTEGER_REPRESENTATION_SIGNED,
+                                        INTEGER_REPRESENTATION_UNSIGNED> {
+  static const NumericRangeRepresentation value =
+      MaxExponent<Dst>::value > MaxExponent<Src>::value
+          ? NUMERIC_RANGE_CONTAINED
+          : NUMERIC_RANGE_NOT_CONTAINED;
+};
+
+// Signed to unsigned: Dst cannot be statically determined to contain Src.
+template <typename Dst, typename Src>
+struct StaticDstRangeRelationToSrcRange<Dst,
+                                        Src,
+                                        INTEGER_REPRESENTATION_UNSIGNED,
+                                        INTEGER_REPRESENTATION_SIGNED> {
+  static const NumericRangeRepresentation value = NUMERIC_RANGE_NOT_CONTAINED;
+};
+
+// This class wraps the range constraints as separate booleans so the compiler
+// can identify constants and eliminate unused code paths.
+class RangeCheck {
+ public:
+  constexpr RangeCheck(bool is_in_lower_bound, bool is_in_upper_bound)
+      : is_underflow_(!is_in_lower_bound), is_overflow_(!is_in_upper_bound) {}
+  constexpr RangeCheck() : is_underflow_(0), is_overflow_(0) {}
+  constexpr bool IsValid() const { return !is_overflow_ && !is_underflow_; }
+  constexpr bool IsInvalid() const { return is_overflow_ && is_underflow_; }
+  constexpr bool IsOverflow() const { return is_overflow_ && !is_underflow_; }
+  constexpr bool IsUnderflow() const { return !is_overflow_ && is_underflow_; }
+  constexpr bool IsOverflowFlagSet() const { return is_overflow_; }
+  constexpr bool IsUnderflowFlagSet() const { return is_underflow_; }
+  constexpr bool operator==(const RangeCheck rhs) const {
+    return is_underflow_ == rhs.is_underflow_ &&
+           is_overflow_ == rhs.is_overflow_;
+  }
+  constexpr bool operator!=(const RangeCheck rhs) const {
+    return !(*this == rhs);
+  }
+
+ private:
+  // Do not change the order of these member variables. The integral conversion
+  // optimization depends on this exact order.
+  const bool is_underflow_;
+  const bool is_overflow_;
+};
+
+// The following helper template addresses a corner case in range checks for
+// conversion from a floating-point type to an integral type of smaller range
+// but larger precision (e.g. float -> unsigned). The problem is as follows:
+//   1. Integral maximum is always one less than a power of two, so it must be
+//      truncated to fit the mantissa of the floating point. The direction of
+//      rounding is implementation defined, but by default it's always IEEE
+//      floats, which round to nearest and thus result in a value of larger
+//      magnitude than the integral value.
+//      Example: float f = UINT_MAX; // f is 4294967296f but UINT_MAX
+//                                   // is 4294967295u.
+//   2. If the floating point value is equal to the promoted integral maximum
+//      value, a range check will erroneously pass.
+//      Example: (4294967296f <= 4294967295u) // This is true due to a precision
+//                                            // loss in rounding up to float.
+//   3. When the floating point value is then converted to an integral, the
+//      resulting value is out of range for the target integral type and
+//      thus is implementation defined.
+//      Example: unsigned u = (float)INT_MAX; // u will typically overflow to 0.
+// To fix this bug we manually truncate the maximum value when the destination
+// type is an integral of larger precision than the source floating-point type,
+// such that the resulting maximum is represented exactly as a floating point.
+template <typename Dst, typename Src, template <typename> class Bounds>
+struct NarrowingRange {
+  using SrcLimits = std::numeric_limits<Src>;
+  using DstLimits = typename std::numeric_limits<Dst>;
+
+  // Computes the mask required to make an accurate comparison between types.
+  static const int kShift =
+      (MaxExponent<Src>::value > MaxExponent<Dst>::value &&
+       SrcLimits::digits < DstLimits::digits)
+          ? (DstLimits::digits - SrcLimits::digits)
+          : 0;
+  template <
+      typename T,
+      typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+
+  // Masks out the integer bits that are beyond the precision of the
+  // intermediate type used for comparison.
+  static constexpr T Adjust(T value) {
+    static_assert(std::is_same<T, Dst>::value, "");
+    static_assert(kShift < DstLimits::digits, "");
+    return static_cast<T>(
+        ConditionalNegate(SafeUnsignedAbs(value) & ~((T(1) << kShift) - T(1)),
+                          IsValueNegative(value)));
+  }
+
+  template <typename T,
+            typename std::enable_if<std::is_floating_point<T>::value>::type* =
+                nullptr>
+  static constexpr T Adjust(T value) {
+    static_assert(std::is_same<T, Dst>::value, "");
+    static_assert(kShift == 0, "");
+    return value;
+  }
+
+  static constexpr Dst max() { return Adjust(Bounds<Dst>::max()); }
+  static constexpr Dst lowest() { return Adjust(Bounds<Dst>::lowest()); }
+};
+
+template <typename Dst,
+          typename Src,
+          template <typename> class Bounds,
+          IntegerRepresentation DstSign = std::is_signed<Dst>::value
+                                              ? INTEGER_REPRESENTATION_SIGNED
+                                              : INTEGER_REPRESENTATION_UNSIGNED,
+          IntegerRepresentation SrcSign = std::is_signed<Src>::value
+                                              ? INTEGER_REPRESENTATION_SIGNED
+                                              : INTEGER_REPRESENTATION_UNSIGNED,
+          NumericRangeRepresentation DstRange =
+              StaticDstRangeRelationToSrcRange<Dst, Src>::value>
+struct DstRangeRelationToSrcRangeImpl;
+
+// The following templates are for ranges that must be verified at runtime. We
+// split it into checks based on signedness to avoid confusing casts and
+// compiler warnings on signed an unsigned comparisons.
+
+// Same sign narrowing: The range is contained for normal limits.
+template <typename Dst,
+          typename Src,
+          template <typename> class Bounds,
+          IntegerRepresentation DstSign,
+          IntegerRepresentation SrcSign>
+struct DstRangeRelationToSrcRangeImpl<Dst,
+                                      Src,
+                                      Bounds,
+                                      DstSign,
+                                      SrcSign,
+                                      NUMERIC_RANGE_CONTAINED> {
+  static constexpr RangeCheck Check(Src value) {
+    using SrcLimits = std::numeric_limits<Src>;
+    using DstLimits = NarrowingRange<Dst, Src, Bounds>;
+    return RangeCheck(
+        static_cast<Dst>(SrcLimits::lowest()) >= DstLimits::lowest() ||
+            static_cast<Dst>(value) >= DstLimits::lowest(),
+        static_cast<Dst>(SrcLimits::max()) <= DstLimits::max() ||
+            static_cast<Dst>(value) <= DstLimits::max());
+  }
+};
+
+// Signed to signed narrowing: Both the upper and lower boundaries may be
+// exceeded for standard limits.
+template <typename Dst, typename Src, template <typename> class Bounds>
+struct DstRangeRelationToSrcRangeImpl<Dst,
+                                      Src,
+                                      Bounds,
+                                      INTEGER_REPRESENTATION_SIGNED,
+                                      INTEGER_REPRESENTATION_SIGNED,
+                                      NUMERIC_RANGE_NOT_CONTAINED> {
+  static constexpr RangeCheck Check(Src value) {
+    using DstLimits = NarrowingRange<Dst, Src, Bounds>;
+    return RangeCheck(value >= DstLimits::lowest(), value <= DstLimits::max());
+  }
+};
+
+// Unsigned to unsigned narrowing: Only the upper bound can be exceeded for
+// standard limits.
+template <typename Dst, typename Src, template <typename> class Bounds>
+struct DstRangeRelationToSrcRangeImpl<Dst,
+                                      Src,
+                                      Bounds,
+                                      INTEGER_REPRESENTATION_UNSIGNED,
+                                      INTEGER_REPRESENTATION_UNSIGNED,
+                                      NUMERIC_RANGE_NOT_CONTAINED> {
+  static constexpr RangeCheck Check(Src value) {
+    using DstLimits = NarrowingRange<Dst, Src, Bounds>;
+    return RangeCheck(
+        DstLimits::lowest() == Dst(0) || value >= DstLimits::lowest(),
+        value <= DstLimits::max());
+  }
+};
+
+// Unsigned to signed: Only the upper bound can be exceeded for standard limits.
+template <typename Dst, typename Src, template <typename> class Bounds>
+struct DstRangeRelationToSrcRangeImpl<Dst,
+                                      Src,
+                                      Bounds,
+                                      INTEGER_REPRESENTATION_SIGNED,
+                                      INTEGER_REPRESENTATION_UNSIGNED,
+                                      NUMERIC_RANGE_NOT_CONTAINED> {
+  static constexpr RangeCheck Check(Src value) {
+    using DstLimits = NarrowingRange<Dst, Src, Bounds>;
+    using Promotion = decltype(Src() + Dst());
+    return RangeCheck(DstLimits::lowest() <= Dst(0) ||
+                          static_cast<Promotion>(value) >=
+                              static_cast<Promotion>(DstLimits::lowest()),
+                      static_cast<Promotion>(value) <=
+                          static_cast<Promotion>(DstLimits::max()));
+  }
+};
+
+// Signed to unsigned: The upper boundary may be exceeded for a narrower Dst,
+// and any negative value exceeds the lower boundary for standard limits.
+template <typename Dst, typename Src, template <typename> class Bounds>
+struct DstRangeRelationToSrcRangeImpl<Dst,
+                                      Src,
+                                      Bounds,
+                                      INTEGER_REPRESENTATION_UNSIGNED,
+                                      INTEGER_REPRESENTATION_SIGNED,
+                                      NUMERIC_RANGE_NOT_CONTAINED> {
+  static constexpr RangeCheck Check(Src value) {
+    using SrcLimits = std::numeric_limits<Src>;
+    using DstLimits = NarrowingRange<Dst, Src, Bounds>;
+    using Promotion = decltype(Src() + Dst());
+    return RangeCheck(
+        value >= Src(0) && (DstLimits::lowest() == 0 ||
+                            static_cast<Dst>(value) >= DstLimits::lowest()),
+        static_cast<Promotion>(SrcLimits::max()) <=
+                static_cast<Promotion>(DstLimits::max()) ||
+            static_cast<Promotion>(value) <=
+                static_cast<Promotion>(DstLimits::max()));
+  }
+};
+
+// Simple wrapper for statically checking if a type's range is contained.
+template <typename Dst, typename Src>
+struct IsTypeInRangeForNumericType {
+  static const bool value = StaticDstRangeRelationToSrcRange<Dst, Src>::value ==
+                            NUMERIC_RANGE_CONTAINED;
+};
+
+template <typename Dst,
+          template <typename> class Bounds = std::numeric_limits,
+          typename Src>
+constexpr RangeCheck DstRangeRelationToSrcRange(Src value) {
+  static_assert(std::is_arithmetic<Src>::value, "Argument must be numeric.");
+  static_assert(std::is_arithmetic<Dst>::value, "Result must be numeric.");
+  static_assert(Bounds<Dst>::lowest() < Bounds<Dst>::max(), "");
+  return DstRangeRelationToSrcRangeImpl<Dst, Src, Bounds>::Check(value);
+}
+
+// Integer promotion templates used by the portable checked integer arithmetic.
+template <size_t Size, bool IsSigned>
+struct IntegerForDigitsAndSign;
+
+#define INTEGER_FOR_DIGITS_AND_SIGN(I)                          \
+  template <>                                                   \
+  struct IntegerForDigitsAndSign<IntegerBitsPlusSign<I>::value, \
+                                 std::is_signed<I>::value> {    \
+    using type = I;                                             \
+  }
+
+INTEGER_FOR_DIGITS_AND_SIGN(int8_t);
+INTEGER_FOR_DIGITS_AND_SIGN(uint8_t);
+INTEGER_FOR_DIGITS_AND_SIGN(int16_t);
+INTEGER_FOR_DIGITS_AND_SIGN(uint16_t);
+INTEGER_FOR_DIGITS_AND_SIGN(int32_t);
+INTEGER_FOR_DIGITS_AND_SIGN(uint32_t);
+INTEGER_FOR_DIGITS_AND_SIGN(int64_t);
+INTEGER_FOR_DIGITS_AND_SIGN(uint64_t);
+#undef INTEGER_FOR_DIGITS_AND_SIGN
+
+// WARNING: We have no IntegerForSizeAndSign<16, *>. If we ever add one to
+// support 128-bit math, then the ArithmeticPromotion template below will need
+// to be updated (or more likely replaced with a decltype expression).
+static_assert(IntegerBitsPlusSign<intmax_t>::value == 64,
+              "Max integer size not supported for this toolchain.");
+
+template <typename Integer, bool IsSigned = std::is_signed<Integer>::value>
+struct TwiceWiderInteger {
+  using type =
+      typename IntegerForDigitsAndSign<IntegerBitsPlusSign<Integer>::value * 2,
+                                       IsSigned>::type;
+};
+
+enum ArithmeticPromotionCategory {
+  LEFT_PROMOTION,  // Use the type of the left-hand argument.
+  RIGHT_PROMOTION  // Use the type of the right-hand argument.
+};
+
+// Determines the type that can represent the largest positive value.
+template <typename Lhs,
+          typename Rhs,
+          ArithmeticPromotionCategory Promotion =
+              (MaxExponent<Lhs>::value > MaxExponent<Rhs>::value)
+                  ? LEFT_PROMOTION
+                  : RIGHT_PROMOTION>
+struct MaxExponentPromotion;
+
+template <typename Lhs, typename Rhs>
+struct MaxExponentPromotion<Lhs, Rhs, LEFT_PROMOTION> {
+  using type = Lhs;
+};
+
+template <typename Lhs, typename Rhs>
+struct MaxExponentPromotion<Lhs, Rhs, RIGHT_PROMOTION> {
+  using type = Rhs;
+};
+
+// Determines the type that can represent the lowest arithmetic value.
+template <typename Lhs,
+          typename Rhs,
+          ArithmeticPromotionCategory Promotion =
+              std::is_signed<Lhs>::value
+                  ? (std::is_signed<Rhs>::value
+                         ? (MaxExponent<Lhs>::value > MaxExponent<Rhs>::value
+                                ? LEFT_PROMOTION
+                                : RIGHT_PROMOTION)
+                         : LEFT_PROMOTION)
+                  : (std::is_signed<Rhs>::value
+                         ? RIGHT_PROMOTION
+                         : (MaxExponent<Lhs>::value < MaxExponent<Rhs>::value
+                                ? LEFT_PROMOTION
+                                : RIGHT_PROMOTION))>
+struct LowestValuePromotion;
+
+template <typename Lhs, typename Rhs>
+struct LowestValuePromotion<Lhs, Rhs, LEFT_PROMOTION> {
+  using type = Lhs;
+};
+
+template <typename Lhs, typename Rhs>
+struct LowestValuePromotion<Lhs, Rhs, RIGHT_PROMOTION> {
+  using type = Rhs;
+};
+
+// Determines the type that is best able to represent an arithmetic result.
+template <
+    typename Lhs,
+    typename Rhs = Lhs,
+    bool is_intmax_type =
+        std::is_integral<typename MaxExponentPromotion<Lhs, Rhs>::type>::value&&
+            IntegerBitsPlusSign<typename MaxExponentPromotion<Lhs, Rhs>::type>::
+                value == IntegerBitsPlusSign<intmax_t>::value,
+    bool is_max_exponent =
+        StaticDstRangeRelationToSrcRange<
+            typename MaxExponentPromotion<Lhs, Rhs>::type,
+            Lhs>::value ==
+        NUMERIC_RANGE_CONTAINED&& StaticDstRangeRelationToSrcRange<
+            typename MaxExponentPromotion<Lhs, Rhs>::type,
+            Rhs>::value == NUMERIC_RANGE_CONTAINED>
+struct BigEnoughPromotion;
+
+// The side with the max exponent is big enough.
+template <typename Lhs, typename Rhs, bool is_intmax_type>
+struct BigEnoughPromotion<Lhs, Rhs, is_intmax_type, true> {
+  using type = typename MaxExponentPromotion<Lhs, Rhs>::type;
+  static const bool is_contained = true;
+};
+
+// We can use a twice wider type to fit.
+template <typename Lhs, typename Rhs>
+struct BigEnoughPromotion<Lhs, Rhs, false, false> {
+  using type =
+      typename TwiceWiderInteger<typename MaxExponentPromotion<Lhs, Rhs>::type,
+                                 std::is_signed<Lhs>::value ||
+                                     std::is_signed<Rhs>::value>::type;
+  static const bool is_contained = true;
+};
+
+// No type is large enough.
+template <typename Lhs, typename Rhs>
+struct BigEnoughPromotion<Lhs, Rhs, true, false> {
+  using type = typename MaxExponentPromotion<Lhs, Rhs>::type;
+  static const bool is_contained = false;
+};
+
+// We can statically check if operations on the provided types can wrap, so we
+// can skip the checked operations if they're not needed. So, for an integer we
+// care if the destination type preserves the sign and is twice the width of
+// the source.
+template <typename T, typename Lhs, typename Rhs = Lhs>
+struct IsIntegerArithmeticSafe {
+  static const bool value =
+      !std::is_floating_point<T>::value &&
+      !std::is_floating_point<Lhs>::value &&
+      !std::is_floating_point<Rhs>::value &&
+      std::is_signed<T>::value >= std::is_signed<Lhs>::value &&
+      IntegerBitsPlusSign<T>::value >= (2 * IntegerBitsPlusSign<Lhs>::value) &&
+      std::is_signed<T>::value >= std::is_signed<Rhs>::value &&
+      IntegerBitsPlusSign<T>::value >= (2 * IntegerBitsPlusSign<Rhs>::value);
+};
+
+// Promotes to a type that can represent any possible result of a binary
+// arithmetic operation with the source types.
+template <typename Lhs,
+          typename Rhs,
+          bool is_promotion_possible = IsIntegerArithmeticSafe<
+              typename std::conditional<std::is_signed<Lhs>::value ||
+                                            std::is_signed<Rhs>::value,
+                                        intmax_t,
+                                        uintmax_t>::type,
+              typename MaxExponentPromotion<Lhs, Rhs>::type>::value>
+struct FastIntegerArithmeticPromotion;
+
+template <typename Lhs, typename Rhs>
+struct FastIntegerArithmeticPromotion<Lhs, Rhs, true> {
+  using type =
+      typename TwiceWiderInteger<typename MaxExponentPromotion<Lhs, Rhs>::type,
+                                 std::is_signed<Lhs>::value ||
+                                     std::is_signed<Rhs>::value>::type;
+  static_assert(IsIntegerArithmeticSafe<type, Lhs, Rhs>::value, "");
+  static const bool is_contained = true;
+};
+
+template <typename Lhs, typename Rhs>
+struct FastIntegerArithmeticPromotion<Lhs, Rhs, false> {
+  using type = typename BigEnoughPromotion<Lhs, Rhs>::type;
+  static const bool is_contained = false;
+};
+
+// Extracts the underlying type from an enum.
+template <typename T, bool is_enum = std::is_enum<T>::value>
+struct ArithmeticOrUnderlyingEnum;
+
+template <typename T>
+struct ArithmeticOrUnderlyingEnum<T, true> {
+  using type = typename std::underlying_type<T>::type;
+  static const bool value = std::is_arithmetic<type>::value;
+};
+
+template <typename T>
+struct ArithmeticOrUnderlyingEnum<T, false> {
+  using type = T;
+  static const bool value = std::is_arithmetic<type>::value;
+};
+
+// The following are helper templates used in the CheckedNumeric class.
+template <typename T>
+class CheckedNumeric;
+
+template <typename T>
+class ClampedNumeric;
+
+template <typename T>
+class StrictNumeric;
+
+// Used to treat CheckedNumeric and arithmetic underlying types the same.
+template <typename T>
+struct UnderlyingType {
+  using type = typename ArithmeticOrUnderlyingEnum<T>::type;
+  static const bool is_numeric = std::is_arithmetic<type>::value;
+  static const bool is_checked = false;
+  static const bool is_clamped = false;
+  static const bool is_strict = false;
+};
+
+template <typename T>
+struct UnderlyingType<CheckedNumeric<T>> {
+  using type = T;
+  static const bool is_numeric = true;
+  static const bool is_checked = true;
+  static const bool is_clamped = false;
+  static const bool is_strict = false;
+};
+
+template <typename T>
+struct UnderlyingType<ClampedNumeric<T>> {
+  using type = T;
+  static const bool is_numeric = true;
+  static const bool is_checked = false;
+  static const bool is_clamped = true;
+  static const bool is_strict = false;
+};
+
+template <typename T>
+struct UnderlyingType<StrictNumeric<T>> {
+  using type = T;
+  static const bool is_numeric = true;
+  static const bool is_checked = false;
+  static const bool is_clamped = false;
+  static const bool is_strict = true;
+};
+
+template <typename L, typename R>
+struct IsCheckedOp {
+  static const bool value =
+      UnderlyingType<L>::is_numeric && UnderlyingType<R>::is_numeric &&
+      (UnderlyingType<L>::is_checked || UnderlyingType<R>::is_checked);
+};
+
+template <typename L, typename R>
+struct IsClampedOp {
+  static const bool value =
+      UnderlyingType<L>::is_numeric && UnderlyingType<R>::is_numeric &&
+      (UnderlyingType<L>::is_clamped || UnderlyingType<R>::is_clamped) &&
+      !(UnderlyingType<L>::is_checked || UnderlyingType<R>::is_checked);
+};
+
+template <typename L, typename R>
+struct IsStrictOp {
+  static const bool value =
+      UnderlyingType<L>::is_numeric && UnderlyingType<R>::is_numeric &&
+      (UnderlyingType<L>::is_strict || UnderlyingType<R>::is_strict) &&
+      !(UnderlyingType<L>::is_checked || UnderlyingType<R>::is_checked) &&
+      !(UnderlyingType<L>::is_clamped || UnderlyingType<R>::is_clamped);
+};
+
+// as_signed<> returns the supplied integral value (or integral castable
+// Numeric template) cast as a signed integral of equivalent precision.
+// I.e. it's mostly an alias for: static_cast<std::make_signed<T>::type>(t)
+template <typename Src>
+constexpr typename std::make_signed<
+    typename base::internal::UnderlyingType<Src>::type>::type
+as_signed(const Src value) {
+  static_assert(std::is_integral<decltype(as_signed(value))>::value,
+                "Argument must be a signed or unsigned integer type.");
+  return static_cast<decltype(as_signed(value))>(value);
+}
+
+// as_unsigned<> returns the supplied integral value (or integral castable
+// Numeric template) cast as an unsigned integral of equivalent precision.
+// I.e. it's mostly an alias for: static_cast<std::make_unsigned<T>::type>(t)
+template <typename Src>
+constexpr typename std::make_unsigned<
+    typename base::internal::UnderlyingType<Src>::type>::type
+as_unsigned(const Src value) {
+  static_assert(std::is_integral<decltype(as_unsigned(value))>::value,
+                "Argument must be a signed or unsigned integer type.");
+  return static_cast<decltype(as_unsigned(value))>(value);
+}
+
+template <typename L, typename R>
+constexpr bool IsLessImpl(const L lhs,
+                          const R rhs,
+                          const RangeCheck l_range,
+                          const RangeCheck r_range) {
+  return l_range.IsUnderflow() || r_range.IsOverflow() ||
+         (l_range == r_range &&
+          static_cast<decltype(lhs + rhs)>(lhs) <
+              static_cast<decltype(lhs + rhs)>(rhs));
+}
+
+template <typename L, typename R>
+struct IsLess {
+  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
+                "Types must be numeric.");
+  static constexpr bool Test(const L lhs, const R rhs) {
+    return IsLessImpl(lhs, rhs, DstRangeRelationToSrcRange<R>(lhs),
+                      DstRangeRelationToSrcRange<L>(rhs));
+  }
+};
+
+template <typename L, typename R>
+constexpr bool IsLessOrEqualImpl(const L lhs,
+                                 const R rhs,
+                                 const RangeCheck l_range,
+                                 const RangeCheck r_range) {
+  return l_range.IsUnderflow() || r_range.IsOverflow() ||
+         (l_range == r_range &&
+          static_cast<decltype(lhs + rhs)>(lhs) <=
+              static_cast<decltype(lhs + rhs)>(rhs));
+}
+
+template <typename L, typename R>
+struct IsLessOrEqual {
+  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
+                "Types must be numeric.");
+  static constexpr bool Test(const L lhs, const R rhs) {
+    return IsLessOrEqualImpl(lhs, rhs, DstRangeRelationToSrcRange<R>(lhs),
+                             DstRangeRelationToSrcRange<L>(rhs));
+  }
+};
+
+template <typename L, typename R>
+constexpr bool IsGreaterImpl(const L lhs,
+                             const R rhs,
+                             const RangeCheck l_range,
+                             const RangeCheck r_range) {
+  return l_range.IsOverflow() || r_range.IsUnderflow() ||
+         (l_range == r_range &&
+          static_cast<decltype(lhs + rhs)>(lhs) >
+              static_cast<decltype(lhs + rhs)>(rhs));
+}
+
+template <typename L, typename R>
+struct IsGreater {
+  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
+                "Types must be numeric.");
+  static constexpr bool Test(const L lhs, const R rhs) {
+    return IsGreaterImpl(lhs, rhs, DstRangeRelationToSrcRange<R>(lhs),
+                         DstRangeRelationToSrcRange<L>(rhs));
+  }
+};
+
+template <typename L, typename R>
+constexpr bool IsGreaterOrEqualImpl(const L lhs,
+                                    const R rhs,
+                                    const RangeCheck l_range,
+                                    const RangeCheck r_range) {
+  return l_range.IsOverflow() || r_range.IsUnderflow() ||
+         (l_range == r_range &&
+          static_cast<decltype(lhs + rhs)>(lhs) >=
+              static_cast<decltype(lhs + rhs)>(rhs));
+}
+
+template <typename L, typename R>
+struct IsGreaterOrEqual {
+  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
+                "Types must be numeric.");
+  static constexpr bool Test(const L lhs, const R rhs) {
+    return IsGreaterOrEqualImpl(lhs, rhs, DstRangeRelationToSrcRange<R>(lhs),
+                                DstRangeRelationToSrcRange<L>(rhs));
+  }
+};
+
+template <typename L, typename R>
+struct IsEqual {
+  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
+                "Types must be numeric.");
+  static constexpr bool Test(const L lhs, const R rhs) {
+    return DstRangeRelationToSrcRange<R>(lhs) ==
+               DstRangeRelationToSrcRange<L>(rhs) &&
+           static_cast<decltype(lhs + rhs)>(lhs) ==
+               static_cast<decltype(lhs + rhs)>(rhs);
+  }
+};
+
+template <typename L, typename R>
+struct IsNotEqual {
+  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
+                "Types must be numeric.");
+  static constexpr bool Test(const L lhs, const R rhs) {
+    return DstRangeRelationToSrcRange<R>(lhs) !=
+               DstRangeRelationToSrcRange<L>(rhs) ||
+           static_cast<decltype(lhs + rhs)>(lhs) !=
+               static_cast<decltype(lhs + rhs)>(rhs);
+  }
+};
+
+// These perform the actual math operations on the CheckedNumerics.
+// Binary arithmetic operations.
+template <template <typename, typename> class C, typename L, typename R>
+constexpr bool SafeCompare(const L lhs, const R rhs) {
+  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
+                "Types must be numeric.");
+  using Promotion = BigEnoughPromotion<L, R>;
+  using BigType = typename Promotion::type;
+  return Promotion::is_contained
+             // Force to a larger type for speed if both are contained.
+             ? C<BigType, BigType>::Test(
+                   static_cast<BigType>(static_cast<L>(lhs)),
+                   static_cast<BigType>(static_cast<R>(rhs)))
+             // Let the template functions figure it out for mixed types.
+             : C<L, R>::Test(lhs, rhs);
+}
+
+template <typename Dst, typename Src>
+constexpr bool IsMaxInRangeForNumericType() {
+  return IsGreaterOrEqual<Dst, Src>::Test(std::numeric_limits<Dst>::max(),
+                                          std::numeric_limits<Src>::max());
+}
+
+template <typename Dst, typename Src>
+constexpr bool IsMinInRangeForNumericType() {
+  return IsLessOrEqual<Dst, Src>::Test(std::numeric_limits<Dst>::lowest(),
+                                       std::numeric_limits<Src>::lowest());
+}
+
+template <typename Dst, typename Src>
+constexpr Dst CommonMax() {
+  return !IsMaxInRangeForNumericType<Dst, Src>()
+             ? Dst(std::numeric_limits<Dst>::max())
+             : Dst(std::numeric_limits<Src>::max());
+}
+
+template <typename Dst, typename Src>
+constexpr Dst CommonMin() {
+  return !IsMinInRangeForNumericType<Dst, Src>()
+             ? Dst(std::numeric_limits<Dst>::lowest())
+             : Dst(std::numeric_limits<Src>::lowest());
+}
+
+// This is a wrapper to generate return the max or min for a supplied type.
+// If the argument is false, the returned value is the maximum. If true the
+// returned value is the minimum.
+template <typename Dst, typename Src = Dst>
+constexpr Dst CommonMaxOrMin(bool is_min) {
+  return is_min ? CommonMin<Dst, Src>() : CommonMax<Dst, Src>();
+}
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/safe_math.h b/native/zucchini/vendor/libchrome/base/numerics/safe_math.h
new file mode 100644
index 0000000..e30be90
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/numerics/safe_math.h
@@ -0,0 +1,12 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_NUMERICS_SAFE_MATH_H_
+#define BASE_NUMERICS_SAFE_MATH_H_
+
+#include "base/numerics/checked_math.h"
+#include "base/numerics/clamped_math.h"
+#include "base/numerics/safe_conversions.h"
+
+#endif  // BASE_NUMERICS_SAFE_MATH_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/safe_math_clang_gcc_impl.h b/native/zucchini/vendor/libchrome/base/numerics/safe_math_clang_gcc_impl.h
new file mode 100644
index 0000000..1760338
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/numerics/safe_math_clang_gcc_impl.h
@@ -0,0 +1,157 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_NUMERICS_SAFE_MATH_CLANG_GCC_IMPL_H_
+#define BASE_NUMERICS_SAFE_MATH_CLANG_GCC_IMPL_H_
+
+#include <cassert>
+#include <limits>
+#include <type_traits>
+
+#include "base/numerics/safe_conversions.h"
+
+#if !defined(__native_client__) && (defined(__ARMEL__) || defined(__arch64__))
+#include "base/numerics/safe_math_arm_impl.h"
+#define BASE_HAS_ASSEMBLER_SAFE_MATH (1)
+#else
+#define BASE_HAS_ASSEMBLER_SAFE_MATH (0)
+#endif
+
+namespace base {
+namespace internal {
+
+// These are the non-functioning boilerplate implementations of the optimized
+// safe math routines.
+#if !BASE_HAS_ASSEMBLER_SAFE_MATH
+template <typename T, typename U>
+struct CheckedMulFastAsmOp {
+  static const bool is_supported = false;
+  template <typename V>
+  static constexpr bool Do(T, U, V*) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<bool>();
+  }
+};
+
+template <typename T, typename U>
+struct ClampedAddFastAsmOp {
+  static const bool is_supported = false;
+  template <typename V>
+  static constexpr V Do(T, U) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<V>();
+  }
+};
+
+template <typename T, typename U>
+struct ClampedSubFastAsmOp {
+  static const bool is_supported = false;
+  template <typename V>
+  static constexpr V Do(T, U) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<V>();
+  }
+};
+
+template <typename T, typename U>
+struct ClampedMulFastAsmOp {
+  static const bool is_supported = false;
+  template <typename V>
+  static constexpr V Do(T, U) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<V>();
+  }
+};
+#endif  // BASE_HAS_ASSEMBLER_SAFE_MATH
+#undef BASE_HAS_ASSEMBLER_SAFE_MATH
+
+template <typename T, typename U>
+struct CheckedAddFastOp {
+  static const bool is_supported = true;
+  template <typename V>
+  __attribute__((always_inline)) static constexpr bool Do(T x, U y, V* result) {
+    return !__builtin_add_overflow(x, y, result);
+  }
+};
+
+template <typename T, typename U>
+struct CheckedSubFastOp {
+  static const bool is_supported = true;
+  template <typename V>
+  __attribute__((always_inline)) static constexpr bool Do(T x, U y, V* result) {
+    return !__builtin_sub_overflow(x, y, result);
+  }
+};
+
+template <typename T, typename U>
+struct CheckedMulFastOp {
+#if defined(__clang__)
+  // TODO(jschuh): Get the Clang runtime library issues sorted out so we can
+  // support full-width, mixed-sign multiply builtins.
+  // https://crbug.com/613003
+  // We can support intptr_t, uintptr_t, or a smaller common type.
+  static const bool is_supported =
+      (IsTypeInRangeForNumericType<intptr_t, T>::value &&
+       IsTypeInRangeForNumericType<intptr_t, U>::value) ||
+      (IsTypeInRangeForNumericType<uintptr_t, T>::value &&
+       IsTypeInRangeForNumericType<uintptr_t, U>::value);
+#else
+  static const bool is_supported = true;
+#endif
+  template <typename V>
+  __attribute__((always_inline)) static constexpr bool Do(T x, U y, V* result) {
+    return CheckedMulFastAsmOp<T, U>::is_supported
+               ? CheckedMulFastAsmOp<T, U>::Do(x, y, result)
+               : !__builtin_mul_overflow(x, y, result);
+  }
+};
+
+template <typename T, typename U>
+struct ClampedAddFastOp {
+  static const bool is_supported = ClampedAddFastAsmOp<T, U>::is_supported;
+  template <typename V>
+  __attribute__((always_inline)) static V Do(T x, U y) {
+    return ClampedAddFastAsmOp<T, U>::template Do<V>(x, y);
+  }
+};
+
+template <typename T, typename U>
+struct ClampedSubFastOp {
+  static const bool is_supported = ClampedSubFastAsmOp<T, U>::is_supported;
+  template <typename V>
+  __attribute__((always_inline)) static V Do(T x, U y) {
+    return ClampedSubFastAsmOp<T, U>::template Do<V>(x, y);
+  }
+};
+
+template <typename T, typename U>
+struct ClampedMulFastOp {
+  static const bool is_supported = ClampedMulFastAsmOp<T, U>::is_supported;
+  template <typename V>
+  __attribute__((always_inline)) static V Do(T x, U y) {
+    return ClampedMulFastAsmOp<T, U>::template Do<V>(x, y);
+  }
+};
+
+template <typename T>
+struct ClampedNegFastOp {
+  static const bool is_supported = std::is_signed<T>::value;
+  __attribute__((always_inline)) static T Do(T value) {
+    // Use this when there is no assembler path available.
+    if (!ClampedSubFastAsmOp<T, T>::is_supported) {
+      T result;
+      return !__builtin_sub_overflow(T(0), value, &result)
+                 ? result
+                 : std::numeric_limits<T>::max();
+    }
+
+    // Fallback to the normal subtraction path.
+    return ClampedSubFastOp<T, T>::template Do<T>(T(0), value);
+  }
+};
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_NUMERICS_SAFE_MATH_CLANG_GCC_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/safe_math_shared_impl.h b/native/zucchini/vendor/libchrome/base/numerics/safe_math_shared_impl.h
new file mode 100644
index 0000000..583c487
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/numerics/safe_math_shared_impl.h
@@ -0,0 +1,237 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_NUMERICS_SAFE_MATH_SHARED_IMPL_H_
+#define BASE_NUMERICS_SAFE_MATH_SHARED_IMPL_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <cassert>
+#include <climits>
+#include <cmath>
+#include <cstdlib>
+#include <limits>
+#include <type_traits>
+
+#include "base/numerics/safe_conversions.h"
+
+// Where available use builtin math overflow support on Clang and GCC.
+#if !defined(__native_client__) &&                         \
+    ((defined(__clang__) &&                                \
+      ((__clang_major__ > 3) ||                            \
+       (__clang_major__ == 3 && __clang_minor__ >= 4))) || \
+     (defined(__GNUC__) && __GNUC__ >= 5))
+#include "base/numerics/safe_math_clang_gcc_impl.h"
+#define BASE_HAS_OPTIMIZED_SAFE_MATH (1)
+#else
+#define BASE_HAS_OPTIMIZED_SAFE_MATH (0)
+#endif
+
+namespace base {
+namespace internal {
+
+// These are the non-functioning boilerplate implementations of the optimized
+// safe math routines.
+#if !BASE_HAS_OPTIMIZED_SAFE_MATH
+template <typename T, typename U>
+struct CheckedAddFastOp {
+  static const bool is_supported = false;
+  template <typename V>
+  static constexpr bool Do(T, U, V*) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<bool>();
+  }
+};
+
+template <typename T, typename U>
+struct CheckedSubFastOp {
+  static const bool is_supported = false;
+  template <typename V>
+  static constexpr bool Do(T, U, V*) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<bool>();
+  }
+};
+
+template <typename T, typename U>
+struct CheckedMulFastOp {
+  static const bool is_supported = false;
+  template <typename V>
+  static constexpr bool Do(T, U, V*) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<bool>();
+  }
+};
+
+template <typename T, typename U>
+struct ClampedAddFastOp {
+  static const bool is_supported = false;
+  template <typename V>
+  static constexpr V Do(T, U) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<V>();
+  }
+};
+
+template <typename T, typename U>
+struct ClampedSubFastOp {
+  static const bool is_supported = false;
+  template <typename V>
+  static constexpr V Do(T, U) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<V>();
+  }
+};
+
+template <typename T, typename U>
+struct ClampedMulFastOp {
+  static const bool is_supported = false;
+  template <typename V>
+  static constexpr V Do(T, U) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<V>();
+  }
+};
+
+template <typename T>
+struct ClampedNegFastOp {
+  static const bool is_supported = false;
+  static constexpr T Do(T) {
+    // Force a compile failure if instantiated.
+    return CheckOnFailure::template HandleFailure<T>();
+  }
+};
+#endif  // BASE_HAS_OPTIMIZED_SAFE_MATH
+#undef BASE_HAS_OPTIMIZED_SAFE_MATH
+
+// This is used for UnsignedAbs, where we need to support floating-point
+// template instantiations even though we don't actually support the operations.
+// However, there is no corresponding implementation of e.g. SafeUnsignedAbs,
+// so the float versions will not compile.
+template <typename Numeric,
+          bool IsInteger = std::is_integral<Numeric>::value,
+          bool IsFloat = std::is_floating_point<Numeric>::value>
+struct UnsignedOrFloatForSize;
+
+template <typename Numeric>
+struct UnsignedOrFloatForSize<Numeric, true, false> {
+  using type = typename std::make_unsigned<Numeric>::type;
+};
+
+template <typename Numeric>
+struct UnsignedOrFloatForSize<Numeric, false, true> {
+  using type = Numeric;
+};
+
+// Wrap the unary operations to allow SFINAE when instantiating integrals versus
+// floating points. These don't perform any overflow checking. Rather, they
+// exhibit well-defined overflow semantics and rely on the caller to detect
+// if an overflow occured.
+
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+constexpr T NegateWrapper(T value) {
+  using UnsignedT = typename std::make_unsigned<T>::type;
+  // This will compile to a NEG on Intel, and is normal negation on ARM.
+  return static_cast<T>(UnsignedT(0) - static_cast<UnsignedT>(value));
+}
+
+template <
+    typename T,
+    typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
+constexpr T NegateWrapper(T value) {
+  return -value;
+}
+
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+constexpr typename std::make_unsigned<T>::type InvertWrapper(T value) {
+  return ~value;
+}
+
+template <typename T,
+          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
+constexpr T AbsWrapper(T value) {
+  return static_cast<T>(SafeUnsignedAbs(value));
+}
+
+template <
+    typename T,
+    typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
+constexpr T AbsWrapper(T value) {
+  return value < 0 ? -value : value;
+}
+
+template <template <typename, typename, typename> class M,
+          typename L,
+          typename R>
+struct MathWrapper {
+  using math = M<typename UnderlyingType<L>::type,
+                 typename UnderlyingType<R>::type,
+                 void>;
+  using type = typename math::result_type;
+};
+
+// These variadic templates work out the return types.
+// TODO(jschuh): Rip all this out once we have C++14 non-trailing auto support.
+template <template <typename, typename, typename> class M,
+          typename L,
+          typename R,
+          typename... Args>
+struct ResultType;
+
+template <template <typename, typename, typename> class M,
+          typename L,
+          typename R>
+struct ResultType<M, L, R> {
+  using type = typename MathWrapper<M, L, R>::type;
+};
+
+template <template <typename, typename, typename> class M,
+          typename L,
+          typename R,
+          typename... Args>
+struct ResultType {
+  using type =
+      typename ResultType<M, typename ResultType<M, L, R>::type, Args...>::type;
+};
+
+// The following macros are just boilerplate for the standard arithmetic
+// operator overloads and variadic function templates. A macro isn't the nicest
+// solution, but it beats rewriting these over and over again.
+#define BASE_NUMERIC_ARITHMETIC_VARIADIC(CLASS, CL_ABBR, OP_NAME)       \
+  template <typename L, typename R, typename... Args>                   \
+  constexpr CLASS##Numeric<                                             \
+      typename ResultType<CLASS##OP_NAME##Op, L, R, Args...>::type>     \
+      CL_ABBR##OP_NAME(const L lhs, const R rhs, const Args... args) {  \
+    return CL_ABBR##MathOp<CLASS##OP_NAME##Op, L, R, Args...>(lhs, rhs, \
+                                                              args...); \
+  }
+
+#define BASE_NUMERIC_ARITHMETIC_OPERATORS(CLASS, CL_ABBR, OP_NAME, OP, CMP_OP) \
+  /* Binary arithmetic operator for all CLASS##Numeric operations. */          \
+  template <typename L, typename R,                                            \
+            typename std::enable_if<Is##CLASS##Op<L, R>::value>::type* =       \
+                nullptr>                                                       \
+  constexpr CLASS##Numeric<                                                    \
+      typename MathWrapper<CLASS##OP_NAME##Op, L, R>::type>                    \
+  operator OP(const L lhs, const R rhs) {                                      \
+    return decltype(lhs OP rhs)::template MathOp<CLASS##OP_NAME##Op>(lhs,      \
+                                                                     rhs);     \
+  }                                                                            \
+  /* Assignment arithmetic operator implementation from CLASS##Numeric. */     \
+  template <typename L>                                                        \
+  template <typename R>                                                        \
+  constexpr CLASS##Numeric<L>& CLASS##Numeric<L>::operator CMP_OP(             \
+      const R rhs) {                                                           \
+    return MathOp<CLASS##OP_NAME##Op>(rhs);                                    \
+  }                                                                            \
+  /* Variadic arithmetic functions that return CLASS##Numeric. */              \
+  BASE_NUMERIC_ARITHMETIC_VARIADIC(CLASS, CL_ABBR, OP_NAME)
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_NUMERICS_SAFE_MATH_SHARED_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/observer_list.h b/native/zucchini/vendor/libchrome/base/observer_list.h
new file mode 100644
index 0000000..e900e43
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/observer_list.h
@@ -0,0 +1,307 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_OBSERVER_LIST_H_
+#define BASE_OBSERVER_LIST_H_
+
+#include <stddef.h>
+
+#include <algorithm>
+#include <iterator>
+#include <limits>
+#include <utility>
+#include <vector>
+
+#include "base/gtest_prod_util.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "base/stl_util.h"
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// OVERVIEW:
+//
+//   A list of observers. Unlike a standard vector or list, this container can
+//   be modified during iteration without invalidating the iterator. So, it
+//   safely handles the case of an observer removing itself or other observers
+//   from the list while observers are being notified.
+//
+//
+// WARNING:
+//
+//   ObserverList is not thread-compatible. Iterating on the same ObserverList
+//   simultaneously in different threads is not safe, even when the ObserverList
+//   itself is not modified.
+//
+//   For a thread-safe observer list, see ObserverListThreadSafe.
+//
+//
+// TYPICAL USAGE:
+//
+//   class MyWidget {
+//    public:
+//     ...
+//
+//     class Observer {
+//      public:
+//       virtual void OnFoo(MyWidget* w) = 0;
+//       virtual void OnBar(MyWidget* w, int x, int y) = 0;
+//     };
+//
+//     void AddObserver(Observer* obs) {
+//       observers_.AddObserver(obs);
+//     }
+//
+//     void RemoveObserver(const Observer* obs) {
+//       observers_.RemoveObserver(obs);
+//     }
+//
+//     void NotifyFoo() {
+//       for (Observer& obs : observers_)
+//         obs.OnFoo(this);
+//     }
+//
+//     void NotifyBar(int x, int y) {
+//       for (Observer& obs : observers_)
+//         obs.OnBar(this, x, y);
+//     }
+//
+//    private:
+//     base::ObserverList<Observer> observers_;
+//   };
+//
+//
+///////////////////////////////////////////////////////////////////////////////
+
+namespace base {
+
+// Enumeration of which observers are notified by ObserverList.
+enum class ObserverListPolicy {
+  // Specifies that any observers added during notification are notified.
+  // This is the default policy if no policy is provided to the constructor.
+  ALL,
+
+  // Specifies that observers added while sending out notification are not
+  // notified.
+  EXISTING_ONLY,
+};
+
+// When check_empty is true, assert that the list is empty on destruction.
+// When allow_reentrancy is false, iterating throught the list while already in
+// the iteration loop will result in DCHECK failure.
+// TODO(oshima): Change the default to non reentrant. https://crbug.com/812109
+template <class ObserverType,
+          bool check_empty = false,
+          bool allow_reentrancy = true>
+class ObserverList
+    : public SupportsWeakPtr<
+          ObserverList<ObserverType, check_empty, allow_reentrancy>> {
+ public:
+  // An iterator class that can be used to access the list of observers.
+  class Iter {
+   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = ObserverType;
+    using difference_type = ptrdiff_t;
+    using pointer = ObserverType*;
+    using reference = ObserverType&;
+
+    Iter() : index_(0), max_index_(0) {}
+
+    explicit Iter(const ObserverList* list)
+        : list_(const_cast<ObserverList*>(list)->AsWeakPtr()),
+          index_(0),
+          max_index_(list->policy_ == ObserverListPolicy::ALL
+                         ? std::numeric_limits<size_t>::max()
+                         : list->observers_.size()) {
+      DCHECK(list_);
+      DCHECK(allow_reentrancy || !list_->live_iterator_count_);
+      EnsureValidIndex();
+      ++list_->live_iterator_count_;
+    }
+
+    ~Iter() {
+      if (!list_)
+        return;
+
+      DCHECK_GT(list_->live_iterator_count_, 0);
+      if (--list_->live_iterator_count_ == 0)
+        list_->Compact();
+    }
+
+    Iter(const Iter& other)
+        : list_(other.list_),
+          index_(other.index_),
+          max_index_(other.max_index_) {
+      if (list_)
+        ++list_->live_iterator_count_;
+    }
+
+    Iter& operator=(Iter other) {
+      using std::swap;
+      swap(list_, other.list_);
+      swap(index_, other.index_);
+      swap(max_index_, other.max_index_);
+      return *this;
+    }
+
+    bool operator==(const Iter& other) const {
+      return (is_end() && other.is_end()) ||
+             (list_.get() == other.list_.get() && index_ == other.index_);
+    }
+
+    bool operator!=(const Iter& other) const { return !(*this == other); }
+
+    Iter& operator++() {
+      if (list_) {
+        ++index_;
+        EnsureValidIndex();
+      }
+      return *this;
+    }
+
+    Iter operator++(int) {
+      Iter it(*this);
+      ++(*this);
+      return it;
+    }
+
+    ObserverType* operator->() const {
+      ObserverType* const current = GetCurrent();
+      DCHECK(current);
+      return current;
+    }
+
+    ObserverType& operator*() const {
+      ObserverType* const current = GetCurrent();
+      DCHECK(current);
+      return *current;
+    }
+
+   private:
+    FRIEND_TEST_ALL_PREFIXES(ObserverListTest, BasicStdIterator);
+    FRIEND_TEST_ALL_PREFIXES(ObserverListTest, StdIteratorRemoveFront);
+
+    ObserverType* GetCurrent() const {
+      DCHECK(list_);
+      DCHECK_LT(index_, clamped_max_index());
+      return list_->observers_[index_];
+    }
+
+    void EnsureValidIndex() {
+      DCHECK(list_);
+      const size_t max_index = clamped_max_index();
+      while (index_ < max_index && !list_->observers_[index_])
+        ++index_;
+    }
+
+    size_t clamped_max_index() const {
+      return std::min(max_index_, list_->observers_.size());
+    }
+
+    bool is_end() const { return !list_ || index_ == clamped_max_index(); }
+
+    WeakPtr<ObserverList> list_;
+
+    // When initially constructed and each time the iterator is incremented,
+    // |index_| is guaranteed to point to a non-null index if the iterator
+    // has not reached the end of the ObserverList.
+    size_t index_;
+    size_t max_index_;
+  };
+
+  using iterator = Iter;
+  using const_iterator = Iter;
+
+  const_iterator begin() const {
+    // An optimization: do not involve weak pointers for empty list.
+    return observers_.empty() ? const_iterator() : const_iterator(this);
+  }
+
+  const_iterator end() const { return const_iterator(); }
+
+  ObserverList() = default;
+  explicit ObserverList(ObserverListPolicy policy) : policy_(policy) {}
+
+  ~ObserverList() {
+    if (check_empty) {
+      Compact();
+      DCHECK(observers_.empty());
+    }
+  }
+
+  // Add an observer to this list. An observer should not be added to the same
+  // list more than once.
+  //
+  // Precondition: obs != nullptr
+  // Precondition: !HasObserver(obs)
+  void AddObserver(ObserverType* obs) {
+    DCHECK(obs);
+    if (HasObserver(obs)) {
+      NOTREACHED() << "Observers can only be added once!";
+      return;
+    }
+    observers_.push_back(obs);
+  }
+
+  // Removes the given observer from this list. Does nothing if this observer is
+  // not in this list.
+  void RemoveObserver(const ObserverType* obs) {
+    DCHECK(obs);
+    const auto it = std::find(observers_.begin(), observers_.end(), obs);
+    if (it == observers_.end())
+      return;
+
+    DCHECK_GE(live_iterator_count_, 0);
+    if (live_iterator_count_) {
+      *it = nullptr;
+    } else {
+      observers_.erase(it);
+    }
+  }
+
+  // Determine whether a particular observer is in the list.
+  bool HasObserver(const ObserverType* obs) const {
+    return ContainsValue(observers_, obs);
+  }
+
+  // Removes all the observers from this list.
+  void Clear() {
+    DCHECK_GE(live_iterator_count_, 0);
+    if (live_iterator_count_) {
+      std::fill(observers_.begin(), observers_.end(), nullptr);
+    } else {
+      observers_.clear();
+    }
+  }
+
+  bool might_have_observers() const { return !observers_.empty(); }
+
+ private:
+  // Compacts list of observers by removing null pointers.
+  void Compact() {
+    observers_.erase(std::remove(observers_.begin(), observers_.end(), nullptr),
+                     observers_.end());
+  }
+
+  std::vector<ObserverType*> observers_;
+
+  // Number of active iterators referencing this ObserverList.
+  //
+  // This counter is not synchronized although it is modified by const
+  // iterators.
+  int live_iterator_count_ = 0;
+
+  const ObserverListPolicy policy_ = ObserverListPolicy::ALL;
+
+  DISALLOW_COPY_AND_ASSIGN(ObserverList);
+};
+
+template <class ObserverType, bool check_empty = false>
+using ReentrantObserverList = ObserverList<ObserverType, check_empty, true>;
+
+}  // namespace base
+
+#endif  // BASE_OBSERVER_LIST_H_
diff --git a/native/zucchini/vendor/libchrome/base/observer_list_threadsafe.h b/native/zucchini/vendor/libchrome/base/observer_list_threadsafe.h
new file mode 100644
index 0000000..bd349f3
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/observer_list_threadsafe.h
@@ -0,0 +1,237 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_OBSERVER_LIST_THREADSAFE_H_
+#define BASE_OBSERVER_LIST_THREADSAFE_H_
+
+#include <unordered_map>
+
+#include "base/base_export.h"
+#include "base/bind.h"
+#include "base/lazy_instance.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/observer_list.h"
+#include "base/sequenced_task_runner.h"
+#include "base/stl_util.h"
+#include "base/synchronization/lock.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "base/threading/thread_local.h"
+#include "build/build_config.h"
+
+// TODO(fdoray): Removing these includes causes IWYU failures in other headers,
+// remove them in a follow- up CL.
+#include "base/memory/ptr_util.h"
+#include "base/single_thread_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// OVERVIEW:
+//
+//   A thread-safe container for a list of observers. This is similar to the
+//   observer_list (see observer_list.h), but it is more robust for multi-
+//   threaded situations.
+//
+//   The following use cases are supported:
+//    * Observers can register for notifications from any sequence. They are
+//      always notified on the sequence from which they were registered.
+//    * Any sequence may trigger a notification via Notify().
+//    * Observers can remove themselves from the observer list inside of a
+//      callback.
+//    * If one sequence is notifying observers concurrently with an observer
+//      removing itself from the observer list, the notifications will be
+//      silently dropped.
+//
+//   The drawback of the threadsafe observer list is that notifications are not
+//   as real-time as the non-threadsafe version of this class. Notifications
+//   will always be done via PostTask() to another sequence, whereas with the
+//   non-thread-safe observer_list, notifications happen synchronously.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+namespace base {
+namespace internal {
+
+class BASE_EXPORT ObserverListThreadSafeBase
+    : public RefCountedThreadSafe<ObserverListThreadSafeBase> {
+ public:
+  ObserverListThreadSafeBase() = default;
+
+ protected:
+  template <typename ObserverType, typename Method>
+  struct Dispatcher;
+
+  template <typename ObserverType, typename ReceiverType, typename... Params>
+  struct Dispatcher<ObserverType, void (ReceiverType::*)(Params...)> {
+    static void Run(void (ReceiverType::*m)(Params...),
+                    Params... params,
+                    ObserverType* obj) {
+      (obj->*m)(std::forward<Params>(params)...);
+    }
+  };
+
+  struct NotificationDataBase {
+    NotificationDataBase(void* observer_list_in, const Location& from_here_in)
+        : observer_list(observer_list_in), from_here(from_here_in) {}
+
+    void* observer_list;
+    Location from_here;
+  };
+
+  virtual ~ObserverListThreadSafeBase() = default;
+
+  static LazyInstance<ThreadLocalPointer<const NotificationDataBase>>::Leaky
+      tls_current_notification_;
+
+ private:
+  friend class RefCountedThreadSafe<ObserverListThreadSafeBase>;
+
+  DISALLOW_COPY_AND_ASSIGN(ObserverListThreadSafeBase);
+};
+
+}  // namespace internal
+
+template <class ObserverType>
+class ObserverListThreadSafe : public internal::ObserverListThreadSafeBase {
+ public:
+  ObserverListThreadSafe() = default;
+  explicit ObserverListThreadSafe(ObserverListPolicy policy)
+      : policy_(policy) {}
+
+  // Adds |observer| to the list. |observer| must not already be in the list.
+  void AddObserver(ObserverType* observer) {
+    // TODO(fdoray): Change this to a DCHECK once all call sites have a
+    // SequencedTaskRunnerHandle.
+    if (!SequencedTaskRunnerHandle::IsSet())
+      return;
+
+    AutoLock auto_lock(lock_);
+
+    // Add |observer| to the list of observers.
+    DCHECK(!ContainsKey(observers_, observer));
+    const scoped_refptr<SequencedTaskRunner> task_runner =
+        SequencedTaskRunnerHandle::Get();
+    observers_[observer] = task_runner;
+
+    // If this is called while a notification is being dispatched on this thread
+    // and |policy_| is ALL, |observer| must be notified (if a notification is
+    // being dispatched on another thread in parallel, the notification may or
+    // may not make it to |observer| depending on the outcome of the race to
+    // |lock_|).
+    if (policy_ == ObserverListPolicy::ALL) {
+      const NotificationDataBase* current_notification =
+          tls_current_notification_.Get().Get();
+      if (current_notification && current_notification->observer_list == this) {
+        task_runner->PostTask(
+            current_notification->from_here,
+            BindOnce(
+                &ObserverListThreadSafe<ObserverType>::NotifyWrapper, this,
+                observer,
+                *static_cast<const NotificationData*>(current_notification)));
+      }
+    }
+  }
+
+  // Remove an observer from the list if it is in the list.
+  //
+  // If a notification was sent to the observer but hasn't started to run yet,
+  // it will be aborted. If a notification has started to run, removing the
+  // observer won't stop it.
+  void RemoveObserver(ObserverType* observer) {
+    AutoLock auto_lock(lock_);
+    observers_.erase(observer);
+  }
+
+  // Verifies that the list is currently empty (i.e. there are no observers).
+  void AssertEmpty() const {
+#if DCHECK_IS_ON()
+    AutoLock auto_lock(lock_);
+    DCHECK(observers_.empty());
+#endif
+  }
+
+  // Asynchronously invokes a callback on all observers, on their registration
+  // sequence. You cannot assume that at the completion of the Notify call that
+  // all Observers have been Notified. The notification may still be pending
+  // delivery.
+  template <typename Method, typename... Params>
+  void Notify(const Location& from_here, Method m, Params&&... params) {
+    Callback<void(ObserverType*)> method =
+        Bind(&Dispatcher<ObserverType, Method>::Run, m,
+             std::forward<Params>(params)...);
+
+    AutoLock lock(lock_);
+    for (const auto& observer : observers_) {
+      observer.second->PostTask(
+          from_here,
+          BindOnce(&ObserverListThreadSafe<ObserverType>::NotifyWrapper, this,
+                   observer.first, NotificationData(this, from_here, method)));
+    }
+  }
+
+ private:
+  friend class RefCountedThreadSafe<ObserverListThreadSafeBase>;
+
+  struct NotificationData : public NotificationDataBase {
+    NotificationData(ObserverListThreadSafe* observer_list_in,
+                     const Location& from_here_in,
+                     const Callback<void(ObserverType*)>& method_in)
+        : NotificationDataBase(observer_list_in, from_here_in),
+          method(method_in) {}
+
+    Callback<void(ObserverType*)> method;
+  };
+
+  ~ObserverListThreadSafe() override = default;
+
+  void NotifyWrapper(ObserverType* observer,
+                     const NotificationData& notification) {
+    {
+      AutoLock auto_lock(lock_);
+
+      // Check whether the observer still needs a notification.
+      auto it = observers_.find(observer);
+      if (it == observers_.end())
+        return;
+      DCHECK(it->second->RunsTasksInCurrentSequence());
+    }
+
+    // Keep track of the notification being dispatched on the current thread.
+    // This will be used if the callback below calls AddObserver().
+    //
+    // Note: |tls_current_notification_| may not be nullptr if this runs in a
+    // nested loop started by a notification callback. In that case, it is
+    // important to save the previous value to restore it later.
+    auto& tls_current_notification = tls_current_notification_.Get();
+    const NotificationDataBase* const previous_notification =
+        tls_current_notification.Get();
+    tls_current_notification.Set(&notification);
+
+    // Invoke the callback.
+    notification.method.Run(observer);
+
+    // Reset the notification being dispatched on the current thread to its
+    // previous value.
+    tls_current_notification.Set(previous_notification);
+  }
+
+  const ObserverListPolicy policy_ = ObserverListPolicy::ALL;
+
+  // Synchronizes access to |observers_|.
+  mutable Lock lock_;
+
+  // Keys are observers. Values are the SequencedTaskRunners on which they must
+  // be notified.
+  std::unordered_map<ObserverType*, scoped_refptr<SequencedTaskRunner>>
+      observers_;
+
+  DISALLOW_COPY_AND_ASSIGN(ObserverListThreadSafe);
+};
+
+}  // namespace base
+
+#endif  // BASE_OBSERVER_LIST_THREADSAFE_H_
diff --git a/native/zucchini/vendor/libchrome/base/optional.h b/native/zucchini/vendor/libchrome/base/optional.h
new file mode 100644
index 0000000..f6263b8
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/optional.h
@@ -0,0 +1,922 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_OPTIONAL_H_
+#define BASE_OPTIONAL_H_
+
+#include <type_traits>
+#include <utility>
+
+#include "base/logging.h"
+#include "base/template_util.h"
+
+namespace base {
+
+// Specification:
+// http://en.cppreference.com/w/cpp/utility/optional/in_place_t
+struct in_place_t {};
+
+// Specification:
+// http://en.cppreference.com/w/cpp/utility/optional/nullopt_t
+struct nullopt_t {
+  constexpr explicit nullopt_t(int) {}
+};
+
+// Specification:
+// http://en.cppreference.com/w/cpp/utility/optional/in_place
+constexpr in_place_t in_place = {};
+
+// Specification:
+// http://en.cppreference.com/w/cpp/utility/optional/nullopt
+constexpr nullopt_t nullopt(0);
+
+// Forward declaration, which is refered by following helpers.
+template <typename T>
+class Optional;
+
+namespace internal {
+
+template <typename T, bool = std::is_trivially_destructible<T>::value>
+struct OptionalStorageBase {
+  // Initializing |empty_| here instead of using default member initializing
+  // to avoid errors in g++ 4.8.
+  constexpr OptionalStorageBase() : empty_('\0') {}
+
+  template <class... Args>
+  constexpr explicit OptionalStorageBase(in_place_t, Args&&... args)
+      : is_populated_(true), value_(std::forward<Args>(args)...) {}
+
+  // When T is not trivially destructible we must call its
+  // destructor before deallocating its memory.
+  // Note that this hides the (implicitly declared) move constructor, which
+  // would be used for constexpr move constructor in OptionalStorage<T>.
+  // It is needed iff T is trivially move constructible. However, the current
+  // is_trivially_{copy,move}_constructible implementation requires
+  // is_trivially_destructible (which looks a bug, cf:
+  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452 and
+  // http://cplusplus.github.io/LWG/lwg-active.html#2116), so it is not
+  // necessary for this case at the moment. Please see also the destructor
+  // comment in "is_trivially_destructible = true" specialization below.
+  ~OptionalStorageBase() {
+    if (is_populated_)
+      value_.~T();
+  }
+
+  template <class... Args>
+  void Init(Args&&... args) {
+    DCHECK(!is_populated_);
+    ::new (&value_) T(std::forward<Args>(args)...);
+    is_populated_ = true;
+  }
+
+  bool is_populated_ = false;
+  union {
+    // |empty_| exists so that the union will always be initialized, even when
+    // it doesn't contain a value. Union members must be initialized for the
+    // constructor to be 'constexpr'.
+    char empty_;
+    T value_;
+  };
+};
+
+template <typename T>
+struct OptionalStorageBase<T, true /* trivially destructible */> {
+  // Initializing |empty_| here instead of using default member initializing
+  // to avoid errors in g++ 4.8.
+  constexpr OptionalStorageBase() : empty_('\0') {}
+
+  template <class... Args>
+  constexpr explicit OptionalStorageBase(in_place_t, Args&&... args)
+      : is_populated_(true), value_(std::forward<Args>(args)...) {}
+
+  // When T is trivially destructible (i.e. its destructor does nothing) there
+  // is no need to call it. Implicitly defined destructor is trivial, because
+  // both members (bool and union containing only variants which are trivially
+  // destructible) are trivially destructible.
+  // Explicitly-defaulted destructor is also trivial, but do not use it here,
+  // because it hides the implicit move constructor. It is needed to implement
+  // constexpr move constructor in OptionalStorage iff T is trivially move
+  // constructible. Note that, if T is trivially move constructible, the move
+  // constructor of OptionalStorageBase<T> is also implicitly defined and it is
+  // trivially move constructor. If T is not trivially move constructible,
+  // "not declaring move constructor without destructor declaration" here means
+  // "delete move constructor", which works because any move constructor of
+  // OptionalStorage will not refer to it in that case.
+
+  template <class... Args>
+  void Init(Args&&... args) {
+    DCHECK(!is_populated_);
+    ::new (&value_) T(std::forward<Args>(args)...);
+    is_populated_ = true;
+  }
+
+  bool is_populated_ = false;
+  union {
+    // |empty_| exists so that the union will always be initialized, even when
+    // it doesn't contain a value. Union members must be initialized for the
+    // constructor to be 'constexpr'.
+    char empty_;
+    T value_;
+  };
+};
+
+// Implement conditional constexpr copy and move constructors. These are
+// constexpr if is_trivially_{copy,move}_constructible<T>::value is true
+// respectively. If each is true, the corresponding constructor is defined as
+// "= default;", which generates a constexpr constructor (In this case,
+// the condition of constexpr-ness is satisfied because the base class also has
+// compiler generated constexpr {copy,move} constructors). Note that
+// placement-new is prohibited in constexpr.
+template <typename T,
+          bool = is_trivially_copy_constructible<T>::value,
+          bool = std::is_trivially_move_constructible<T>::value>
+struct OptionalStorage : OptionalStorageBase<T> {
+  // This is no trivially {copy,move} constructible case. Other cases are
+  // defined below as specializations.
+
+  // Accessing the members of template base class requires explicit
+  // declaration.
+  using OptionalStorageBase<T>::is_populated_;
+  using OptionalStorageBase<T>::value_;
+  using OptionalStorageBase<T>::Init;
+
+  // Inherit constructors (specifically, the in_place constructor).
+  using OptionalStorageBase<T>::OptionalStorageBase;
+
+  // User defined constructor deletes the default constructor.
+  // Define it explicitly.
+  OptionalStorage() = default;
+
+  OptionalStorage(const OptionalStorage& other) {
+    if (other.is_populated_)
+      Init(other.value_);
+  }
+
+  OptionalStorage(OptionalStorage&& other) noexcept(
+      std::is_nothrow_move_constructible<T>::value) {
+    if (other.is_populated_)
+      Init(std::move(other.value_));
+  }
+};
+
+template <typename T>
+struct OptionalStorage<T,
+                       true /* trivially copy constructible */,
+                       false /* trivially move constructible */>
+    : OptionalStorageBase<T> {
+  using OptionalStorageBase<T>::is_populated_;
+  using OptionalStorageBase<T>::value_;
+  using OptionalStorageBase<T>::Init;
+  using OptionalStorageBase<T>::OptionalStorageBase;
+
+  OptionalStorage() = default;
+  OptionalStorage(const OptionalStorage& other) = default;
+
+  OptionalStorage(OptionalStorage&& other) noexcept(
+      std::is_nothrow_move_constructible<T>::value) {
+    if (other.is_populated_)
+      Init(std::move(other.value_));
+  }
+};
+
+template <typename T>
+struct OptionalStorage<T,
+                       false /* trivially copy constructible */,
+                       true /* trivially move constructible */>
+    : OptionalStorageBase<T> {
+  using OptionalStorageBase<T>::is_populated_;
+  using OptionalStorageBase<T>::value_;
+  using OptionalStorageBase<T>::Init;
+  using OptionalStorageBase<T>::OptionalStorageBase;
+
+  OptionalStorage() = default;
+  OptionalStorage(OptionalStorage&& other) = default;
+
+  OptionalStorage(const OptionalStorage& other) {
+    if (other.is_populated_)
+      Init(other.value_);
+  }
+};
+
+template <typename T>
+struct OptionalStorage<T,
+                       true /* trivially copy constructible */,
+                       true /* trivially move constructible */>
+    : OptionalStorageBase<T> {
+  // If both trivially {copy,move} constructible are true, it is not necessary
+  // to use user-defined constructors. So, just inheriting constructors
+  // from the base class works.
+  using OptionalStorageBase<T>::OptionalStorageBase;
+};
+
+// Base class to support conditionally usable copy-/move- constructors
+// and assign operators.
+template <typename T>
+class OptionalBase {
+  // This class provides implementation rather than public API, so everything
+  // should be hidden. Often we use composition, but we cannot in this case
+  // because of C++ language restriction.
+ protected:
+  constexpr OptionalBase() = default;
+  constexpr OptionalBase(const OptionalBase& other) = default;
+  constexpr OptionalBase(OptionalBase&& other) = default;
+
+  template <class... Args>
+  constexpr explicit OptionalBase(in_place_t, Args&&... args)
+      : storage_(in_place, std::forward<Args>(args)...) {}
+
+  // Implementation of converting constructors.
+  template <typename U>
+  explicit OptionalBase(const OptionalBase<U>& other) {
+    if (other.storage_.is_populated_)
+      storage_.Init(other.storage_.value_);
+  }
+
+  template <typename U>
+  explicit OptionalBase(OptionalBase<U>&& other) {
+    if (other.storage_.is_populated_)
+      storage_.Init(std::move(other.storage_.value_));
+  }
+
+  ~OptionalBase() = default;
+
+  OptionalBase& operator=(const OptionalBase& other) {
+    CopyAssign(other);
+    return *this;
+  }
+
+  OptionalBase& operator=(OptionalBase&& other) noexcept(
+      std::is_nothrow_move_assignable<T>::value&&
+          std::is_nothrow_move_constructible<T>::value) {
+    MoveAssign(std::move(other));
+    return *this;
+  }
+
+  template <typename U>
+  void CopyAssign(const OptionalBase<U>& other) {
+    if (other.storage_.is_populated_)
+      InitOrAssign(other.storage_.value_);
+    else
+      FreeIfNeeded();
+  }
+
+  template <typename U>
+  void MoveAssign(OptionalBase<U>&& other) {
+    if (other.storage_.is_populated_)
+      InitOrAssign(std::move(other.storage_.value_));
+    else
+      FreeIfNeeded();
+  }
+
+  template <typename U>
+  void InitOrAssign(U&& value) {
+    if (storage_.is_populated_)
+      storage_.value_ = std::forward<U>(value);
+    else
+      storage_.Init(std::forward<U>(value));
+  }
+
+  void FreeIfNeeded() {
+    if (!storage_.is_populated_)
+      return;
+    storage_.value_.~T();
+    storage_.is_populated_ = false;
+  }
+
+  // For implementing conversion, allow access to other typed OptionalBase
+  // class.
+  template <typename U>
+  friend class OptionalBase;
+
+  OptionalStorage<T> storage_;
+};
+
+// The following {Copy,Move}{Constructible,Assignable} structs are helpers to
+// implement constructor/assign-operator overloading. Specifically, if T is
+// is not movable but copyable, Optional<T>'s move constructor should not
+// participate in overload resolution. This inheritance trick implements that.
+template <bool is_copy_constructible>
+struct CopyConstructible {};
+
+template <>
+struct CopyConstructible<false> {
+  constexpr CopyConstructible() = default;
+  constexpr CopyConstructible(const CopyConstructible&) = delete;
+  constexpr CopyConstructible(CopyConstructible&&) = default;
+  CopyConstructible& operator=(const CopyConstructible&) = default;
+  CopyConstructible& operator=(CopyConstructible&&) = default;
+};
+
+template <bool is_move_constructible>
+struct MoveConstructible {};
+
+template <>
+struct MoveConstructible<false> {
+  constexpr MoveConstructible() = default;
+  constexpr MoveConstructible(const MoveConstructible&) = default;
+  constexpr MoveConstructible(MoveConstructible&&) = delete;
+  MoveConstructible& operator=(const MoveConstructible&) = default;
+  MoveConstructible& operator=(MoveConstructible&&) = default;
+};
+
+template <bool is_copy_assignable>
+struct CopyAssignable {};
+
+template <>
+struct CopyAssignable<false> {
+  constexpr CopyAssignable() = default;
+  constexpr CopyAssignable(const CopyAssignable&) = default;
+  constexpr CopyAssignable(CopyAssignable&&) = default;
+  CopyAssignable& operator=(const CopyAssignable&) = delete;
+  CopyAssignable& operator=(CopyAssignable&&) = default;
+};
+
+template <bool is_move_assignable>
+struct MoveAssignable {};
+
+template <>
+struct MoveAssignable<false> {
+  constexpr MoveAssignable() = default;
+  constexpr MoveAssignable(const MoveAssignable&) = default;
+  constexpr MoveAssignable(MoveAssignable&&) = default;
+  MoveAssignable& operator=(const MoveAssignable&) = default;
+  MoveAssignable& operator=(MoveAssignable&&) = delete;
+};
+
+// Helper to conditionally enable converting constructors and assign operators.
+template <typename T, typename U>
+struct IsConvertibleFromOptional
+    : std::integral_constant<
+          bool,
+          std::is_constructible<T, Optional<U>&>::value ||
+              std::is_constructible<T, const Optional<U>&>::value ||
+              std::is_constructible<T, Optional<U>&&>::value ||
+              std::is_constructible<T, const Optional<U>&&>::value ||
+              std::is_convertible<Optional<U>&, T>::value ||
+              std::is_convertible<const Optional<U>&, T>::value ||
+              std::is_convertible<Optional<U>&&, T>::value ||
+              std::is_convertible<const Optional<U>&&, T>::value> {};
+
+template <typename T, typename U>
+struct IsAssignableFromOptional
+    : std::integral_constant<
+          bool,
+          IsConvertibleFromOptional<T, U>::value ||
+              std::is_assignable<T&, Optional<U>&>::value ||
+              std::is_assignable<T&, const Optional<U>&>::value ||
+              std::is_assignable<T&, Optional<U>&&>::value ||
+              std::is_assignable<T&, const Optional<U>&&>::value> {};
+
+// Forward compatibility for C++17.
+// Introduce one more deeper nested namespace to avoid leaking using std::swap.
+namespace swappable_impl {
+using std::swap;
+
+struct IsSwappableImpl {
+  // Tests if swap can be called. Check<T&>(0) returns true_type iff swap
+  // is available for T. Otherwise, Check's overload resolution falls back
+  // to Check(...) declared below thanks to SFINAE, so returns false_type.
+  template <typename T>
+  static auto Check(int)
+      -> decltype(swap(std::declval<T>(), std::declval<T>()), std::true_type());
+
+  template <typename T>
+  static std::false_type Check(...);
+};
+}  // namespace swappable_impl
+
+template <typename T>
+struct IsSwappable : decltype(swappable_impl::IsSwappableImpl::Check<T&>(0)) {};
+
+// Forward compatibility for C++20.
+template <typename T>
+using RemoveCvRefT = std::remove_cv_t<std::remove_reference_t<T>>;
+
+}  // namespace internal
+
+// On Windows, by default, empty-base class optimization does not work,
+// which means even if the base class is empty struct, it still consumes one
+// byte for its body. __declspec(empty_bases) enables the optimization.
+// cf)
+// https://blogs.msdn.microsoft.com/vcblog/2016/03/30/optimizing-the-layout-of-empty-base-classes-in-vs2015-update-2-3/
+#ifdef OS_WIN
+#define OPTIONAL_DECLSPEC_EMPTY_BASES __declspec(empty_bases)
+#else
+#define OPTIONAL_DECLSPEC_EMPTY_BASES
+#endif
+
+// base::Optional is a Chromium version of the C++17 optional class:
+// std::optional documentation:
+// http://en.cppreference.com/w/cpp/utility/optional
+// Chromium documentation:
+// https://chromium.googlesource.com/chromium/src/+/master/docs/optional.md
+//
+// These are the differences between the specification and the implementation:
+// - Constructors do not use 'constexpr' as it is a C++14 extension.
+// - 'constexpr' might be missing in some places for reasons specified locally.
+// - No exceptions are thrown, because they are banned from Chromium.
+//   Marked noexcept for only move constructor and move assign operators.
+// - All the non-members are in the 'base' namespace instead of 'std'.
+//
+// Note that T cannot have a constructor T(Optional<T>) etc. Optional<T> checks
+// T's constructor (specifically via IsConvertibleFromOptional), and in the
+// check whether T can be constructible from Optional<T>, which is recursive
+// so it does not work. As of Feb 2018, std::optional C++17 implementation in
+// both clang and gcc has same limitation. MSVC SFINAE looks to have different
+// behavior, but anyway it reports an error, too.
+template <typename T>
+class OPTIONAL_DECLSPEC_EMPTY_BASES Optional
+    : public internal::OptionalBase<T>,
+      public internal::CopyConstructible<std::is_copy_constructible<T>::value>,
+      public internal::MoveConstructible<std::is_move_constructible<T>::value>,
+      public internal::CopyAssignable<std::is_copy_constructible<T>::value &&
+                                      std::is_copy_assignable<T>::value>,
+      public internal::MoveAssignable<std::is_move_constructible<T>::value &&
+                                      std::is_move_assignable<T>::value> {
+ public:
+#undef OPTIONAL_DECLSPEC_EMPTY_BASES
+  using value_type = T;
+
+  // Defer default/copy/move constructor implementation to OptionalBase.
+  constexpr Optional() = default;
+  constexpr Optional(const Optional& other) = default;
+  constexpr Optional(Optional&& other) noexcept(
+      std::is_nothrow_move_constructible<T>::value) = default;
+
+  constexpr Optional(nullopt_t) {}  // NOLINT(runtime/explicit)
+
+  // Converting copy constructor. "explicit" only if
+  // std::is_convertible<const U&, T>::value is false. It is implemented by
+  // declaring two almost same constructors, but that condition in enable_if_t
+  // is different, so that either one is chosen, thanks to SFINAE.
+  template <
+      typename U,
+      std::enable_if_t<std::is_constructible<T, const U&>::value &&
+                           !internal::IsConvertibleFromOptional<T, U>::value &&
+                           std::is_convertible<const U&, T>::value,
+                       bool> = false>
+  Optional(const Optional<U>& other) : internal::OptionalBase<T>(other) {}
+
+  template <
+      typename U,
+      std::enable_if_t<std::is_constructible<T, const U&>::value &&
+                           !internal::IsConvertibleFromOptional<T, U>::value &&
+                           !std::is_convertible<const U&, T>::value,
+                       bool> = false>
+  explicit Optional(const Optional<U>& other)
+      : internal::OptionalBase<T>(other) {}
+
+  // Converting move constructor. Similar to converting copy constructor,
+  // declaring two (explicit and non-explicit) constructors.
+  template <
+      typename U,
+      std::enable_if_t<std::is_constructible<T, U&&>::value &&
+                           !internal::IsConvertibleFromOptional<T, U>::value &&
+                           std::is_convertible<U&&, T>::value,
+                       bool> = false>
+  Optional(Optional<U>&& other) : internal::OptionalBase<T>(std::move(other)) {}
+
+  template <
+      typename U,
+      std::enable_if_t<std::is_constructible<T, U&&>::value &&
+                           !internal::IsConvertibleFromOptional<T, U>::value &&
+                           !std::is_convertible<U&&, T>::value,
+                       bool> = false>
+  explicit Optional(Optional<U>&& other)
+      : internal::OptionalBase<T>(std::move(other)) {}
+
+  template <class... Args>
+  constexpr explicit Optional(in_place_t, Args&&... args)
+      : internal::OptionalBase<T>(in_place, std::forward<Args>(args)...) {}
+
+  template <
+      class U,
+      class... Args,
+      class = std::enable_if_t<std::is_constructible<value_type,
+                                                     std::initializer_list<U>&,
+                                                     Args...>::value>>
+  constexpr explicit Optional(in_place_t,
+                              std::initializer_list<U> il,
+                              Args&&... args)
+      : internal::OptionalBase<T>(in_place, il, std::forward<Args>(args)...) {}
+
+  // Forward value constructor. Similar to converting constructors,
+  // conditionally explicit.
+  template <
+      typename U = value_type,
+      std::enable_if_t<
+          std::is_constructible<T, U&&>::value &&
+              !std::is_same<internal::RemoveCvRefT<U>, in_place_t>::value &&
+              !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value &&
+              std::is_convertible<U&&, T>::value,
+          bool> = false>
+  constexpr Optional(U&& value)
+      : internal::OptionalBase<T>(in_place, std::forward<U>(value)) {}
+
+  template <
+      typename U = value_type,
+      std::enable_if_t<
+          std::is_constructible<T, U&&>::value &&
+              !std::is_same<internal::RemoveCvRefT<U>, in_place_t>::value &&
+              !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value &&
+              !std::is_convertible<U&&, T>::value,
+          bool> = false>
+  constexpr explicit Optional(U&& value)
+      : internal::OptionalBase<T>(in_place, std::forward<U>(value)) {}
+
+  ~Optional() = default;
+
+  // Defer copy-/move- assign operator implementation to OptionalBase.
+  Optional& operator=(const Optional& other) = default;
+  Optional& operator=(Optional&& other) noexcept(
+      std::is_nothrow_move_assignable<T>::value&&
+          std::is_nothrow_move_constructible<T>::value) = default;
+
+  Optional& operator=(nullopt_t) {
+    FreeIfNeeded();
+    return *this;
+  }
+
+  // Perfect-forwarded assignment.
+  template <typename U>
+  std::enable_if_t<
+      !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value &&
+          std::is_constructible<T, U>::value &&
+          std::is_assignable<T&, U>::value &&
+          (!std::is_scalar<T>::value ||
+           !std::is_same<std::decay_t<U>, T>::value),
+      Optional&>
+  operator=(U&& value) {
+    InitOrAssign(std::forward<U>(value));
+    return *this;
+  }
+
+  // Copy assign the state of other.
+  template <typename U>
+  std::enable_if_t<!internal::IsAssignableFromOptional<T, U>::value &&
+                       std::is_constructible<T, const U&>::value &&
+                       std::is_assignable<T&, const U&>::value,
+                   Optional&>
+  operator=(const Optional<U>& other) {
+    CopyAssign(other);
+    return *this;
+  }
+
+  // Move assign the state of other.
+  template <typename U>
+  std::enable_if_t<!internal::IsAssignableFromOptional<T, U>::value &&
+                       std::is_constructible<T, U>::value &&
+                       std::is_assignable<T&, U>::value,
+                   Optional&>
+  operator=(Optional<U>&& other) {
+    MoveAssign(std::move(other));
+    return *this;
+  }
+
+  constexpr const T* operator->() const {
+    DCHECK(storage_.is_populated_);
+    return &storage_.value_;
+  }
+
+  constexpr T* operator->() {
+    DCHECK(storage_.is_populated_);
+    return &storage_.value_;
+  }
+
+  constexpr const T& operator*() const & {
+    DCHECK(storage_.is_populated_);
+    return storage_.value_;
+  }
+
+  constexpr T& operator*() & {
+    DCHECK(storage_.is_populated_);
+    return storage_.value_;
+  }
+
+  constexpr const T&& operator*() const && {
+    DCHECK(storage_.is_populated_);
+    return std::move(storage_.value_);
+  }
+
+  constexpr T&& operator*() && {
+    DCHECK(storage_.is_populated_);
+    return std::move(storage_.value_);
+  }
+
+  constexpr explicit operator bool() const { return storage_.is_populated_; }
+
+  constexpr bool has_value() const { return storage_.is_populated_; }
+
+  constexpr T& value() & {
+    CHECK(storage_.is_populated_);
+    return storage_.value_;
+  }
+
+  constexpr const T& value() const & {
+    CHECK(storage_.is_populated_);
+    return storage_.value_;
+  }
+
+  constexpr T&& value() && {
+    CHECK(storage_.is_populated_);
+    return std::move(storage_.value_);
+  }
+
+  constexpr const T&& value() const && {
+    CHECK(storage_.is_populated_);
+    return std::move(storage_.value_);
+  }
+
+  template <class U>
+  constexpr T value_or(U&& default_value) const& {
+    // TODO(mlamouri): add the following assert when possible:
+    // static_assert(std::is_copy_constructible<T>::value,
+    //               "T must be copy constructible");
+    static_assert(std::is_convertible<U, T>::value,
+                  "U must be convertible to T");
+    return storage_.is_populated_
+               ? storage_.value_
+               : static_cast<T>(std::forward<U>(default_value));
+  }
+
+  template <class U>
+  constexpr T value_or(U&& default_value) && {
+    // TODO(mlamouri): add the following assert when possible:
+    // static_assert(std::is_move_constructible<T>::value,
+    //               "T must be move constructible");
+    static_assert(std::is_convertible<U, T>::value,
+                  "U must be convertible to T");
+    return storage_.is_populated_
+               ? std::move(storage_.value_)
+               : static_cast<T>(std::forward<U>(default_value));
+  }
+
+  void swap(Optional& other) {
+    if (!storage_.is_populated_ && !other.storage_.is_populated_)
+      return;
+
+    if (storage_.is_populated_ != other.storage_.is_populated_) {
+      if (storage_.is_populated_) {
+        other.storage_.Init(std::move(storage_.value_));
+        FreeIfNeeded();
+      } else {
+        storage_.Init(std::move(other.storage_.value_));
+        other.FreeIfNeeded();
+      }
+      return;
+    }
+
+    DCHECK(storage_.is_populated_ && other.storage_.is_populated_);
+    using std::swap;
+    swap(**this, *other);
+  }
+
+  void reset() { FreeIfNeeded(); }
+
+  template <class... Args>
+  T& emplace(Args&&... args) {
+    FreeIfNeeded();
+    storage_.Init(std::forward<Args>(args)...);
+    return storage_.value_;
+  }
+
+  template <class U, class... Args>
+  std::enable_if_t<
+      std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value,
+      T&>
+  emplace(std::initializer_list<U> il, Args&&... args) {
+    FreeIfNeeded();
+    storage_.Init(il, std::forward<Args>(args)...);
+    return storage_.value_;
+  }
+
+ private:
+  // Accessing template base class's protected member needs explicit
+  // declaration to do so.
+  using internal::OptionalBase<T>::CopyAssign;
+  using internal::OptionalBase<T>::FreeIfNeeded;
+  using internal::OptionalBase<T>::InitOrAssign;
+  using internal::OptionalBase<T>::MoveAssign;
+  using internal::OptionalBase<T>::storage_;
+};
+
+// Here after defines comparation operators. The definition follows
+// http://en.cppreference.com/w/cpp/utility/optional/operator_cmp
+// while bool() casting is replaced by has_value() to meet the chromium
+// style guide.
+template <class T, class U>
+constexpr bool operator==(const Optional<T>& lhs, const Optional<U>& rhs) {
+  if (lhs.has_value() != rhs.has_value())
+    return false;
+  if (!lhs.has_value())
+    return true;
+  return *lhs == *rhs;
+}
+
+template <class T, class U>
+constexpr bool operator!=(const Optional<T>& lhs, const Optional<U>& rhs) {
+  if (lhs.has_value() != rhs.has_value())
+    return true;
+  if (!lhs.has_value())
+    return false;
+  return *lhs != *rhs;
+}
+
+template <class T, class U>
+constexpr bool operator<(const Optional<T>& lhs, const Optional<U>& rhs) {
+  if (!rhs.has_value())
+    return false;
+  if (!lhs.has_value())
+    return true;
+  return *lhs < *rhs;
+}
+
+template <class T, class U>
+constexpr bool operator<=(const Optional<T>& lhs, const Optional<U>& rhs) {
+  if (!lhs.has_value())
+    return true;
+  if (!rhs.has_value())
+    return false;
+  return *lhs <= *rhs;
+}
+
+template <class T, class U>
+constexpr bool operator>(const Optional<T>& lhs, const Optional<U>& rhs) {
+  if (!lhs.has_value())
+    return false;
+  if (!rhs.has_value())
+    return true;
+  return *lhs > *rhs;
+}
+
+template <class T, class U>
+constexpr bool operator>=(const Optional<T>& lhs, const Optional<U>& rhs) {
+  if (!rhs.has_value())
+    return true;
+  if (!lhs.has_value())
+    return false;
+  return *lhs >= *rhs;
+}
+
+template <class T>
+constexpr bool operator==(const Optional<T>& opt, nullopt_t) {
+  return !opt;
+}
+
+template <class T>
+constexpr bool operator==(nullopt_t, const Optional<T>& opt) {
+  return !opt;
+}
+
+template <class T>
+constexpr bool operator!=(const Optional<T>& opt, nullopt_t) {
+  return opt.has_value();
+}
+
+template <class T>
+constexpr bool operator!=(nullopt_t, const Optional<T>& opt) {
+  return opt.has_value();
+}
+
+template <class T>
+constexpr bool operator<(const Optional<T>& opt, nullopt_t) {
+  return false;
+}
+
+template <class T>
+constexpr bool operator<(nullopt_t, const Optional<T>& opt) {
+  return opt.has_value();
+}
+
+template <class T>
+constexpr bool operator<=(const Optional<T>& opt, nullopt_t) {
+  return !opt;
+}
+
+template <class T>
+constexpr bool operator<=(nullopt_t, const Optional<T>& opt) {
+  return true;
+}
+
+template <class T>
+constexpr bool operator>(const Optional<T>& opt, nullopt_t) {
+  return opt.has_value();
+}
+
+template <class T>
+constexpr bool operator>(nullopt_t, const Optional<T>& opt) {
+  return false;
+}
+
+template <class T>
+constexpr bool operator>=(const Optional<T>& opt, nullopt_t) {
+  return true;
+}
+
+template <class T>
+constexpr bool operator>=(nullopt_t, const Optional<T>& opt) {
+  return !opt;
+}
+
+template <class T, class U>
+constexpr bool operator==(const Optional<T>& opt, const U& value) {
+  return opt.has_value() ? *opt == value : false;
+}
+
+template <class T, class U>
+constexpr bool operator==(const U& value, const Optional<T>& opt) {
+  return opt.has_value() ? value == *opt : false;
+}
+
+template <class T, class U>
+constexpr bool operator!=(const Optional<T>& opt, const U& value) {
+  return opt.has_value() ? *opt != value : true;
+}
+
+template <class T, class U>
+constexpr bool operator!=(const U& value, const Optional<T>& opt) {
+  return opt.has_value() ? value != *opt : true;
+}
+
+template <class T, class U>
+constexpr bool operator<(const Optional<T>& opt, const U& value) {
+  return opt.has_value() ? *opt < value : true;
+}
+
+template <class T, class U>
+constexpr bool operator<(const U& value, const Optional<T>& opt) {
+  return opt.has_value() ? value < *opt : false;
+}
+
+template <class T, class U>
+constexpr bool operator<=(const Optional<T>& opt, const U& value) {
+  return opt.has_value() ? *opt <= value : true;
+}
+
+template <class T, class U>
+constexpr bool operator<=(const U& value, const Optional<T>& opt) {
+  return opt.has_value() ? value <= *opt : false;
+}
+
+template <class T, class U>
+constexpr bool operator>(const Optional<T>& opt, const U& value) {
+  return opt.has_value() ? *opt > value : false;
+}
+
+template <class T, class U>
+constexpr bool operator>(const U& value, const Optional<T>& opt) {
+  return opt.has_value() ? value > *opt : true;
+}
+
+template <class T, class U>
+constexpr bool operator>=(const Optional<T>& opt, const U& value) {
+  return opt.has_value() ? *opt >= value : false;
+}
+
+template <class T, class U>
+constexpr bool operator>=(const U& value, const Optional<T>& opt) {
+  return opt.has_value() ? value >= *opt : true;
+}
+
+template <class T>
+constexpr Optional<std::decay_t<T>> make_optional(T&& value) {
+  return Optional<std::decay_t<T>>(std::forward<T>(value));
+}
+
+template <class T, class... Args>
+constexpr Optional<T> make_optional(Args&&... args) {
+  return Optional<T>(in_place, std::forward<Args>(args)...);
+}
+
+template <class T, class U, class... Args>
+constexpr Optional<T> make_optional(std::initializer_list<U> il,
+                                    Args&&... args) {
+  return Optional<T>(in_place, il, std::forward<Args>(args)...);
+}
+
+// Partial specialization for a function template is not allowed. Also, it is
+// not allowed to add overload function to std namespace, while it is allowed
+// to specialize the template in std. Thus, swap() (kind of) overloading is
+// defined in base namespace, instead.
+template <class T>
+std::enable_if_t<std::is_move_constructible<T>::value &&
+                 internal::IsSwappable<T>::value>
+swap(Optional<T>& lhs, Optional<T>& rhs) {
+  lhs.swap(rhs);
+}
+
+}  // namespace base
+
+namespace std {
+
+template <class T>
+struct hash<base::Optional<T>> {
+  size_t operator()(const base::Optional<T>& opt) const {
+    return opt == base::nullopt ? 0 : std::hash<T>()(*opt);
+  }
+};
+
+}  // namespace std
+
+#endif  // BASE_OPTIONAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/pending_task.h b/native/zucchini/vendor/libchrome/base/pending_task.h
new file mode 100644
index 0000000..b71a371
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/pending_task.h
@@ -0,0 +1,68 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_PENDING_TASK_H_
+#define BASE_PENDING_TASK_H_
+
+#include <array>
+
+#include "base/base_export.h"
+#include "base/callback.h"
+#include "base/containers/queue.h"
+#include "base/location.h"
+#include "base/time/time.h"
+
+namespace base {
+
+enum class Nestable {
+  kNonNestable,
+  kNestable,
+};
+
+// Contains data about a pending task. Stored in TaskQueue and DelayedTaskQueue
+// for use by classes that queue and execute tasks.
+struct BASE_EXPORT PendingTask {
+  PendingTask(const Location& posted_from,
+              OnceClosure task,
+              TimeTicks delayed_run_time = TimeTicks(),
+              Nestable nestable = Nestable::kNestable);
+  PendingTask(PendingTask&& other);
+  ~PendingTask();
+
+  PendingTask& operator=(PendingTask&& other);
+
+  // Used to support sorting.
+  bool operator<(const PendingTask& other) const;
+
+  // The task to run.
+  OnceClosure task;
+
+  // The site this PendingTask was posted from.
+  Location posted_from;
+
+  // The time when the task should be run.
+  base::TimeTicks delayed_run_time;
+
+  // Chain of up-to-four symbols of the parent tasks which led to this one being
+  // posted.
+  std::array<const void*, 4> task_backtrace = {};
+
+  // Secondary sort key for run time.
+  int sequence_num = 0;
+
+  // OK to dispatch from a nested loop.
+  Nestable nestable;
+
+  // Needs high resolution timers.
+  bool is_high_res = false;
+};
+
+using TaskQueue = base::queue<PendingTask>;
+
+// PendingTasks are sorted by their |delayed_run_time| property.
+using DelayedTaskQueue = std::priority_queue<base::PendingTask>;
+
+}  // namespace base
+
+#endif  // BASE_PENDING_TASK_H_
diff --git a/native/zucchini/vendor/libchrome/base/pickle.h b/native/zucchini/vendor/libchrome/base/pickle.h
new file mode 100644
index 0000000..eff2092
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/pickle.h
@@ -0,0 +1,345 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_PICKLE_H_
+#define BASE_PICKLE_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <string>
+
+#include "base/base_export.h"
+#include "base/compiler_specific.h"
+#include "base/gtest_prod_util.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_piece.h"
+
+#if defined(OS_POSIX)
+#include "base/files/file.h"
+#endif
+
+namespace base {
+
+class Pickle;
+
+// PickleIterator reads data from a Pickle. The Pickle object must remain valid
+// while the PickleIterator object is in use.
+class BASE_EXPORT PickleIterator {
+ public:
+  PickleIterator() : payload_(NULL), read_index_(0), end_index_(0) {}
+  explicit PickleIterator(const Pickle& pickle);
+
+  // Methods for reading the payload of the Pickle. To read from the start of
+  // the Pickle, create a PickleIterator from a Pickle. If successful, these
+  // methods return true. Otherwise, false is returned to indicate that the
+  // result could not be extracted. It is not possible to read from the iterator
+  // after that.
+  bool ReadBool(bool* result) WARN_UNUSED_RESULT;
+  bool ReadInt(int* result) WARN_UNUSED_RESULT;
+  bool ReadLong(long* result) WARN_UNUSED_RESULT;
+  bool ReadUInt16(uint16_t* result) WARN_UNUSED_RESULT;
+  bool ReadUInt32(uint32_t* result) WARN_UNUSED_RESULT;
+  bool ReadInt64(int64_t* result) WARN_UNUSED_RESULT;
+  bool ReadUInt64(uint64_t* result) WARN_UNUSED_RESULT;
+  bool ReadFloat(float* result) WARN_UNUSED_RESULT;
+  bool ReadDouble(double* result) WARN_UNUSED_RESULT;
+  bool ReadString(std::string* result) WARN_UNUSED_RESULT;
+  // The StringPiece data will only be valid for the lifetime of the message.
+  bool ReadStringPiece(StringPiece* result) WARN_UNUSED_RESULT;
+  bool ReadString16(string16* result) WARN_UNUSED_RESULT;
+  // The StringPiece16 data will only be valid for the lifetime of the message.
+  bool ReadStringPiece16(StringPiece16* result) WARN_UNUSED_RESULT;
+
+  // A pointer to the data will be placed in |*data|, and the length will be
+  // placed in |*length|. The pointer placed into |*data| points into the
+  // message's buffer so it will be scoped to the lifetime of the message (or
+  // until the message data is mutated). Do not keep the pointer around!
+  bool ReadData(const char** data, int* length) WARN_UNUSED_RESULT;
+
+  // A pointer to the data will be placed in |*data|. The caller specifies the
+  // number of bytes to read, and ReadBytes will validate this length. The
+  // pointer placed into |*data| points into the message's buffer so it will be
+  // scoped to the lifetime of the message (or until the message data is
+  // mutated). Do not keep the pointer around!
+  bool ReadBytes(const char** data, int length) WARN_UNUSED_RESULT;
+
+  // A safer version of ReadInt() that checks for the result not being negative.
+  // Use it for reading the object sizes.
+  bool ReadLength(int* result) WARN_UNUSED_RESULT {
+    return ReadInt(result) && *result >= 0;
+  }
+
+  // Skips bytes in the read buffer and returns true if there are at least
+  // num_bytes available. Otherwise, does nothing and returns false.
+  bool SkipBytes(int num_bytes) WARN_UNUSED_RESULT {
+    return !!GetReadPointerAndAdvance(num_bytes);
+  }
+
+ private:
+  // Read Type from Pickle.
+  template <typename Type>
+  bool ReadBuiltinType(Type* result);
+
+  // Advance read_index_ but do not allow it to exceed end_index_.
+  // Keeps read_index_ aligned.
+  void Advance(size_t size);
+
+  // Get read pointer for Type and advance read pointer.
+  template<typename Type>
+  const char* GetReadPointerAndAdvance();
+
+  // Get read pointer for |num_bytes| and advance read pointer. This method
+  // checks num_bytes for negativity and wrapping.
+  const char* GetReadPointerAndAdvance(int num_bytes);
+
+  // Get read pointer for (num_elements * size_element) bytes and advance read
+  // pointer. This method checks for int overflow, negativity and wrapping.
+  const char* GetReadPointerAndAdvance(int num_elements,
+                                       size_t size_element);
+
+  const char* payload_;  // Start of our pickle's payload.
+  size_t read_index_;  // Offset of the next readable byte in payload.
+  size_t end_index_;  // Payload size.
+
+  FRIEND_TEST_ALL_PREFIXES(PickleTest, GetReadPointerAndAdvance);
+};
+
+// This class provides facilities for basic binary value packing and unpacking.
+//
+// The Pickle class supports appending primitive values (ints, strings, etc.)
+// to a pickle instance.  The Pickle instance grows its internal memory buffer
+// dynamically to hold the sequence of primitive values.   The internal memory
+// buffer is exposed as the "data" of the Pickle.  This "data" can be passed
+// to a Pickle object to initialize it for reading.
+//
+// When reading from a Pickle object, it is important for the consumer to know
+// what value types to read and in what order to read them as the Pickle does
+// not keep track of the type of data written to it.
+//
+// The Pickle's data has a header which contains the size of the Pickle's
+// payload.  It can optionally support additional space in the header.  That
+// space is controlled by the header_size parameter passed to the Pickle
+// constructor.
+//
+class BASE_EXPORT Pickle {
+ public:
+  // Auxiliary data attached to a Pickle. Pickle must be subclassed along with
+  // this interface in order to provide a concrete implementation of support
+  // for attachments. The base Pickle implementation does not accept
+  // attachments.
+  class BASE_EXPORT Attachment : public RefCountedThreadSafe<Attachment> {
+   public:
+    Attachment();
+
+   protected:
+    friend class RefCountedThreadSafe<Attachment>;
+    virtual ~Attachment();
+
+    DISALLOW_COPY_AND_ASSIGN(Attachment);
+  };
+
+  // Initialize a Pickle object using the default header size.
+  Pickle();
+
+  // Initialize a Pickle object with the specified header size in bytes, which
+  // must be greater-than-or-equal-to sizeof(Pickle::Header).  The header size
+  // will be rounded up to ensure that the header size is 32bit-aligned.
+  explicit Pickle(int header_size);
+
+  // Initializes a Pickle from a const block of data.  The data is not copied;
+  // instead the data is merely referenced by this Pickle.  Only const methods
+  // should be used on the Pickle when initialized this way.  The header
+  // padding size is deduced from the data length.
+  Pickle(const char* data, int data_len);
+
+  // Initializes a Pickle as a deep copy of another Pickle.
+  Pickle(const Pickle& other);
+
+  // Note: There are no virtual methods in this class.  This destructor is
+  // virtual as an element of defensive coding.  Other classes have derived from
+  // this class, and there is a *chance* that they will cast into this base
+  // class before destruction.  At least one such class does have a virtual
+  // destructor, suggesting at least some need to call more derived destructors.
+  virtual ~Pickle();
+
+  // Performs a deep copy.
+  Pickle& operator=(const Pickle& other);
+
+  // Returns the number of bytes written in the Pickle, including the header.
+  size_t size() const { return header_size_ + header_->payload_size; }
+
+  // Returns the data for this Pickle.
+  const void* data() const { return header_; }
+
+  // Returns the effective memory capacity of this Pickle, that is, the total
+  // number of bytes currently dynamically allocated or 0 in the case of a
+  // read-only Pickle. This should be used only for diagnostic / profiling
+  // purposes.
+  size_t GetTotalAllocatedSize() const;
+
+  // Methods for adding to the payload of the Pickle.  These values are
+  // appended to the end of the Pickle's payload.  When reading values from a
+  // Pickle, it is important to read them in the order in which they were added
+  // to the Pickle.
+
+  void WriteBool(bool value) { WriteInt(value ? 1 : 0); }
+  void WriteInt(int value) { WritePOD(value); }
+  void WriteLong(long value) {
+    // Always write long as a 64-bit value to ensure compatibility between
+    // 32-bit and 64-bit processes.
+    WritePOD(static_cast<int64_t>(value));
+  }
+  void WriteUInt16(uint16_t value) { WritePOD(value); }
+  void WriteUInt32(uint32_t value) { WritePOD(value); }
+  void WriteInt64(int64_t value) { WritePOD(value); }
+  void WriteUInt64(uint64_t value) { WritePOD(value); }
+  void WriteFloat(float value) { WritePOD(value); }
+  void WriteDouble(double value) { WritePOD(value); }
+  void WriteString(const StringPiece& value);
+  void WriteString16(const StringPiece16& value);
+  // "Data" is a blob with a length. When you read it out you will be given the
+  // length. See also WriteBytes.
+  void WriteData(const char* data, int length);
+  // "Bytes" is a blob with no length. The caller must specify the length both
+  // when reading and writing. It is normally used to serialize PoD types of a
+  // known size. See also WriteData.
+  void WriteBytes(const void* data, int length);
+
+  // WriteAttachment appends |attachment| to the pickle. It returns
+  // false iff the set is full or if the Pickle implementation does not support
+  // attachments.
+  virtual bool WriteAttachment(scoped_refptr<Attachment> attachment);
+
+  // ReadAttachment parses an attachment given the parsing state |iter| and
+  // writes it to |*attachment|. It returns true on success.
+  virtual bool ReadAttachment(base::PickleIterator* iter,
+                              scoped_refptr<Attachment>* attachment) const;
+
+  // Indicates whether the pickle has any attachments.
+  virtual bool HasAttachments() const;
+
+  // Reserves space for upcoming writes when multiple writes will be made and
+  // their sizes are computed in advance. It can be significantly faster to call
+  // Reserve() before calling WriteFoo() multiple times.
+  void Reserve(size_t additional_capacity);
+
+  // Payload follows after allocation of Header (header size is customizable).
+  struct Header {
+    uint32_t payload_size;  // Specifies the size of the payload.
+  };
+
+  // Returns the header, cast to a user-specified type T.  The type T must be a
+  // subclass of Header and its size must correspond to the header_size passed
+  // to the Pickle constructor.
+  template <class T>
+  T* headerT() {
+    DCHECK_EQ(header_size_, sizeof(T));
+    return static_cast<T*>(header_);
+  }
+  template <class T>
+  const T* headerT() const {
+    DCHECK_EQ(header_size_, sizeof(T));
+    return static_cast<const T*>(header_);
+  }
+
+  // The payload is the pickle data immediately following the header.
+  size_t payload_size() const {
+    return header_ ? header_->payload_size : 0;
+  }
+
+  const char* payload() const {
+    return reinterpret_cast<const char*>(header_) + header_size_;
+  }
+
+  // Returns the address of the byte immediately following the currently valid
+  // header + payload.
+  const char* end_of_payload() const {
+    // This object may be invalid.
+    return header_ ? payload() + payload_size() : NULL;
+  }
+
+ protected:
+  // Returns size of the header, which can have default value, set by user or
+  // calculated by passed raw data.
+  size_t header_size() const { return header_size_; }
+
+  char* mutable_payload() {
+    return reinterpret_cast<char*>(header_) + header_size_;
+  }
+
+  size_t capacity_after_header() const {
+    return capacity_after_header_;
+  }
+
+  // Resize the capacity, note that the input value should not include the size
+  // of the header.
+  void Resize(size_t new_capacity);
+
+  // Claims |num_bytes| bytes of payload. This is similar to Reserve() in that
+  // it may grow the capacity, but it also advances the write offset of the
+  // pickle by |num_bytes|. Claimed memory, including padding, is zeroed.
+  //
+  // Returns the address of the first byte claimed.
+  void* ClaimBytes(size_t num_bytes);
+
+  // Find the end of the pickled data that starts at range_start.  Returns NULL
+  // if the entire Pickle is not found in the given data range.
+  static const char* FindNext(size_t header_size,
+                              const char* range_start,
+                              const char* range_end);
+
+  // Parse pickle header and return total size of the pickle. Data range
+  // doesn't need to contain entire pickle.
+  // Returns true if pickle header was found and parsed. Callers must check
+  // returned |pickle_size| for sanity (against maximum message size, etc).
+  // NOTE: when function successfully parses a header, but encounters an
+  // overflow during pickle size calculation, it sets |pickle_size| to the
+  // maximum size_t value and returns true.
+  static bool PeekNext(size_t header_size,
+                       const char* range_start,
+                       const char* range_end,
+                       size_t* pickle_size);
+
+  // The allocation granularity of the payload.
+  static const int kPayloadUnit;
+
+ private:
+  friend class PickleIterator;
+
+  Header* header_;
+  size_t header_size_;  // Supports extra data between header and payload.
+  // Allocation size of payload (or -1 if allocation is const). Note: this
+  // doesn't count the header.
+  size_t capacity_after_header_;
+  // The offset at which we will write the next field. Note: this doesn't count
+  // the header.
+  size_t write_offset_;
+
+  // Just like WriteBytes, but with a compile-time size, for performance.
+  template<size_t length> void BASE_EXPORT WriteBytesStatic(const void* data);
+
+  // Writes a POD by copying its bytes.
+  template <typename T> bool WritePOD(const T& data) {
+    WriteBytesStatic<sizeof(data)>(&data);
+    return true;
+  }
+
+  inline void* ClaimUninitializedBytesInternal(size_t num_bytes);
+  inline void WriteBytesCommon(const void* data, size_t length);
+
+  FRIEND_TEST_ALL_PREFIXES(PickleTest, DeepCopyResize);
+  FRIEND_TEST_ALL_PREFIXES(PickleTest, Resize);
+  FRIEND_TEST_ALL_PREFIXES(PickleTest, PeekNext);
+  FRIEND_TEST_ALL_PREFIXES(PickleTest, PeekNextOverflow);
+  FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNext);
+  FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextWithIncompleteHeader);
+  FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextOverflow);
+};
+
+}  // namespace base
+
+#endif  // BASE_PICKLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/posix/eintr_wrapper.h b/native/zucchini/vendor/libchrome/base/posix/eintr_wrapper.h
new file mode 100644
index 0000000..0e6e437
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/posix/eintr_wrapper.h
@@ -0,0 +1,68 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This provides a wrapper around system calls which may be interrupted by a
+// signal and return EINTR. See man 7 signal.
+// To prevent long-lasting loops (which would likely be a bug, such as a signal
+// that should be masked) to go unnoticed, there is a limit after which the
+// caller will nonetheless see an EINTR in Debug builds.
+//
+// On Windows and Fuchsia, this wrapper macro does nothing because there are no
+// signals.
+//
+// Don't wrap close calls in HANDLE_EINTR. Use IGNORE_EINTR if the return
+// value of close is significant. See http://crbug.com/269623.
+
+#ifndef BASE_POSIX_EINTR_WRAPPER_H_
+#define BASE_POSIX_EINTR_WRAPPER_H_
+
+#include "build/build_config.h"
+
+#if defined(OS_POSIX)
+
+#include <errno.h>
+
+#if defined(NDEBUG)
+
+#define HANDLE_EINTR(x) ({ \
+  decltype(x) eintr_wrapper_result; \
+  do { \
+    eintr_wrapper_result = (x); \
+  } while (eintr_wrapper_result == -1 && errno == EINTR); \
+  eintr_wrapper_result; \
+})
+
+#else
+
+#define HANDLE_EINTR(x) ({ \
+  int eintr_wrapper_counter = 0; \
+  decltype(x) eintr_wrapper_result; \
+  do { \
+    eintr_wrapper_result = (x); \
+  } while (eintr_wrapper_result == -1 && errno == EINTR && \
+           eintr_wrapper_counter++ < 100); \
+  eintr_wrapper_result; \
+})
+
+#endif  // NDEBUG
+
+#define IGNORE_EINTR(x) ({ \
+  decltype(x) eintr_wrapper_result; \
+  do { \
+    eintr_wrapper_result = (x); \
+    if (eintr_wrapper_result == -1 && errno == EINTR) { \
+      eintr_wrapper_result = 0; \
+    } \
+  } while (0); \
+  eintr_wrapper_result; \
+})
+
+#else  // !OS_POSIX
+
+#define HANDLE_EINTR(x) (x)
+#define IGNORE_EINTR(x) (x)
+
+#endif  // !OS_POSIX
+
+#endif  // BASE_POSIX_EINTR_WRAPPER_H_
diff --git a/native/zucchini/vendor/libchrome/base/posix/file_descriptor_shuffle.h b/native/zucchini/vendor/libchrome/base/posix/file_descriptor_shuffle.h
new file mode 100644
index 0000000..2afdc28
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/posix/file_descriptor_shuffle.h
@@ -0,0 +1,87 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_POSIX_FILE_DESCRIPTOR_SHUFFLE_H_
+#define BASE_POSIX_FILE_DESCRIPTOR_SHUFFLE_H_
+
+// This code exists to shuffle file descriptors, which is commonly needed when
+// forking subprocesses. The naive approach (just call dup2 to set up the
+// desired descriptors) is very simple, but wrong: it won't handle edge cases
+// (like mapping 0 -> 1, 1 -> 0) correctly.
+//
+// In order to unittest this code, it's broken into the abstract action (an
+// injective multimap) and the concrete code for dealing with file descriptors.
+// Users should use the code like this:
+//   base::InjectiveMultimap file_descriptor_map;
+//   file_descriptor_map.push_back(base::InjectionArc(devnull, 0, true));
+//   file_descriptor_map.push_back(base::InjectionArc(devnull, 2, true));
+//   file_descriptor_map.push_back(base::InjectionArc(pipe[1], 1, true));
+//   base::ShuffleFileDescriptors(file_descriptor_map);
+//
+// and trust the the Right Thing will get done.
+
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/compiler_specific.h"
+
+namespace base {
+
+// A Delegate which performs the actions required to perform an injective
+// multimapping in place.
+class InjectionDelegate {
+ public:
+  // Duplicate |fd|, an element of the domain, and write a fresh element of the
+  // domain into |result|. Returns true iff successful.
+  virtual bool Duplicate(int* result, int fd) = 0;
+  // Destructively move |src| to |dest|, overwriting |dest|. Returns true iff
+  // successful.
+  virtual bool Move(int src, int dest) = 0;
+  // Delete an element of the domain.
+  virtual void Close(int fd) = 0;
+
+ protected:
+  virtual ~InjectionDelegate() = default;
+};
+
+// An implementation of the InjectionDelegate interface using the file
+// descriptor table of the current process as the domain.
+class BASE_EXPORT FileDescriptorTableInjection : public InjectionDelegate {
+  bool Duplicate(int* result, int fd) override;
+  bool Move(int src, int dest) override;
+  void Close(int fd) override;
+};
+
+// A single arc of the directed graph which describes an injective multimapping.
+struct InjectionArc {
+  InjectionArc(int in_source, int in_dest, bool in_close)
+      : source(in_source),
+        dest(in_dest),
+        close(in_close) {
+  }
+
+  int source;
+  int dest;
+  bool close;  // if true, delete the source element after performing the
+               // mapping.
+};
+
+typedef std::vector<InjectionArc> InjectiveMultimap;
+
+BASE_EXPORT bool PerformInjectiveMultimap(const InjectiveMultimap& map,
+                                          InjectionDelegate* delegate);
+
+BASE_EXPORT bool PerformInjectiveMultimapDestructive(
+    InjectiveMultimap* map,
+    InjectionDelegate* delegate);
+
+// This function will not call malloc but will mutate |map|
+static inline bool ShuffleFileDescriptors(InjectiveMultimap* map) {
+  FileDescriptorTableInjection delegate;
+  return PerformInjectiveMultimapDestructive(map, &delegate);
+}
+
+}  // namespace base
+
+#endif  // BASE_POSIX_FILE_DESCRIPTOR_SHUFFLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/posix/safe_strerror.h b/native/zucchini/vendor/libchrome/base/posix/safe_strerror.h
new file mode 100644
index 0000000..2945312
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/posix/safe_strerror.h
@@ -0,0 +1,44 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_POSIX_SAFE_STRERROR_H_
+#define BASE_POSIX_SAFE_STRERROR_H_
+
+#include <stddef.h>
+
+#include <string>
+
+#include "base/base_export.h"
+
+namespace base {
+
+// BEFORE using anything from this file, first look at PLOG and friends in
+// logging.h and use them instead if applicable.
+//
+// This file declares safe, portable alternatives to the POSIX strerror()
+// function. strerror() is inherently unsafe in multi-threaded apps and should
+// never be used. Doing so can cause crashes. Additionally, the thread-safe
+// alternative strerror_r varies in semantics across platforms. Use these
+// functions instead.
+
+// Thread-safe strerror function with dependable semantics that never fails.
+// It will write the string form of error "err" to buffer buf of length len.
+// If there is an error calling the OS's strerror_r() function then a message to
+// that effect will be printed into buf, truncating if necessary. The final
+// result is always null-terminated. The value of errno is never changed.
+//
+// Use this instead of strerror_r().
+BASE_EXPORT void safe_strerror_r(int err, char *buf, size_t len);
+
+// Calls safe_strerror_r with a buffer of suitable size and returns the result
+// in a C++ string.
+//
+// Use this instead of strerror(). Note though that safe_strerror_r will be
+// more robust in the case of heap corruption errors, since it doesn't need to
+// allocate a string.
+BASE_EXPORT std::string safe_strerror(int err);
+
+}  // namespace base
+
+#endif  // BASE_POSIX_SAFE_STRERROR_H_
diff --git a/native/zucchini/vendor/libchrome/base/process/launch.h b/native/zucchini/vendor/libchrome/base/process/launch.h
new file mode 100644
index 0000000..7a2def2
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/process/launch.h
@@ -0,0 +1,396 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file contains functions for launching subprocesses.
+
+#ifndef BASE_PROCESS_LAUNCH_H_
+#define BASE_PROCESS_LAUNCH_H_
+
+#include <stddef.h>
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/environment.h"
+#include "base/macros.h"
+#include "base/process/process.h"
+#include "base/process/process_handle.h"
+#include "base/strings/string_piece.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+#elif defined(OS_FUCHSIA)
+#include <lib/fdio/spawn.h>
+#include <zircon/types.h>
+#endif
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+#include "base/posix/file_descriptor_shuffle.h"
+#endif
+
+namespace base {
+
+class CommandLine;
+
+#if defined(OS_WIN)
+typedef std::vector<HANDLE> HandlesToInheritVector;
+#elif defined(OS_FUCHSIA)
+struct PathToTransfer {
+  base::FilePath path;
+  zx_handle_t handle;
+};
+struct HandleToTransfer {
+  uint32_t id;
+  zx_handle_t handle;
+};
+typedef std::vector<HandleToTransfer> HandlesToTransferVector;
+typedef std::vector<std::pair<int, int>> FileHandleMappingVector;
+#elif defined(OS_POSIX)
+typedef std::vector<std::pair<int, int>> FileHandleMappingVector;
+#endif  // defined(OS_WIN)
+
+// Options for launching a subprocess that are passed to LaunchProcess().
+// The default constructor constructs the object with default options.
+struct BASE_EXPORT LaunchOptions {
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+  // Delegate to be run in between fork and exec in the subprocess (see
+  // pre_exec_delegate below)
+  class BASE_EXPORT PreExecDelegate {
+   public:
+    PreExecDelegate() = default;
+    virtual ~PreExecDelegate() = default;
+
+    // Since this is to be run between fork and exec, and fork may have happened
+    // while multiple threads were running, this function needs to be async
+    // safe.
+    virtual void RunAsyncSafe() = 0;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(PreExecDelegate);
+  };
+#endif  // defined(OS_POSIX)
+
+  LaunchOptions();
+  LaunchOptions(const LaunchOptions&);
+  ~LaunchOptions();
+
+  // If true, wait for the process to complete.
+  bool wait = false;
+
+  // If not empty, change to this directory before executing the new process.
+  base::FilePath current_directory;
+
+#if defined(OS_WIN)
+  bool start_hidden = false;
+
+  // Windows can inherit handles when it launches child processes.
+  // See https://blogs.msdn.microsoft.com/oldnewthing/20111216-00/?p=8873
+  // for a good overview of Windows handle inheritance.
+  //
+  // Implementation note: it might be nice to implement in terms of
+  // base::Optional<>, but then the natural default state (vector not present)
+  // would be "all inheritable handles" while we want "no inheritance."
+  enum class Inherit {
+    // Only those handles in |handles_to_inherit| vector are inherited. If the
+    // vector is empty, no handles are inherited. The handles in the vector must
+    // all be inheritable.
+    kSpecific,
+
+    // All handles in the current process which are inheritable are inherited.
+    // In production code this flag should be used only when running
+    // short-lived, trusted binaries, because open handles from other libraries
+    // and subsystems will leak to the child process, causing errors such as
+    // open socket hangs. There are also race conditions that can cause handle
+    // over-sharing.
+    //
+    // |handles_to_inherit| must be null.
+    //
+    // DEPRECATED. THIS SHOULD NOT BE USED. Explicitly map all handles that
+    // need to be shared in new code.
+    // TODO(brettw) bug 748258: remove this.
+    kAll
+  };
+  Inherit inherit_mode = Inherit::kSpecific;
+  HandlesToInheritVector handles_to_inherit;
+
+  // If non-null, runs as if the user represented by the token had launched it.
+  // Whether the application is visible on the interactive desktop depends on
+  // the token belonging to an interactive logon session.
+  //
+  // To avoid hard to diagnose problems, when specified this loads the
+  // environment variables associated with the user and if this operation fails
+  // the entire call fails as well.
+  UserTokenHandle as_user = nullptr;
+
+  // If true, use an empty string for the desktop name.
+  bool empty_desktop_name = false;
+
+  // If non-null, launches the application in that job object. The process will
+  // be terminated immediately and LaunchProcess() will fail if assignment to
+  // the job object fails.
+  HANDLE job_handle = nullptr;
+
+  // Handles for the redirection of stdin, stdout and stderr. The caller should
+  // either set all three of them or none (i.e. there is no way to redirect
+  // stderr without redirecting stdin).
+  //
+  // The handles must be inheritable. Pseudo handles are used when stdout and
+  // stderr redirect to the console. In that case, GetFileType() will return
+  // FILE_TYPE_CHAR and they're automatically inherited by child processes. See
+  // https://msdn.microsoft.com/en-us/library/windows/desktop/ms682075.aspx
+  // Otherwise, the caller must ensure that the |inherit_mode| and/or
+  // |handles_to_inherit| set so that the handles are inherited.
+  HANDLE stdin_handle = nullptr;
+  HANDLE stdout_handle = nullptr;
+  HANDLE stderr_handle = nullptr;
+
+  // If set to true, ensures that the child process is launched with the
+  // CREATE_BREAKAWAY_FROM_JOB flag which allows it to breakout of the parent
+  // job if any.
+  bool force_breakaway_from_job_ = false;
+
+  // If set to true, permission to bring windows to the foreground is passed to
+  // the launched process if the current process has such permission.
+  bool grant_foreground_privilege = false;
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  // Set/unset environment variables. These are applied on top of the parent
+  // process environment.  Empty (the default) means to inherit the same
+  // environment. See AlterEnvironment().
+  EnvironmentMap environ;
+
+  // Clear the environment for the new process before processing changes from
+  // |environ|.
+  bool clear_environ = false;
+
+  // Remap file descriptors according to the mapping of src_fd->dest_fd to
+  // propagate FDs into the child process.
+  FileHandleMappingVector fds_to_remap;
+#endif  // defined(OS_WIN)
+
+#if defined(OS_LINUX)
+  // If non-zero, start the process using clone(), using flags as provided.
+  // Unlike in clone, clone_flags may not contain a custom termination signal
+  // that is sent to the parent when the child dies. The termination signal will
+  // always be set to SIGCHLD.
+  int clone_flags = 0;
+
+  // By default, child processes will have the PR_SET_NO_NEW_PRIVS bit set. If
+  // true, then this bit will not be set in the new child process.
+  bool allow_new_privs = false;
+
+  // Sets parent process death signal to SIGKILL.
+  bool kill_on_parent_death = false;
+#endif  // defined(OS_LINUX)
+
+#if defined(OS_FUCHSIA)
+  // If valid, launches the application in that job object.
+  zx_handle_t job_handle = ZX_HANDLE_INVALID;
+
+  // Specifies additional handles to transfer (not duplicate) to the child
+  // process. Each entry is an <id,handle> pair, with an |id| created using the
+  // PA_HND() macro. The child retrieves the handle
+  // |zx_take_startup_handle(id)|. The supplied handles are consumed by
+  // LaunchProcess() even on failure.
+  HandlesToTransferVector handles_to_transfer;
+
+  // Specifies which basic capabilities to grant to the child process.
+  // By default the child process will receive the caller's complete namespace,
+  // access to the current base::fuchsia::DefaultJob(), handles for stdio and
+  // access to the dynamic library loader.
+  // Note that the child is always provided access to the loader service.
+  uint32_t spawn_flags = FDIO_SPAWN_CLONE_NAMESPACE | FDIO_SPAWN_CLONE_STDIO |
+                         FDIO_SPAWN_CLONE_JOB;
+
+  // Specifies paths to clone from the calling process' namespace into that of
+  // the child process. If |paths_to_clone| is empty then the process will
+  // receive either a full copy of the parent's namespace, or an empty one,
+  // depending on whether FDIO_SPAWN_CLONE_NAMESPACE is set.
+  std::vector<FilePath> paths_to_clone;
+
+  // Specifies handles which will be installed as files or directories in the
+  // child process' namespace. Paths installed by |paths_to_clone| will be
+  // overridden by these entries.
+  std::vector<PathToTransfer> paths_to_transfer;
+#endif  // defined(OS_FUCHSIA)
+
+#if defined(OS_POSIX)
+  // If not empty, launch the specified executable instead of
+  // cmdline.GetProgram(). This is useful when it is necessary to pass a custom
+  // argv[0].
+  base::FilePath real_path;
+
+  // If non-null, a delegate to be run immediately prior to executing the new
+  // program in the child process.
+  //
+  // WARNING: If LaunchProcess is called in the presence of multiple threads,
+  // code running in this delegate essentially needs to be async-signal safe
+  // (see man 7 signal for a list of allowed functions).
+  PreExecDelegate* pre_exec_delegate = nullptr;
+
+  // Each element is an RLIMIT_* constant that should be raised to its
+  // rlim_max.  This pointer is owned by the caller and must live through
+  // the call to LaunchProcess().
+  const std::vector<int>* maximize_rlimits = nullptr;
+
+  // If true, start the process in a new process group, instead of
+  // inheriting the parent's process group.  The pgid of the child process
+  // will be the same as its pid.
+  bool new_process_group = false;
+#endif  // defined(OS_POSIX)
+
+#if defined(OS_CHROMEOS)
+  // If non-negative, the specified file descriptor will be set as the launched
+  // process' controlling terminal.
+  int ctrl_terminal_fd = -1;
+#endif  // defined(OS_CHROMEOS)
+};
+
+// Launch a process via the command line |cmdline|.
+// See the documentation of LaunchOptions for details on |options|.
+//
+// Returns a valid Process upon success.
+//
+// Unix-specific notes:
+// - All file descriptors open in the parent process will be closed in the
+//   child process except for any preserved by options::fds_to_remap, and
+//   stdin, stdout, and stderr. If not remapped by options::fds_to_remap,
+//   stdin is reopened as /dev/null, and the child is allowed to inherit its
+//   parent's stdout and stderr.
+// - If the first argument on the command line does not contain a slash,
+//   PATH will be searched.  (See man execvp.)
+BASE_EXPORT Process LaunchProcess(const CommandLine& cmdline,
+                                  const LaunchOptions& options);
+
+#if defined(OS_WIN)
+// Windows-specific LaunchProcess that takes the command line as a
+// string.  Useful for situations where you need to control the
+// command line arguments directly, but prefer the CommandLine version
+// if launching Chrome itself.
+//
+// The first command line argument should be the path to the process,
+// and don't forget to quote it.
+//
+// Example (including literal quotes)
+//  cmdline = "c:\windows\explorer.exe" -foo "c:\bar\"
+BASE_EXPORT Process LaunchProcess(const string16& cmdline,
+                                  const LaunchOptions& options);
+
+// Launches a process with elevated privileges.  This does not behave exactly
+// like LaunchProcess as it uses ShellExecuteEx instead of CreateProcess to
+// create the process.  This means the process will have elevated privileges
+// and thus some common operations like OpenProcess will fail. Currently the
+// only supported LaunchOptions are |start_hidden| and |wait|.
+BASE_EXPORT Process LaunchElevatedProcess(const CommandLine& cmdline,
+                                          const LaunchOptions& options);
+
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+// A POSIX-specific version of LaunchProcess that takes an argv array
+// instead of a CommandLine.  Useful for situations where you need to
+// control the command line arguments directly, but prefer the
+// CommandLine version if launching Chrome itself.
+BASE_EXPORT Process LaunchProcess(const std::vector<std::string>& argv,
+                                  const LaunchOptions& options);
+
+// Close all file descriptors, except those which are a destination in the
+// given multimap. Only call this function in a child process where you know
+// that there aren't any other threads.
+BASE_EXPORT void CloseSuperfluousFds(const InjectiveMultimap& saved_map);
+#endif  // defined(OS_WIN)
+
+#if defined(OS_WIN)
+// Set |job_object|'s JOBOBJECT_EXTENDED_LIMIT_INFORMATION
+// BasicLimitInformation.LimitFlags to |limit_flags|.
+BASE_EXPORT bool SetJobObjectLimitFlags(HANDLE job_object, DWORD limit_flags);
+
+// Output multi-process printf, cout, cerr, etc to the cmd.exe console that ran
+// chrome. This is not thread-safe: only call from main thread.
+BASE_EXPORT void RouteStdioToConsole(bool create_console_if_not_found);
+#endif  // defined(OS_WIN)
+
+// Executes the application specified by |cl| and wait for it to exit. Stores
+// the output (stdout) in |output|. Redirects stderr to /dev/null. Returns true
+// on success (application launched and exited cleanly, with exit code
+// indicating success).
+BASE_EXPORT bool GetAppOutput(const CommandLine& cl, std::string* output);
+
+// Like GetAppOutput, but also includes stderr.
+BASE_EXPORT bool GetAppOutputAndError(const CommandLine& cl,
+                                      std::string* output);
+
+// A version of |GetAppOutput()| which also returns the exit code of the
+// executed command. Returns true if the application runs and exits cleanly. If
+// this is the case the exit code of the application is available in
+// |*exit_code|.
+BASE_EXPORT bool GetAppOutputWithExitCode(const CommandLine& cl,
+                                          std::string* output, int* exit_code);
+
+#if defined(OS_WIN)
+// A Windows-specific version of GetAppOutput that takes a command line string
+// instead of a CommandLine object. Useful for situations where you need to
+// control the command line arguments directly.
+BASE_EXPORT bool GetAppOutput(const StringPiece16& cl, std::string* output);
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+// A POSIX-specific version of GetAppOutput that takes an argv array
+// instead of a CommandLine.  Useful for situations where you need to
+// control the command line arguments directly.
+BASE_EXPORT bool GetAppOutput(const std::vector<std::string>& argv,
+                              std::string* output);
+
+// Like the above POSIX-specific version of GetAppOutput, but also includes
+// stderr.
+BASE_EXPORT bool GetAppOutputAndError(const std::vector<std::string>& argv,
+                                      std::string* output);
+#endif  // defined(OS_WIN)
+
+// If supported on the platform, and the user has sufficent rights, increase
+// the current process's scheduling priority to a high priority.
+BASE_EXPORT void RaiseProcessToHighPriority();
+
+#if defined(OS_MACOSX)
+// An implementation of LaunchProcess() that uses posix_spawn() instead of
+// fork()+exec(). This does not support the |pre_exec_delegate| and
+// |current_directory| options.
+Process LaunchProcessPosixSpawn(const std::vector<std::string>& argv,
+                                const LaunchOptions& options);
+
+// Restore the default exception handler, setting it to Apple Crash Reporter
+// (ReportCrash).  When forking and execing a new process, the child will
+// inherit the parent's exception ports, which may be set to the Breakpad
+// instance running inside the parent.  The parent's Breakpad instance should
+// not handle the child's exceptions.  Calling RestoreDefaultExceptionHandler
+// in the child after forking will restore the standard exception handler.
+// See http://crbug.com/20371/ for more details.
+void RestoreDefaultExceptionHandler();
+#endif  // defined(OS_MACOSX)
+
+// Creates a LaunchOptions object suitable for launching processes in a test
+// binary. This should not be called in production/released code.
+BASE_EXPORT LaunchOptions LaunchOptionsForTest();
+
+#if defined(OS_LINUX) || defined(OS_NACL_NONSFI)
+// A wrapper for clone with fork-like behavior, meaning that it returns the
+// child's pid in the parent and 0 in the child. |flags|, |ptid|, and |ctid| are
+// as in the clone system call (the CLONE_VM flag is not supported).
+//
+// This function uses the libc clone wrapper (which updates libc's pid cache)
+// internally, so callers may expect things like getpid() to work correctly
+// after in both the child and parent.
+//
+// As with fork(), callers should be extremely careful when calling this while
+// multiple threads are running, since at the time the fork happened, the
+// threads could have been in any state (potentially holding locks, etc.).
+// Callers should most likely call execve() in the child soon after calling
+// this.
+//
+// It is unsafe to use any pthread APIs after ForkWithFlags().
+// However, performing an exec() will lift this restriction.
+BASE_EXPORT pid_t ForkWithFlags(unsigned long flags, pid_t* ptid, pid_t* ctid);
+#endif
+
+}  // namespace base
+
+#endif  // BASE_PROCESS_LAUNCH_H_
diff --git a/native/zucchini/vendor/libchrome/base/process/process.h b/native/zucchini/vendor/libchrome/base/process/process.h
new file mode 100644
index 0000000..674cea3
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/process/process.h
@@ -0,0 +1,213 @@
+// Copyright 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_PROCESS_PROCESS_H_
+#define BASE_PROCESS_PROCESS_H_
+
+#include "base/base_export.h"
+#include "base/macros.h"
+#include "base/process/process_handle.h"
+#include "base/time/time.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include "base/win/scoped_handle.h"
+#endif
+
+#if defined(OS_FUCHSIA)
+#include <lib/zx/process.h>
+#endif
+
+#if defined(OS_MACOSX)
+#include "base/feature_list.h"
+#include "base/process/port_provider_mac.h"
+#endif
+
+namespace base {
+
+#if defined(OS_MACOSX)
+extern const Feature kMacAllowBackgroundingProcesses;
+#endif
+
+// Provides a move-only encapsulation of a process.
+//
+// This object is not tied to the lifetime of the underlying process: the
+// process may be killed and this object may still around, and it will still
+// claim to be valid. The actual behavior in that case is OS dependent like so:
+//
+// Windows: The underlying ProcessHandle will be valid after the process dies
+// and can be used to gather some information about that process, but most
+// methods will obviously fail.
+//
+// POSIX: The underlying ProcessHandle is not guaranteed to remain valid after
+// the process dies, and it may be reused by the system, which means that it may
+// end up pointing to the wrong process.
+class BASE_EXPORT Process {
+ public:
+  // On Windows, this takes ownership of |handle|. On POSIX, this does not take
+  // ownership of |handle|.
+  explicit Process(ProcessHandle handle = kNullProcessHandle);
+
+  Process(Process&& other);
+
+  // The destructor does not terminate the process.
+  ~Process();
+
+  Process& operator=(Process&& other);
+
+  // Returns an object for the current process.
+  static Process Current();
+
+  // Returns a Process for the given |pid|.
+  static Process Open(ProcessId pid);
+
+  // Returns a Process for the given |pid|. On Windows the handle is opened
+  // with more access rights and must only be used by trusted code (can read the
+  // address space and duplicate handles).
+  static Process OpenWithExtraPrivileges(ProcessId pid);
+
+#if defined(OS_WIN)
+  // Returns a Process for the given |pid|, using some |desired_access|.
+  // See ::OpenProcess documentation for valid |desired_access|.
+  static Process OpenWithAccess(ProcessId pid, DWORD desired_access);
+#endif
+
+  // Creates an object from a |handle| owned by someone else.
+  // Don't use this for new code. It is only intended to ease the migration to
+  // a strict ownership model.
+  // TODO(rvargas) crbug.com/417532: Remove this code.
+  static Process DeprecatedGetProcessFromHandle(ProcessHandle handle);
+
+  // Returns true if processes can be backgrounded.
+  static bool CanBackgroundProcesses();
+
+  // Terminates the current process immediately with |exit_code|.
+  [[noreturn]] static void TerminateCurrentProcessImmediately(int exit_code);
+
+  // Returns true if this objects represents a valid process.
+  bool IsValid() const;
+
+  // Returns a handle for this process. There is no guarantee about when that
+  // handle becomes invalid because this object retains ownership.
+  ProcessHandle Handle() const;
+
+  // Returns a second object that represents this process.
+  Process Duplicate() const;
+
+  // Get the PID for this process.
+  ProcessId Pid() const;
+
+  // Returns true if this process is the current process.
+  bool is_current() const;
+
+  // Close the process handle. This will not terminate the process.
+  void Close();
+
+  // Returns true if this process is still running. This is only safe on Windows
+  // (and maybe Fuchsia?), because the ProcessHandle will keep the zombie
+  // process information available until itself has been released. But on Posix,
+  // the OS may reuse the ProcessId.
+#if defined(OS_WIN)
+  bool IsRunning() const {
+    return !WaitForExitWithTimeout(base::TimeDelta(), nullptr);
+  }
+#endif
+
+  // Terminates the process with extreme prejudice. The given |exit_code| will
+  // be the exit code of the process. If |wait| is true, this method will wait
+  // for up to one minute for the process to actually terminate.
+  // Returns true if the process terminates within the allowed time.
+  // NOTE: On POSIX |exit_code| is ignored.
+  bool Terminate(int exit_code, bool wait) const;
+
+  // Waits for the process to exit. Returns true on success.
+  // On POSIX, if the process has been signaled then |exit_code| is set to -1.
+  // On Linux this must be a child process, however on Mac and Windows it can be
+  // any process.
+  // NOTE: |exit_code| is optional, nullptr can be passed if the exit code is
+  // not required.
+  bool WaitForExit(int* exit_code) const;
+
+  // Same as WaitForExit() but only waits for up to |timeout|.
+  // NOTE: |exit_code| is optional, nullptr can be passed if the exit code
+  // is not required.
+  bool WaitForExitWithTimeout(TimeDelta timeout, int* exit_code) const;
+
+  // Indicates that the process has exited with the specified |exit_code|.
+  // This should be called if process exit is observed outside of this class.
+  // (i.e. Not because Terminate or WaitForExit, above, was called.)
+  // Note that nothing prevents this being called multiple times for a dead
+  // process though that should be avoided.
+  void Exited(int exit_code) const;
+
+#if defined(OS_MACOSX)
+  // The Mac needs a Mach port in order to manipulate a process's priority,
+  // and there's no good way to get that from base given the pid. These Mac
+  // variants of the IsProcessBackgrounded and SetProcessBackgrounded API take
+  // a port provider for this reason. See crbug.com/460102
+  //
+  // A process is backgrounded when its task priority is
+  // |TASK_BACKGROUND_APPLICATION|.
+  //
+  // Returns true if the port_provider can locate a task port for the process
+  // and it is backgrounded. If port_provider is null, returns false.
+  bool IsProcessBackgrounded(PortProvider* port_provider) const;
+
+  // Set the process as backgrounded. If value is
+  // true, the priority of the associated task will be set to
+  // TASK_BACKGROUND_APPLICATION. If value is false, the
+  // priority of the process will be set to TASK_FOREGROUND_APPLICATION.
+  //
+  // Returns true if the priority was changed, false otherwise. If
+  // |port_provider| is null, this is a no-op and it returns false.
+  bool SetProcessBackgrounded(PortProvider* port_provider, bool value);
+#else
+  // A process is backgrounded when it's priority is lower than normal.
+  // Return true if this process is backgrounded, false otherwise.
+  bool IsProcessBackgrounded() const;
+
+  // Set a process as backgrounded. If value is true, the priority of the
+  // process will be lowered. If value is false, the priority of the process
+  // will be made "normal" - equivalent to default process priority.
+  // Returns true if the priority was changed, false otherwise.
+  bool SetProcessBackgrounded(bool value);
+#endif  // defined(OS_MACOSX)
+  // Returns an integer representing the priority of a process. The meaning
+  // of this value is OS dependent.
+  int GetPriority() const;
+
+#if defined(OS_CHROMEOS)
+  // Get the PID in its PID namespace.
+  // If the process is not in a PID namespace or /proc/<pid>/status does not
+  // report NSpid, kNullProcessId is returned.
+  ProcessId GetPidInNamespace() const;
+#endif
+
+ private:
+#if defined(OS_WIN)
+  win::ScopedHandle process_;
+#elif defined(OS_FUCHSIA)
+  zx::process process_;
+#else
+  ProcessHandle process_;
+#endif
+
+#if defined(OS_WIN) || defined(OS_FUCHSIA)
+  bool is_current_process_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(Process);
+};
+
+#if defined(OS_CHROMEOS)
+// Exposed for testing.
+// Given the contents of the /proc/<pid>/cgroup file, determine whether the
+// process is backgrounded or not.
+BASE_EXPORT bool IsProcessBackgroundedCGroup(
+    const StringPiece& cgroup_contents);
+#endif  // defined(OS_CHROMEOS)
+
+}  // namespace base
+
+#endif  // BASE_PROCESS_PROCESS_H_
diff --git a/native/zucchini/vendor/libchrome/base/process/process_handle.h b/native/zucchini/vendor/libchrome/base/process/process_handle.h
new file mode 100644
index 0000000..f3f6343
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/process/process_handle.h
@@ -0,0 +1,103 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_PROCESS_PROCESS_HANDLE_H_
+#define BASE_PROCESS_PROCESS_HANDLE_H_
+
+#include <stdint.h>
+#include <sys/types.h>
+
+#include "base/base_export.h"
+#include "base/files/file_path.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include "base/win/windows_types.h"
+#endif
+
+#if defined(OS_FUCHSIA)
+#include <zircon/types.h>
+#endif
+
+namespace base {
+
+// ProcessHandle is a platform specific type which represents the underlying OS
+// handle to a process.
+// ProcessId is a number which identifies the process in the OS.
+#if defined(OS_WIN)
+typedef HANDLE ProcessHandle;
+typedef DWORD ProcessId;
+typedef HANDLE UserTokenHandle;
+const ProcessHandle kNullProcessHandle = NULL;
+const ProcessId kNullProcessId = 0;
+#elif defined(OS_FUCHSIA)
+typedef zx_handle_t ProcessHandle;
+typedef zx_koid_t ProcessId;
+const ProcessHandle kNullProcessHandle = ZX_HANDLE_INVALID;
+const ProcessId kNullProcessId = ZX_KOID_INVALID;
+#elif defined(OS_POSIX)
+// On POSIX, our ProcessHandle will just be the PID.
+typedef pid_t ProcessHandle;
+typedef pid_t ProcessId;
+const ProcessHandle kNullProcessHandle = 0;
+const ProcessId kNullProcessId = 0;
+#endif  // defined(OS_WIN)
+
+// To print ProcessIds portably use CrPRIdPid (based on PRIuS and friends from
+// C99 and format_macros.h) like this:
+// base::StringPrintf("PID is %" CrPRIdPid ".\n", pid);
+#if defined(OS_WIN) || defined(OS_FUCHSIA)
+#define CrPRIdPid "ld"
+#else
+#define CrPRIdPid "d"
+#endif
+
+// Returns the id of the current process.
+// Note that on some platforms, this is not guaranteed to be unique across
+// processes (use GetUniqueIdForProcess if uniqueness is required).
+BASE_EXPORT ProcessId GetCurrentProcId();
+
+// Returns a unique ID for the current process. The ID will be unique across all
+// currently running processes within the chrome session, but IDs of terminated
+// processes may be reused. This returns an opaque value that is different from
+// a process's PID.
+BASE_EXPORT uint32_t GetUniqueIdForProcess();
+
+#if defined(OS_LINUX)
+// When a process is started in a different PID namespace from the browser
+// process, this function must be called with the process's PID in the browser's
+// PID namespace in order to initialize its unique ID. Not thread safe.
+// WARNING: To avoid inconsistent results from GetUniqueIdForProcess, this
+// should only be called very early after process startup - ideally as soon
+// after process creation as possible.
+BASE_EXPORT void InitUniqueIdForProcessInPidNamespace(
+    ProcessId pid_outside_of_namespace);
+#endif
+
+// Returns the ProcessHandle of the current process.
+BASE_EXPORT ProcessHandle GetCurrentProcessHandle();
+
+// Returns the process ID for the specified process. This is functionally the
+// same as Windows' GetProcessId(), but works on versions of Windows before Win
+// XP SP1 as well.
+// DEPRECATED. New code should be using Process::Pid() instead.
+// Note that on some platforms, this is not guaranteed to be unique across
+// processes.
+BASE_EXPORT ProcessId GetProcId(ProcessHandle process);
+
+#if !defined(OS_FUCHSIA)
+// Returns the ID for the parent of the given process. Not available on Fuchsia.
+// Returning a negative value indicates an error, such as if the |process| does
+// not exist. Returns 0 when |process| has no parent process.
+BASE_EXPORT ProcessId GetParentProcessId(ProcessHandle process);
+#endif  // !defined(OS_FUCHSIA)
+
+#if defined(OS_POSIX)
+// Returns the path to the executable of the given process.
+BASE_EXPORT FilePath GetProcessExecutablePath(ProcessHandle process);
+#endif
+
+}  // namespace base
+
+#endif  // BASE_PROCESS_PROCESS_HANDLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/scoped_clear_errno.h b/native/zucchini/vendor/libchrome/base/scoped_clear_errno.h
new file mode 100644
index 0000000..585f6f7
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/scoped_clear_errno.h
@@ -0,0 +1,34 @@
+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_SCOPED_CLEAR_ERRNO_H_
+#define BASE_SCOPED_CLEAR_ERRNO_H_
+
+#include <errno.h>
+
+#include "base/macros.h"
+
+namespace base {
+
+// Simple scoper that saves the current value of errno, resets it to 0, and on
+// destruction puts the old value back.
+class ScopedClearErrno {
+ public:
+  ScopedClearErrno() : old_errno_(errno) {
+    errno = 0;
+  }
+  ~ScopedClearErrno() {
+    if (errno == 0)
+      errno = old_errno_;
+  }
+
+ private:
+  const int old_errno_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedClearErrno);
+};
+
+}  // namespace base
+
+#endif  // BASE_SCOPED_CLEAR_ERRNO_H_
diff --git a/native/zucchini/vendor/libchrome/base/scoped_generic.h b/native/zucchini/vendor/libchrome/base/scoped_generic.h
new file mode 100644
index 0000000..25e6208
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/scoped_generic.h
@@ -0,0 +1,189 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_SCOPED_GENERIC_H_
+#define BASE_SCOPED_GENERIC_H_
+
+#include <stdlib.h>
+
+#include <algorithm>
+
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+
+namespace base {
+
+// This class acts like unique_ptr with a custom deleter (although is slightly
+// less fancy in some of the more escoteric respects) except that it keeps a
+// copy of the object rather than a pointer, and we require that the contained
+// object has some kind of "invalid" value.
+//
+// Defining a scoper based on this class allows you to get a scoper for
+// non-pointer types without having to write custom code for set, reset, and
+// move, etc. and get almost identical semantics that people are used to from
+// unique_ptr.
+//
+// It is intended that you will typedef this class with an appropriate deleter
+// to implement clean up tasks for objects that act like pointers from a
+// resource management standpoint but aren't, such as file descriptors and
+// various types of operating system handles. Using unique_ptr for these
+// things requires that you keep a pointer to the handle valid for the lifetime
+// of the scoper (which is easy to mess up).
+//
+// For an object to be able to be put into a ScopedGeneric, it must support
+// standard copyable semantics and have a specific "invalid" value. The traits
+// must define a free function and also the invalid value to assign for
+// default-constructed and released objects.
+//
+//   struct FooScopedTraits {
+//     // It's assumed that this is a fast inline function with little-to-no
+//     // penalty for duplicate calls. This must be a static function even
+//     // for stateful traits.
+//     static int InvalidValue() {
+//       return 0;
+//     }
+//
+//     // This free function will not be called if f == InvalidValue()!
+//     static void Free(int f) {
+//       ::FreeFoo(f);
+//     }
+//   };
+//
+//   typedef ScopedGeneric<int, FooScopedTraits> ScopedFoo;
+template<typename T, typename Traits>
+class ScopedGeneric {
+ private:
+  // This must be first since it's used inline below.
+  //
+  // Use the empty base class optimization to allow us to have a D
+  // member, while avoiding any space overhead for it when D is an
+  // empty class.  See e.g. http://www.cantrip.org/emptyopt.html for a good
+  // discussion of this technique.
+  struct Data : public Traits {
+    explicit Data(const T& in) : generic(in) {}
+    Data(const T& in, const Traits& other) : Traits(other), generic(in) {}
+    T generic;
+  };
+
+ public:
+  typedef T element_type;
+  typedef Traits traits_type;
+
+  ScopedGeneric() : data_(traits_type::InvalidValue()) {}
+
+  // Constructor. Takes responsibility for freeing the resource associated with
+  // the object T.
+  explicit ScopedGeneric(const element_type& value) : data_(value) {}
+
+  // Constructor. Allows initialization of a stateful traits object.
+  ScopedGeneric(const element_type& value, const traits_type& traits)
+      : data_(value, traits) {
+  }
+
+  // Move constructor. Allows initialization from a ScopedGeneric rvalue.
+  ScopedGeneric(ScopedGeneric<T, Traits>&& rvalue)
+      : data_(rvalue.release(), rvalue.get_traits()) {
+  }
+
+  ~ScopedGeneric() {
+    FreeIfNecessary();
+  }
+
+  // operator=. Allows assignment from a ScopedGeneric rvalue.
+  ScopedGeneric& operator=(ScopedGeneric<T, Traits>&& rvalue) {
+    reset(rvalue.release());
+    return *this;
+  }
+
+  // Frees the currently owned object, if any. Then takes ownership of a new
+  // object, if given. Self-resets are not allowd as on unique_ptr. See
+  // http://crbug.com/162971
+  void reset(const element_type& value = traits_type::InvalidValue()) {
+    if (data_.generic != traits_type::InvalidValue() && data_.generic == value)
+      abort();
+    FreeIfNecessary();
+    data_.generic = value;
+  }
+
+  void swap(ScopedGeneric& other) {
+    // Standard swap idiom: 'using std::swap' ensures that std::swap is
+    // present in the overload set, but we call swap unqualified so that
+    // any more-specific overloads can be used, if available.
+    using std::swap;
+    swap(static_cast<Traits&>(data_), static_cast<Traits&>(other.data_));
+    swap(data_.generic, other.data_.generic);
+  }
+
+  // Release the object. The return value is the current object held by this
+  // object. After this operation, this object will hold a null value, and
+  // will not own the object any more.
+  element_type release() WARN_UNUSED_RESULT {
+    element_type old_generic = data_.generic;
+    data_.generic = traits_type::InvalidValue();
+    return old_generic;
+  }
+
+  // Returns a raw pointer to the object storage, to allow the scoper to be used
+  // to receive and manage out-parameter values. Implies reset().
+  element_type* receive() WARN_UNUSED_RESULT {
+    reset();
+    return &data_.generic;
+  }
+
+  const element_type& get() const { return data_.generic; }
+
+  // Returns true if this object doesn't hold the special null value for the
+  // associated data type.
+  bool is_valid() const { return data_.generic != traits_type::InvalidValue(); }
+
+  bool operator==(const element_type& value) const {
+    return data_.generic == value;
+  }
+  bool operator!=(const element_type& value) const {
+    return data_.generic != value;
+  }
+
+  Traits& get_traits() { return data_; }
+  const Traits& get_traits() const { return data_; }
+
+ private:
+  void FreeIfNecessary() {
+    if (data_.generic != traits_type::InvalidValue()) {
+      data_.Free(data_.generic);
+      data_.generic = traits_type::InvalidValue();
+    }
+  }
+
+  // Forbid comparison. If U != T, it totally doesn't make sense, and if U ==
+  // T, it still doesn't make sense because you should never have the same
+  // object owned by two different ScopedGenerics.
+  template <typename T2, typename Traits2> bool operator==(
+      const ScopedGeneric<T2, Traits2>& p2) const;
+  template <typename T2, typename Traits2> bool operator!=(
+      const ScopedGeneric<T2, Traits2>& p2) const;
+
+  Data data_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedGeneric);
+};
+
+template<class T, class Traits>
+void swap(const ScopedGeneric<T, Traits>& a,
+          const ScopedGeneric<T, Traits>& b) {
+  a.swap(b);
+}
+
+template<class T, class Traits>
+bool operator==(const T& value, const ScopedGeneric<T, Traits>& scoped) {
+  return value == scoped.get();
+}
+
+template<class T, class Traits>
+bool operator!=(const T& value, const ScopedGeneric<T, Traits>& scoped) {
+  return value != scoped.get();
+}
+
+}  // namespace base
+
+#endif  // BASE_SCOPED_GENERIC_H_
diff --git a/native/zucchini/vendor/libchrome/base/sequence_checker.h b/native/zucchini/vendor/libchrome/base/sequence_checker.h
new file mode 100644
index 0000000..48b593b
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/sequence_checker.h
@@ -0,0 +1,88 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_SEQUENCE_CHECKER_H_
+#define BASE_SEQUENCE_CHECKER_H_
+
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/sequence_checker_impl.h"
+
+// SequenceChecker is a helper class used to help verify that some methods of a
+// class are called sequentially (for thread-safety).
+//
+// Use the macros below instead of the SequenceChecker directly so that the
+// unused member doesn't result in an extra byte (four when padded) per
+// instance in production.
+//
+// This class is much prefered to ThreadChecker for thread-safety checks.
+// ThreadChecker should only be used for classes that are truly thread-affine
+// (use thread-local-storage or a third-party API that does).
+//
+// Usage:
+//   class MyClass {
+//    public:
+//     MyClass() {
+//       // It's sometimes useful to detach on construction for objects that are
+//       // constructed in one place and forever after used from another
+//       // sequence.
+//       DETACH_FROM_SEQUENCE(my_sequence_checker_);
+//     }
+//
+//     ~MyClass() {
+//       // SequenceChecker doesn't automatically check it's destroyed on origin
+//       // sequence for the same reason it's sometimes detached in the
+//       // constructor. It's okay to destroy off sequence if the owner
+//       // otherwise knows usage on the associated sequence is done. If you're
+//       // not detaching in the constructor, you probably want to explicitly
+//       // check in the destructor.
+//       DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker_);
+//     }
+//     void MyMethod() {
+//       DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker_);
+//       ... (do stuff) ...
+//     }
+//
+//    private:
+//     SEQUENCE_CHECKER(my_sequence_checker_);
+//   }
+
+#if DCHECK_IS_ON()
+#define SEQUENCE_CHECKER(name) base::SequenceChecker name
+#define DCHECK_CALLED_ON_VALID_SEQUENCE(name) \
+  DCHECK((name).CalledOnValidSequence())
+#define DETACH_FROM_SEQUENCE(name) (name).DetachFromSequence()
+#else  // DCHECK_IS_ON()
+#define SEQUENCE_CHECKER(name)
+#define DCHECK_CALLED_ON_VALID_SEQUENCE(name) EAT_STREAM_PARAMETERS
+#define DETACH_FROM_SEQUENCE(name)
+#endif  // DCHECK_IS_ON()
+
+namespace base {
+
+// Do nothing implementation, for use in release mode.
+//
+// Note: You should almost always use the SequenceChecker class (through the
+// above macros) to get the right version for your build configuration.
+class SequenceCheckerDoNothing {
+ public:
+  SequenceCheckerDoNothing() = default;
+  bool CalledOnValidSequence() const WARN_UNUSED_RESULT { return true; }
+  void DetachFromSequence() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SequenceCheckerDoNothing);
+};
+
+#if DCHECK_IS_ON()
+class SequenceChecker : public SequenceCheckerImpl {
+};
+#else
+class SequenceChecker : public SequenceCheckerDoNothing {
+};
+#endif  // DCHECK_IS_ON()
+
+}  // namespace base
+
+#endif  // BASE_SEQUENCE_CHECKER_H_
diff --git a/native/zucchini/vendor/libchrome/base/sequence_checker_impl.h b/native/zucchini/vendor/libchrome/base/sequence_checker_impl.h
new file mode 100644
index 0000000..a54c388
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/sequence_checker_impl.h
@@ -0,0 +1,48 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_SEQUENCE_CHECKER_IMPL_H_
+#define BASE_SEQUENCE_CHECKER_IMPL_H_
+
+#include <memory>
+
+#include "base/base_export.h"
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/synchronization/lock.h"
+
+namespace base {
+
+// Real implementation of SequenceChecker for use in debug mode or for temporary
+// use in release mode (e.g. to CHECK on a threading issue seen only in the
+// wild).
+//
+// Note: You should almost always use the SequenceChecker class to get the right
+// version for your build configuration.
+class BASE_EXPORT SequenceCheckerImpl {
+ public:
+  SequenceCheckerImpl();
+  ~SequenceCheckerImpl();
+
+  // Returns true if called in sequence with previous calls to this method and
+  // the constructor.
+  bool CalledOnValidSequence() const WARN_UNUSED_RESULT;
+
+  // Unbinds the checker from the currently associated sequence. The checker
+  // will be re-bound on the next call to CalledOnValidSequence().
+  void DetachFromSequence();
+
+ private:
+  class Core;
+
+  // Guards all variables below.
+  mutable Lock lock_;
+  mutable std::unique_ptr<Core> core_;
+
+  DISALLOW_COPY_AND_ASSIGN(SequenceCheckerImpl);
+};
+
+}  // namespace base
+
+#endif  // BASE_SEQUENCE_CHECKER_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/sequenced_task_runner.h b/native/zucchini/vendor/libchrome/base/sequenced_task_runner.h
new file mode 100644
index 0000000..53d21ad
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/sequenced_task_runner.h
@@ -0,0 +1,176 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_SEQUENCED_TASK_RUNNER_H_
+#define BASE_SEQUENCED_TASK_RUNNER_H_
+
+#include <memory>
+
+#include "base/base_export.h"
+#include "base/callback.h"
+#include "base/sequenced_task_runner_helpers.h"
+#include "base/task_runner.h"
+
+namespace base {
+
+// A SequencedTaskRunner is a subclass of TaskRunner that provides
+// additional guarantees on the order that tasks are started, as well
+// as guarantees on when tasks are in sequence, i.e. one task finishes
+// before the other one starts.
+//
+// Summary
+// -------
+// Non-nested tasks with the same delay will run one by one in FIFO
+// order.
+//
+// Detailed guarantees
+// -------------------
+//
+// SequencedTaskRunner also adds additional methods for posting
+// non-nestable tasks.  In general, an implementation of TaskRunner
+// may expose task-running methods which are themselves callable from
+// within tasks.  A non-nestable task is one that is guaranteed to not
+// be run from within an already-running task.  Conversely, a nestable
+// task (the default) is a task that can be run from within an
+// already-running task.
+//
+// The guarantees of SequencedTaskRunner are as follows:
+//
+//   - Given two tasks T2 and T1, T2 will start after T1 starts if:
+//
+//       * T2 is posted after T1; and
+//       * T2 has equal or higher delay than T1; and
+//       * T2 is non-nestable or T1 is nestable.
+//
+//   - If T2 will start after T1 starts by the above guarantee, then
+//     T2 will start after T1 finishes and is destroyed if:
+//
+//       * T2 is non-nestable, or
+//       * T1 doesn't call any task-running methods.
+//
+//   - If T2 will start after T1 finishes by the above guarantee, then
+//     all memory changes in T1 and T1's destruction will be visible
+//     to T2.
+//
+//   - If T2 runs nested within T1 via a call to the task-running
+//     method M, then all memory changes in T1 up to the call to M
+//     will be visible to T2, and all memory changes in T2 will be
+//     visible to T1 from the return from M.
+//
+// Note that SequencedTaskRunner does not guarantee that tasks are run
+// on a single dedicated thread, although the above guarantees provide
+// most (but not all) of the same guarantees.  If you do need to
+// guarantee that tasks are run on a single dedicated thread, see
+// SingleThreadTaskRunner (in single_thread_task_runner.h).
+//
+// Some corollaries to the above guarantees, assuming the tasks in
+// question don't call any task-running methods:
+//
+//   - Tasks posted via PostTask are run in FIFO order.
+//
+//   - Tasks posted via PostNonNestableTask are run in FIFO order.
+//
+//   - Tasks posted with the same delay and the same nestable state
+//     are run in FIFO order.
+//
+//   - A list of tasks with the same nestable state posted in order of
+//     non-decreasing delay is run in FIFO order.
+//
+//   - A list of tasks posted in order of non-decreasing delay with at
+//     most a single change in nestable state from nestable to
+//     non-nestable is run in FIFO order. (This is equivalent to the
+//     statement of the first guarantee above.)
+//
+// Some theoretical implementations of SequencedTaskRunner:
+//
+//   - A SequencedTaskRunner that wraps a regular TaskRunner but makes
+//     sure that only one task at a time is posted to the TaskRunner,
+//     with appropriate memory barriers in between tasks.
+//
+//   - A SequencedTaskRunner that, for each task, spawns a joinable
+//     thread to run that task and immediately quit, and then
+//     immediately joins that thread.
+//
+//   - A SequencedTaskRunner that stores the list of posted tasks and
+//     has a method Run() that runs each runnable task in FIFO order
+//     that can be called from any thread, but only if another
+//     (non-nested) Run() call isn't already happening.
+class BASE_EXPORT SequencedTaskRunner : public TaskRunner {
+ public:
+  // The two PostNonNestable*Task methods below are like their
+  // nestable equivalents in TaskRunner, but they guarantee that the
+  // posted task will not run nested within an already-running task.
+  //
+  // A simple corollary is that posting a task as non-nestable can
+  // only delay when the task gets run.  That is, posting a task as
+  // non-nestable may not affect when the task gets run, or it could
+  // make it run later than it normally would, but it won't make it
+  // run earlier than it normally would.
+
+  // TODO(akalin): Get rid of the boolean return value for the methods
+  // below.
+
+  bool PostNonNestableTask(const Location& from_here, OnceClosure task);
+
+  virtual bool PostNonNestableDelayedTask(const Location& from_here,
+                                          OnceClosure task,
+                                          base::TimeDelta delay) = 0;
+
+  // Submits a non-nestable task to delete the given object.  Returns
+  // true if the object may be deleted at some point in the future,
+  // and false if the object definitely will not be deleted.
+  template <class T>
+  bool DeleteSoon(const Location& from_here, const T* object) {
+    return DeleteOrReleaseSoonInternal(from_here, &DeleteHelper<T>::DoDelete,
+                                       object);
+  }
+
+  template <class T>
+  bool DeleteSoon(const Location& from_here, std::unique_ptr<T> object) {
+    return DeleteSoon(from_here, object.release());
+  }
+
+  // Submits a non-nestable task to release the given object.  Returns
+  // true if the object may be released at some point in the future,
+  // and false if the object definitely will not be released.
+  template <class T>
+  bool ReleaseSoon(const Location& from_here, const T* object) {
+    return DeleteOrReleaseSoonInternal(from_here, &ReleaseHelper<T>::DoRelease,
+                                       object);
+  }
+
+ protected:
+  ~SequencedTaskRunner() override = default;
+
+ private:
+  bool DeleteOrReleaseSoonInternal(const Location& from_here,
+                                   void (*deleter)(const void*),
+                                   const void* object);
+};
+
+// Sample usage with std::unique_ptr :
+// std::unique_ptr<Foo, base::OnTaskRunnerDeleter> ptr(
+//     new Foo, base::OnTaskRunnerDeleter(my_task_runner));
+//
+// For RefCounted see base::RefCountedDeleteOnSequence.
+struct BASE_EXPORT OnTaskRunnerDeleter {
+  explicit OnTaskRunnerDeleter(scoped_refptr<SequencedTaskRunner> task_runner);
+  ~OnTaskRunnerDeleter();
+
+  OnTaskRunnerDeleter(OnTaskRunnerDeleter&&);
+  OnTaskRunnerDeleter& operator=(OnTaskRunnerDeleter&&);
+
+  // For compatibility with std:: deleters.
+  template <typename T>
+  void operator()(const T* ptr) {
+    if (ptr)
+      task_runner_->DeleteSoon(FROM_HERE, ptr);
+  }
+
+  scoped_refptr<SequencedTaskRunner> task_runner_;
+};
+
+}  // namespace base
+
+#endif  // BASE_SEQUENCED_TASK_RUNNER_H_
diff --git a/native/zucchini/vendor/libchrome/base/sequenced_task_runner_helpers.h b/native/zucchini/vendor/libchrome/base/sequenced_task_runner_helpers.h
new file mode 100644
index 0000000..18ec0e2
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/sequenced_task_runner_helpers.h
@@ -0,0 +1,42 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_SEQUENCED_TASK_RUNNER_HELPERS_H_
+#define BASE_SEQUENCED_TASK_RUNNER_HELPERS_H_
+
+namespace base {
+
+class SequencedTaskRunner;
+
+// Template helpers which use function indirection to erase T from the
+// function signature while still remembering it so we can call the
+// correct destructor/release function.
+//
+// We use this trick so we don't need to include bind.h in a header
+// file like sequenced_task_runner.h. We also wrap the helpers in a
+// templated class to make it easier for users of DeleteSoon to
+// declare the helper as a friend.
+template <class T>
+class DeleteHelper {
+ private:
+  static void DoDelete(const void* object) {
+    delete static_cast<const T*>(object);
+  }
+
+  friend class SequencedTaskRunner;
+};
+
+template <class T>
+class ReleaseHelper {
+ private:
+  static void DoRelease(const void* object) {
+    static_cast<const T*>(object)->Release();
+  }
+
+  friend class SequencedTaskRunner;
+};
+
+}  // namespace base
+
+#endif  // BASE_SEQUENCED_TASK_RUNNER_HELPERS_H_
diff --git a/native/zucchini/vendor/libchrome/base/single_thread_task_runner.h b/native/zucchini/vendor/libchrome/base/single_thread_task_runner.h
new file mode 100644
index 0000000..4d6938e
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/single_thread_task_runner.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_SINGLE_THREAD_TASK_RUNNER_H_
+#define BASE_SINGLE_THREAD_TASK_RUNNER_H_
+
+#include "base/base_export.h"
+#include "base/sequenced_task_runner.h"
+
+namespace base {
+
+// A SingleThreadTaskRunner is a SequencedTaskRunner with one more
+// guarantee; namely, that all tasks are run on a single dedicated
+// thread.  Most use cases require only a SequencedTaskRunner, unless
+// there is a specific need to run tasks on only a single thread.
+//
+// SingleThreadTaskRunner implementations might:
+//   - Post tasks to an existing thread's MessageLoop (see
+//     MessageLoop::task_runner()).
+//   - Create their own worker thread and MessageLoop to post tasks to.
+//   - Add tasks to a FIFO and signal to a non-MessageLoop thread for them to
+//     be processed. This allows TaskRunner-oriented code run on threads
+//     running other kinds of message loop, e.g. Jingle threads.
+class BASE_EXPORT SingleThreadTaskRunner : public SequencedTaskRunner {
+ public:
+  // A more explicit alias to RunsTasksInCurrentSequence().
+  bool BelongsToCurrentThread() const { return RunsTasksInCurrentSequence(); }
+
+ protected:
+  ~SingleThreadTaskRunner() override = default;
+};
+
+}  // namespace base
+
+#endif  // BASE_SINGLE_THREAD_TASK_RUNNER_H_
diff --git a/native/zucchini/vendor/libchrome/base/stl_util.h b/native/zucchini/vendor/libchrome/base/stl_util.h
new file mode 100644
index 0000000..6d521cc
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/stl_util.h
@@ -0,0 +1,410 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Derived from google3/util/gtl/stl_util.h
+
+#ifndef BASE_STL_UTIL_H_
+#define BASE_STL_UTIL_H_
+
+#include <algorithm>
+#include <deque>
+#include <forward_list>
+#include <functional>
+#include <initializer_list>
+#include <iterator>
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "base/logging.h"
+#include "base/optional.h"
+
+namespace base {
+
+namespace internal {
+
+// Calls erase on iterators of matching elements.
+template <typename Container, typename Predicate>
+void IterateAndEraseIf(Container& container, Predicate pred) {
+  for (auto it = container.begin(); it != container.end();) {
+    if (pred(*it))
+      it = container.erase(it);
+    else
+      ++it;
+  }
+}
+
+}  // namespace internal
+
+// C++14 implementation of C++17's std::size():
+// http://en.cppreference.com/w/cpp/iterator/size
+template <typename Container>
+constexpr auto size(const Container& c) -> decltype(c.size()) {
+  return c.size();
+}
+
+template <typename T, size_t N>
+constexpr size_t size(const T (&array)[N]) noexcept {
+  return N;
+}
+
+// C++14 implementation of C++17's std::empty():
+// http://en.cppreference.com/w/cpp/iterator/empty
+template <typename Container>
+constexpr auto empty(const Container& c) -> decltype(c.empty()) {
+  return c.empty();
+}
+
+template <typename T, size_t N>
+constexpr bool empty(const T (&array)[N]) noexcept {
+  return false;
+}
+
+template <typename T>
+constexpr bool empty(std::initializer_list<T> il) noexcept {
+  return il.size() == 0;
+}
+
+// C++14 implementation of C++17's std::data():
+// http://en.cppreference.com/w/cpp/iterator/data
+template <typename Container>
+constexpr auto data(Container& c) -> decltype(c.data()) {
+  return c.data();
+}
+
+// std::basic_string::data() had no mutable overload prior to C++17 [1].
+// Hence this overload is provided.
+// Note: str[0] is safe even for empty strings, as they are guaranteed to be
+// null-terminated [2].
+//
+// [1] http://en.cppreference.com/w/cpp/string/basic_string/data
+// [2] http://en.cppreference.com/w/cpp/string/basic_string/operator_at
+template <typename CharT, typename Traits, typename Allocator>
+CharT* data(std::basic_string<CharT, Traits, Allocator>& str) {
+  return std::addressof(str[0]);
+}
+
+template <typename Container>
+constexpr auto data(const Container& c) -> decltype(c.data()) {
+  return c.data();
+}
+
+template <typename T, size_t N>
+constexpr T* data(T (&array)[N]) noexcept {
+  return array;
+}
+
+template <typename T>
+constexpr const T* data(std::initializer_list<T> il) noexcept {
+  return il.begin();
+}
+
+// Returns a const reference to the underlying container of a container adapter.
+// Works for std::priority_queue, std::queue, and std::stack.
+template <class A>
+const typename A::container_type& GetUnderlyingContainer(const A& adapter) {
+  struct ExposedAdapter : A {
+    using A::c;
+  };
+  return adapter.*&ExposedAdapter::c;
+}
+
+// Clears internal memory of an STL object.
+// STL clear()/reserve(0) does not always free internal memory allocated
+// This function uses swap/destructor to ensure the internal memory is freed.
+template<class T>
+void STLClearObject(T* obj) {
+  T tmp;
+  tmp.swap(*obj);
+  // Sometimes "T tmp" allocates objects with memory (arena implementation?).
+  // Hence using additional reserve(0) even if it doesn't always work.
+  obj->reserve(0);
+}
+
+// Counts the number of instances of val in a container.
+template <typename Container, typename T>
+typename std::iterator_traits<
+    typename Container::const_iterator>::difference_type
+STLCount(const Container& container, const T& val) {
+  return std::count(container.begin(), container.end(), val);
+}
+
+// Test to see if a set or map contains a particular key.
+// Returns true if the key is in the collection.
+template <typename Collection, typename Key>
+bool ContainsKey(const Collection& collection, const Key& key) {
+  return collection.find(key) != collection.end();
+}
+
+namespace internal {
+
+template <typename Collection>
+class HasKeyType {
+  template <typename C>
+  static std::true_type test(typename C::key_type*);
+  template <typename C>
+  static std::false_type test(...);
+
+ public:
+  static constexpr bool value = decltype(test<Collection>(nullptr))::value;
+};
+
+}  // namespace internal
+
+// Test to see if a collection like a vector contains a particular value.
+// Returns true if the value is in the collection.
+// Don't use this on collections such as sets or maps. This is enforced by
+// disabling this method if the collection defines a key_type.
+template <typename Collection,
+          typename Value,
+          typename std::enable_if<!internal::HasKeyType<Collection>::value,
+                                  int>::type = 0>
+bool ContainsValue(const Collection& collection, const Value& value) {
+  return std::find(std::begin(collection), std::end(collection), value) !=
+         std::end(collection);
+}
+
+// Returns true if the container is sorted.
+template <typename Container>
+bool STLIsSorted(const Container& cont) {
+  // Note: Use reverse iterator on container to ensure we only require
+  // value_type to implement operator<.
+  return std::adjacent_find(cont.rbegin(), cont.rend(),
+                            std::less<typename Container::value_type>())
+      == cont.rend();
+}
+
+// Returns a new ResultType containing the difference of two sorted containers.
+template <typename ResultType, typename Arg1, typename Arg2>
+ResultType STLSetDifference(const Arg1& a1, const Arg2& a2) {
+  DCHECK(STLIsSorted(a1));
+  DCHECK(STLIsSorted(a2));
+  ResultType difference;
+  std::set_difference(a1.begin(), a1.end(),
+                      a2.begin(), a2.end(),
+                      std::inserter(difference, difference.end()));
+  return difference;
+}
+
+// Returns a new ResultType containing the union of two sorted containers.
+template <typename ResultType, typename Arg1, typename Arg2>
+ResultType STLSetUnion(const Arg1& a1, const Arg2& a2) {
+  DCHECK(STLIsSorted(a1));
+  DCHECK(STLIsSorted(a2));
+  ResultType result;
+  std::set_union(a1.begin(), a1.end(),
+                 a2.begin(), a2.end(),
+                 std::inserter(result, result.end()));
+  return result;
+}
+
+// Returns a new ResultType containing the intersection of two sorted
+// containers.
+template <typename ResultType, typename Arg1, typename Arg2>
+ResultType STLSetIntersection(const Arg1& a1, const Arg2& a2) {
+  DCHECK(STLIsSorted(a1));
+  DCHECK(STLIsSorted(a2));
+  ResultType result;
+  std::set_intersection(a1.begin(), a1.end(),
+                        a2.begin(), a2.end(),
+                        std::inserter(result, result.end()));
+  return result;
+}
+
+// Returns true if the sorted container |a1| contains all elements of the sorted
+// container |a2|.
+template <typename Arg1, typename Arg2>
+bool STLIncludes(const Arg1& a1, const Arg2& a2) {
+  DCHECK(STLIsSorted(a1));
+  DCHECK(STLIsSorted(a2));
+  return std::includes(a1.begin(), a1.end(),
+                       a2.begin(), a2.end());
+}
+
+// Erase/EraseIf are based on library fundamentals ts v2 erase/erase_if
+// http://en.cppreference.com/w/cpp/experimental/lib_extensions_2
+// They provide a generic way to erase elements from a container.
+// The functions here implement these for the standard containers until those
+// functions are available in the C++ standard.
+// For Chromium containers overloads should be defined in their own headers
+// (like standard containers).
+// Note: there is no std::erase for standard associative containers so we don't
+// have it either.
+
+template <typename CharT, typename Traits, typename Allocator, typename Value>
+void Erase(std::basic_string<CharT, Traits, Allocator>& container,
+           const Value& value) {
+  container.erase(std::remove(container.begin(), container.end(), value),
+                  container.end());
+}
+
+template <typename CharT, typename Traits, typename Allocator, class Predicate>
+void EraseIf(std::basic_string<CharT, Traits, Allocator>& container,
+             Predicate pred) {
+  container.erase(std::remove_if(container.begin(), container.end(), pred),
+                  container.end());
+}
+
+template <class T, class Allocator, class Value>
+void Erase(std::deque<T, Allocator>& container, const Value& value) {
+  container.erase(std::remove(container.begin(), container.end(), value),
+                  container.end());
+}
+
+template <class T, class Allocator, class Predicate>
+void EraseIf(std::deque<T, Allocator>& container, Predicate pred) {
+  container.erase(std::remove_if(container.begin(), container.end(), pred),
+                  container.end());
+}
+
+template <class T, class Allocator, class Value>
+void Erase(std::vector<T, Allocator>& container, const Value& value) {
+  container.erase(std::remove(container.begin(), container.end(), value),
+                  container.end());
+}
+
+template <class T, class Allocator, class Predicate>
+void EraseIf(std::vector<T, Allocator>& container, Predicate pred) {
+  container.erase(std::remove_if(container.begin(), container.end(), pred),
+                  container.end());
+}
+
+template <class T, class Allocator, class Value>
+void Erase(std::forward_list<T, Allocator>& container, const Value& value) {
+  // Unlike std::forward_list::remove, this function template accepts
+  // heterogeneous types and does not force a conversion to the container's
+  // value type before invoking the == operator.
+  container.remove_if([&](const T& cur) { return cur == value; });
+}
+
+template <class T, class Allocator, class Predicate>
+void EraseIf(std::forward_list<T, Allocator>& container, Predicate pred) {
+  container.remove_if(pred);
+}
+
+template <class T, class Allocator, class Value>
+void Erase(std::list<T, Allocator>& container, const Value& value) {
+  // Unlike std::list::remove, this function template accepts heterogeneous
+  // types and does not force a conversion to the container's value type before
+  // invoking the == operator.
+  container.remove_if([&](const T& cur) { return cur == value; });
+}
+
+template <class T, class Allocator, class Predicate>
+void EraseIf(std::list<T, Allocator>& container, Predicate pred) {
+  container.remove_if(pred);
+}
+
+template <class Key, class T, class Compare, class Allocator, class Predicate>
+void EraseIf(std::map<Key, T, Compare, Allocator>& container, Predicate pred) {
+  internal::IterateAndEraseIf(container, pred);
+}
+
+template <class Key, class T, class Compare, class Allocator, class Predicate>
+void EraseIf(std::multimap<Key, T, Compare, Allocator>& container,
+             Predicate pred) {
+  internal::IterateAndEraseIf(container, pred);
+}
+
+template <class Key, class Compare, class Allocator, class Predicate>
+void EraseIf(std::set<Key, Compare, Allocator>& container, Predicate pred) {
+  internal::IterateAndEraseIf(container, pred);
+}
+
+template <class Key, class Compare, class Allocator, class Predicate>
+void EraseIf(std::multiset<Key, Compare, Allocator>& container,
+             Predicate pred) {
+  internal::IterateAndEraseIf(container, pred);
+}
+
+template <class Key,
+          class T,
+          class Hash,
+          class KeyEqual,
+          class Allocator,
+          class Predicate>
+void EraseIf(std::unordered_map<Key, T, Hash, KeyEqual, Allocator>& container,
+             Predicate pred) {
+  internal::IterateAndEraseIf(container, pred);
+}
+
+template <class Key,
+          class T,
+          class Hash,
+          class KeyEqual,
+          class Allocator,
+          class Predicate>
+void EraseIf(
+    std::unordered_multimap<Key, T, Hash, KeyEqual, Allocator>& container,
+    Predicate pred) {
+  internal::IterateAndEraseIf(container, pred);
+}
+
+template <class Key,
+          class Hash,
+          class KeyEqual,
+          class Allocator,
+          class Predicate>
+void EraseIf(std::unordered_set<Key, Hash, KeyEqual, Allocator>& container,
+             Predicate pred) {
+  internal::IterateAndEraseIf(container, pred);
+}
+
+template <class Key,
+          class Hash,
+          class KeyEqual,
+          class Allocator,
+          class Predicate>
+void EraseIf(std::unordered_multiset<Key, Hash, KeyEqual, Allocator>& container,
+             Predicate pred) {
+  internal::IterateAndEraseIf(container, pred);
+}
+
+// A helper class to be used as the predicate with |EraseIf| to implement
+// in-place set intersection. Helps implement the algorithm of going through
+// each container an element at a time, erasing elements from the first
+// container if they aren't in the second container. Requires each container be
+// sorted. Note that the logic below appears inverted since it is returning
+// whether an element should be erased.
+template <class Collection>
+class IsNotIn {
+ public:
+  explicit IsNotIn(const Collection& collection)
+      : i_(collection.begin()), end_(collection.end()) {}
+
+  bool operator()(const typename Collection::value_type& x) {
+    while (i_ != end_ && *i_ < x)
+      ++i_;
+    if (i_ == end_)
+      return true;
+    if (*i_ == x) {
+      ++i_;
+      return false;
+    }
+    return true;
+  }
+
+ private:
+  typename Collection::const_iterator i_;
+  const typename Collection::const_iterator end_;
+};
+
+// Helper for returning the optional value's address, or nullptr.
+template <class T>
+T* OptionalOrNullptr(base::Optional<T>& optional) {
+  return optional.has_value() ? &optional.value() : nullptr;
+}
+
+template <class T>
+const T* OptionalOrNullptr(const base::Optional<T>& optional) {
+  return optional.has_value() ? &optional.value() : nullptr;
+}
+
+}  // namespace base
+
+#endif  // BASE_STL_UTIL_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/char_traits.h b/native/zucchini/vendor/libchrome/base/strings/char_traits.h
new file mode 100644
index 0000000..b193e21
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/char_traits.h
@@ -0,0 +1,92 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_STRINGS_CHAR_TRAITS_H_
+#define BASE_STRINGS_CHAR_TRAITS_H_
+
+#include <stddef.h>
+
+#include "base/compiler_specific.h"
+
+namespace base {
+
+// constexpr version of http://en.cppreference.com/w/cpp/string/char_traits.
+// This currently just implements the bits needed to support a (mostly)
+// constexpr StringPiece.
+//
+// TODO(dcheng): Once we switch to C++17, most methods will become constexpr and
+// we can switch over to using the one in the standard library.
+template <typename T>
+struct CharTraits {
+  // Performs a lexographical comparison of the first N characters of |s1| and
+  // |s2|. Returns 0 if equal, -1 if |s1| is less than |s2|, and 1 if |s1| is
+  // greater than |s2|.
+  static constexpr int compare(const T* s1, const T* s2, size_t n) noexcept;
+
+  // Returns the length of |s|, assuming null termination (and not including the
+  // terminating null).
+  static constexpr size_t length(const T* s) noexcept;
+};
+
+template <typename T>
+constexpr int CharTraits<T>::compare(const T* s1,
+                                     const T* s2,
+                                     size_t n) noexcept {
+  for (; n; --n, ++s1, ++s2) {
+    if (*s1 < *s2)
+      return -1;
+    if (*s1 > *s2)
+      return 1;
+  }
+  return 0;
+}
+
+template <typename T>
+constexpr size_t CharTraits<T>::length(const T* s) noexcept {
+  size_t i = 0;
+  for (; *s; ++s)
+    ++i;
+  return i;
+}
+
+// char specialization of CharTraits that can use clang's constexpr instrinsics,
+// where available.
+template <>
+struct CharTraits<char> {
+  static constexpr int compare(const char* s1,
+                               const char* s2,
+                               size_t n) noexcept;
+  static constexpr size_t length(const char* s) noexcept;
+};
+
+constexpr int CharTraits<char>::compare(const char* s1,
+                                        const char* s2,
+                                        size_t n) noexcept {
+#if HAS_FEATURE(cxx_constexpr_string_builtins)
+  return __builtin_memcmp(s1, s2, n);
+#else
+  for (; n; --n, ++s1, ++s2) {
+    if (*s1 < *s2)
+      return -1;
+    if (*s1 > *s2)
+      return 1;
+  }
+  return 0;
+#endif
+}
+
+constexpr size_t CharTraits<char>::length(const char* s) noexcept {
+#if defined(__clang__)
+  return __builtin_strlen(s);
+#else
+  size_t i = 0;
+  for (; *s; ++s)
+    ++i;
+  return i;
+#endif
+}
+
+}  // namespace base
+
+#endif  // BASE_STRINGS_CHAR_TRAITS_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/string16.h b/native/zucchini/vendor/libchrome/base/strings/string16.h
new file mode 100644
index 0000000..a86baa2
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/string16.h
@@ -0,0 +1,219 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_STRINGS_STRING16_H_
+#define BASE_STRINGS_STRING16_H_
+
+// WHAT:
+// A version of std::basic_string that provides 2-byte characters even when
+// wchar_t is not implemented as a 2-byte type. You can access this class as
+// string16. We also define char16, which string16 is based upon.
+//
+// WHY:
+// On Windows, wchar_t is 2 bytes, and it can conveniently handle UTF-16/UCS-2
+// data. Plenty of existing code operates on strings encoded as UTF-16.
+//
+// On many other platforms, sizeof(wchar_t) is 4 bytes by default. We can make
+// it 2 bytes by using the GCC flag -fshort-wchar. But then std::wstring fails
+// at run time, because it calls some functions (like wcslen) that come from
+// the system's native C library -- which was built with a 4-byte wchar_t!
+// It's wasteful to use 4-byte wchar_t strings to carry UTF-16 data, and it's
+// entirely improper on those systems where the encoding of wchar_t is defined
+// as UTF-32.
+//
+// Here, we define string16, which is similar to std::wstring but replaces all
+// libc functions with custom, 2-byte-char compatible routines. It is capable
+// of carrying UTF-16-encoded data.
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include <functional>
+#include <string>
+
+#include "base/base_export.h"
+#include "build/build_config.h"
+
+#if defined(WCHAR_T_IS_UTF16)
+
+namespace base {
+
+typedef wchar_t char16;
+typedef std::wstring string16;
+
+}  // namespace base
+
+#elif defined(WCHAR_T_IS_UTF32)
+
+#include <wchar.h>  // for mbstate_t
+
+namespace base {
+
+typedef uint16_t char16;
+
+// char16 versions of the functions required by string16_char_traits; these
+// are based on the wide character functions of similar names ("w" or "wcs"
+// instead of "c16").
+BASE_EXPORT int c16memcmp(const char16* s1, const char16* s2, size_t n);
+BASE_EXPORT size_t c16len(const char16* s);
+BASE_EXPORT const char16* c16memchr(const char16* s, char16 c, size_t n);
+BASE_EXPORT char16* c16memmove(char16* s1, const char16* s2, size_t n);
+BASE_EXPORT char16* c16memcpy(char16* s1, const char16* s2, size_t n);
+BASE_EXPORT char16* c16memset(char16* s, char16 c, size_t n);
+
+// This namespace contains the implementation of base::string16 along with
+// things that need to be found via argument-dependent lookup from a
+// base::string16.
+namespace string16_internals {
+
+struct string16_char_traits {
+  typedef char16 char_type;
+  typedef int int_type;
+
+  // int_type needs to be able to hold each possible value of char_type, and in
+  // addition, the distinct value of eof().
+  static_assert(sizeof(int_type) > sizeof(char_type),
+                "int must be larger than 16 bits wide");
+
+  typedef std::streamoff off_type;
+  typedef mbstate_t state_type;
+  typedef std::fpos<state_type> pos_type;
+
+  static void assign(char_type& c1, const char_type& c2) {
+    c1 = c2;
+  }
+
+  static bool eq(const char_type& c1, const char_type& c2) {
+    return c1 == c2;
+  }
+  static bool lt(const char_type& c1, const char_type& c2) {
+    return c1 < c2;
+  }
+
+  static int compare(const char_type* s1, const char_type* s2, size_t n) {
+    return c16memcmp(s1, s2, n);
+  }
+
+  static size_t length(const char_type* s) {
+    return c16len(s);
+  }
+
+  static const char_type* find(const char_type* s, size_t n,
+                               const char_type& a) {
+    return c16memchr(s, a, n);
+  }
+
+  static char_type* move(char_type* s1, const char_type* s2, size_t n) {
+    return c16memmove(s1, s2, n);
+  }
+
+  static char_type* copy(char_type* s1, const char_type* s2, size_t n) {
+    return c16memcpy(s1, s2, n);
+  }
+
+  static char_type* assign(char_type* s, size_t n, char_type a) {
+    return c16memset(s, a, n);
+  }
+
+  static int_type not_eof(const int_type& c) {
+    return eq_int_type(c, eof()) ? 0 : c;
+  }
+
+  static char_type to_char_type(const int_type& c) {
+    return char_type(c);
+  }
+
+  static int_type to_int_type(const char_type& c) {
+    return int_type(c);
+  }
+
+  static bool eq_int_type(const int_type& c1, const int_type& c2) {
+    return c1 == c2;
+  }
+
+  static int_type eof() {
+    return static_cast<int_type>(EOF);
+  }
+};
+
+}  // namespace string16_internals
+
+typedef std::basic_string<char16,
+                          base::string16_internals::string16_char_traits>
+    string16;
+
+namespace string16_internals {
+
+BASE_EXPORT extern std::ostream& operator<<(std::ostream& out,
+                                            const string16& str);
+
+// This is required by googletest to print a readable output on test failures.
+BASE_EXPORT extern void PrintTo(const string16& str, std::ostream* out);
+
+}  // namespace string16_internals
+
+}  // namespace base
+
+// The string class will be explicitly instantiated only once, in string16.cc.
+//
+// std::basic_string<> in GNU libstdc++ contains a static data member,
+// _S_empty_rep_storage, to represent empty strings.  When an operation such
+// as assignment or destruction is performed on a string, causing its existing
+// data member to be invalidated, it must not be freed if this static data
+// member is being used.  Otherwise, it counts as an attempt to free static
+// (and not allocated) data, which is a memory error.
+//
+// Generally, due to C++ template magic, _S_empty_rep_storage will be marked
+// as a coalesced symbol, meaning that the linker will combine multiple
+// instances into a single one when generating output.
+//
+// If a string class is used by multiple shared libraries, a problem occurs.
+// Each library will get its own copy of _S_empty_rep_storage.  When strings
+// are passed across a library boundary for alteration or destruction, memory
+// errors will result.  GNU libstdc++ contains a configuration option,
+// --enable-fully-dynamic-string (_GLIBCXX_FULLY_DYNAMIC_STRING), which
+// disables the static data member optimization, but it's a good optimization
+// and non-STL code is generally at the mercy of the system's STL
+// configuration.  Fully-dynamic strings are not the default for GNU libstdc++
+// libstdc++ itself or for the libstdc++ installations on the systems we care
+// about, such as Mac OS X and relevant flavors of Linux.
+//
+// See also http://gcc.gnu.org/bugzilla/show_bug.cgi?id=24196 .
+//
+// To avoid problems, string classes need to be explicitly instantiated only
+// once, in exactly one library.  All other string users see it via an "extern"
+// declaration.  This is precisely how GNU libstdc++ handles
+// std::basic_string<char> (string) and std::basic_string<wchar_t> (wstring).
+//
+// This also works around a Mac OS X linker bug in ld64-85.2.1 (Xcode 3.1.2),
+// in which the linker does not fully coalesce symbols when dead code
+// stripping is enabled.  This bug causes the memory errors described above
+// to occur even when a std::basic_string<> does not cross shared library
+// boundaries, such as in statically-linked executables.
+//
+// TODO(mark): File this bug with Apple and update this note with a bug number.
+
+extern template class BASE_EXPORT
+    std::basic_string<base::char16,
+                      base::string16_internals::string16_char_traits>;
+
+// Specialize std::hash for base::string16. Although the style guide forbids
+// this in general, it is necessary for consistency with WCHAR_T_IS_UTF16
+// platforms, where base::string16 is a type alias for std::wstring.
+namespace std {
+template <>
+struct hash<base::string16> {
+  std::size_t operator()(const base::string16& s) const {
+    std::size_t result = 0;
+    for (base::char16 c : s)
+      result = (result * 131) + c;
+    return result;
+  }
+};
+}  // namespace std
+
+#endif  // WCHAR_T_IS_UTF32
+
+#endif  // BASE_STRINGS_STRING16_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_number_conversions.h b/native/zucchini/vendor/libchrome/base/strings/string_number_conversions.h
new file mode 100644
index 0000000..057b60a
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/string_number_conversions.h
@@ -0,0 +1,166 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_
+#define BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_piece.h"
+#include "build/build_config.h"
+
+// ----------------------------------------------------------------------------
+// IMPORTANT MESSAGE FROM YOUR SPONSOR
+//
+// This file contains no "wstring" variants. New code should use string16. If
+// you need to make old code work, use the UTF8 version and convert. Please do
+// not add wstring variants.
+//
+// Please do not add "convenience" functions for converting strings to integers
+// that return the value and ignore success/failure. That encourages people to
+// write code that doesn't properly handle the error conditions.
+//
+// DO NOT use these functions in any UI unless it's NOT localized on purpose.
+// Instead, use base::MessageFormatter for a complex message with numbers
+// (integer, float, double) embedded or base::Format{Number,Double,Percent} to
+// just format a single number/percent. Note that some languages use native
+// digits instead of ASCII digits while others use a group separator or decimal
+// point different from ',' and '.'. Using these functions in the UI would lead
+// numbers to be formatted in a non-native way.
+// ----------------------------------------------------------------------------
+
+namespace base {
+
+// Number -> string conversions ------------------------------------------------
+
+// Ignores locale! see warning above.
+BASE_EXPORT std::string NumberToString(int value);
+BASE_EXPORT string16 NumberToString16(int value);
+BASE_EXPORT std::string NumberToString(unsigned int value);
+BASE_EXPORT string16 NumberToString16(unsigned int value);
+BASE_EXPORT std::string NumberToString(long value);
+BASE_EXPORT string16 NumberToString16(long value);
+BASE_EXPORT std::string NumberToString(unsigned long value);
+BASE_EXPORT string16 NumberToString16(unsigned long value);
+BASE_EXPORT std::string NumberToString(long long value);
+BASE_EXPORT string16 NumberToString16(long long value);
+BASE_EXPORT std::string NumberToString(unsigned long long value);
+BASE_EXPORT string16 NumberToString16(unsigned long long value);
+BASE_EXPORT std::string NumberToString(double value);
+BASE_EXPORT string16 NumberToString16(double value);
+
+// Type-specific naming for backwards compatibility.
+//
+// TODO(brettw) these should be removed and callers converted to the overloaded
+// "NumberToString" variant.
+inline std::string IntToString(int value) {
+  return NumberToString(value);
+}
+inline string16 IntToString16(int value) {
+  return NumberToString16(value);
+}
+inline std::string UintToString(unsigned value) {
+  return NumberToString(value);
+}
+inline string16 UintToString16(unsigned value) {
+  return NumberToString16(value);
+}
+inline std::string Int64ToString(int64_t value) {
+  return NumberToString(value);
+}
+inline string16 Int64ToString16(int64_t value) {
+  return NumberToString16(value);
+}
+
+// String -> number conversions ------------------------------------------------
+
+// Perform a best-effort conversion of the input string to a numeric type,
+// setting |*output| to the result of the conversion.  Returns true for
+// "perfect" conversions; returns false in the following cases:
+//  - Overflow. |*output| will be set to the maximum value supported
+//    by the data type.
+//  - Underflow. |*output| will be set to the minimum value supported
+//    by the data type.
+//  - Trailing characters in the string after parsing the number.  |*output|
+//    will be set to the value of the number that was parsed.
+//  - Leading whitespace in the string before parsing the number. |*output| will
+//    be set to the value of the number that was parsed.
+//  - No characters parseable as a number at the beginning of the string.
+//    |*output| will be set to 0.
+//  - Empty string.  |*output| will be set to 0.
+// WARNING: Will write to |output| even when returning false.
+//          Read the comments above carefully.
+BASE_EXPORT bool StringToInt(StringPiece input, int* output);
+BASE_EXPORT bool StringToInt(StringPiece16 input, int* output);
+
+BASE_EXPORT bool StringToUint(StringPiece input, unsigned* output);
+BASE_EXPORT bool StringToUint(StringPiece16 input, unsigned* output);
+
+BASE_EXPORT bool StringToInt64(StringPiece input, int64_t* output);
+BASE_EXPORT bool StringToInt64(StringPiece16 input, int64_t* output);
+
+BASE_EXPORT bool StringToUint64(StringPiece input, uint64_t* output);
+BASE_EXPORT bool StringToUint64(StringPiece16 input, uint64_t* output);
+
+BASE_EXPORT bool StringToSizeT(StringPiece input, size_t* output);
+BASE_EXPORT bool StringToSizeT(StringPiece16 input, size_t* output);
+
+// For floating-point conversions, only conversions of input strings in decimal
+// form are defined to work.  Behavior with strings representing floating-point
+// numbers in hexadecimal, and strings representing non-finite values (such as
+// NaN and inf) is undefined.  Otherwise, these behave the same as the integral
+// variants.  This expects the input string to NOT be specific to the locale.
+// If your input is locale specific, use ICU to read the number.
+// WARNING: Will write to |output| even when returning false.
+//          Read the comments here and above StringToInt() carefully.
+BASE_EXPORT bool StringToDouble(const std::string& input, double* output);
+
+// Hex encoding ----------------------------------------------------------------
+
+// Returns a hex string representation of a binary buffer. The returned hex
+// string will be in upper case. This function does not check if |size| is
+// within reasonable limits since it's written with trusted data in mind.  If
+// you suspect that the data you want to format might be large, the absolute
+// max size for |size| should be is
+//   std::numeric_limits<size_t>::max() / 2
+BASE_EXPORT std::string HexEncode(const void* bytes, size_t size);
+
+// Best effort conversion, see StringToInt above for restrictions.
+// Will only successful parse hex values that will fit into |output|, i.e.
+// -0x80000000 < |input| < 0x7FFFFFFF.
+BASE_EXPORT bool HexStringToInt(StringPiece input, int* output);
+
+// Best effort conversion, see StringToInt above for restrictions.
+// Will only successful parse hex values that will fit into |output|, i.e.
+// 0x00000000 < |input| < 0xFFFFFFFF.
+// The string is not required to start with 0x.
+BASE_EXPORT bool HexStringToUInt(StringPiece input, uint32_t* output);
+
+// Best effort conversion, see StringToInt above for restrictions.
+// Will only successful parse hex values that will fit into |output|, i.e.
+// -0x8000000000000000 < |input| < 0x7FFFFFFFFFFFFFFF.
+BASE_EXPORT bool HexStringToInt64(StringPiece input, int64_t* output);
+
+// Best effort conversion, see StringToInt above for restrictions.
+// Will only successful parse hex values that will fit into |output|, i.e.
+// 0x0000000000000000 < |input| < 0xFFFFFFFFFFFFFFFF.
+// The string is not required to start with 0x.
+BASE_EXPORT bool HexStringToUInt64(StringPiece input, uint64_t* output);
+
+// Similar to the previous functions, except that output is a vector of bytes.
+// |*output| will contain as many bytes as were successfully parsed prior to the
+// error.  There is no overflow, but input.size() must be evenly divisible by 2.
+// Leading 0x or +/- are not allowed.
+BASE_EXPORT bool HexStringToBytes(StringPiece input,
+                                  std::vector<uint8_t>* output);
+
+}  // namespace base
+
+#endif  // BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_piece.cc b/native/zucchini/vendor/libchrome/base/strings/string_piece.cc
new file mode 100644
index 0000000..c82a223
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/string_piece.cc
@@ -0,0 +1,453 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+// Copied from strings/stringpiece.cc with modifications
+
+#include "base/strings/string_piece.h"
+
+#include <limits.h>
+
+#include <algorithm>
+#include <ostream>
+
+#include "base/logging.h"
+
+namespace base {
+namespace {
+
+// For each character in characters_wanted, sets the index corresponding
+// to the ASCII code of that character to 1 in table.  This is used by
+// the find_.*_of methods below to tell whether or not a character is in
+// the lookup table in constant time.
+// The argument `table' must be an array that is large enough to hold all
+// the possible values of an unsigned char.  Thus it should be be declared
+// as follows:
+//   bool table[UCHAR_MAX + 1]
+inline void BuildLookupTable(const StringPiece& characters_wanted,
+                             bool* table) {
+  const size_t length = characters_wanted.length();
+  const char* const data = characters_wanted.data();
+  for (size_t i = 0; i < length; ++i) {
+    table[static_cast<unsigned char>(data[i])] = true;
+  }
+}
+
+}  // namespace
+
+// MSVC doesn't like complex extern templates and DLLs.
+#if !defined(COMPILER_MSVC)
+template class BasicStringPiece<std::string>;
+template class BasicStringPiece<string16>;
+#endif
+
+bool operator==(const StringPiece& x, const StringPiece& y) {
+  if (x.size() != y.size())
+    return false;
+
+  return CharTraits<StringPiece::value_type>::compare(x.data(), y.data(),
+                                                      x.size()) == 0;
+}
+
+std::ostream& operator<<(std::ostream& o, const StringPiece& piece) {
+  o.write(piece.data(), static_cast<std::streamsize>(piece.size()));
+  return o;
+}
+
+namespace internal {
+
+template<typename STR>
+void CopyToStringT(const BasicStringPiece<STR>& self, STR* target) {
+  if (self.empty())
+    target->clear();
+  else
+    target->assign(self.data(), self.size());
+}
+
+void CopyToString(const StringPiece& self, std::string* target) {
+  CopyToStringT(self, target);
+}
+
+void CopyToString(const StringPiece16& self, string16* target) {
+  CopyToStringT(self, target);
+}
+
+template<typename STR>
+void AppendToStringT(const BasicStringPiece<STR>& self, STR* target) {
+  if (!self.empty())
+    target->append(self.data(), self.size());
+}
+
+void AppendToString(const StringPiece& self, std::string* target) {
+  AppendToStringT(self, target);
+}
+
+void AppendToString(const StringPiece16& self, string16* target) {
+  AppendToStringT(self, target);
+}
+
+template<typename STR>
+size_t copyT(const BasicStringPiece<STR>& self,
+             typename STR::value_type* buf,
+             size_t n,
+             size_t pos) {
+  size_t ret = std::min(self.size() - pos, n);
+  memcpy(buf, self.data() + pos, ret * sizeof(typename STR::value_type));
+  return ret;
+}
+
+size_t copy(const StringPiece& self, char* buf, size_t n, size_t pos) {
+  return copyT(self, buf, n, pos);
+}
+
+size_t copy(const StringPiece16& self, char16* buf, size_t n, size_t pos) {
+  return copyT(self, buf, n, pos);
+}
+
+template<typename STR>
+size_t findT(const BasicStringPiece<STR>& self,
+             const BasicStringPiece<STR>& s,
+             size_t pos) {
+  if (pos > self.size())
+    return BasicStringPiece<STR>::npos;
+
+  typename BasicStringPiece<STR>::const_iterator result =
+      std::search(self.begin() + pos, self.end(), s.begin(), s.end());
+  const size_t xpos =
+    static_cast<size_t>(result - self.begin());
+  return xpos + s.size() <= self.size() ? xpos : BasicStringPiece<STR>::npos;
+}
+
+size_t find(const StringPiece& self, const StringPiece& s, size_t pos) {
+  return findT(self, s, pos);
+}
+
+size_t find(const StringPiece16& self, const StringPiece16& s, size_t pos) {
+  return findT(self, s, pos);
+}
+
+template<typename STR>
+size_t findT(const BasicStringPiece<STR>& self,
+             typename STR::value_type c,
+             size_t pos) {
+  if (pos >= self.size())
+    return BasicStringPiece<STR>::npos;
+
+  typename BasicStringPiece<STR>::const_iterator result =
+      std::find(self.begin() + pos, self.end(), c);
+  return result != self.end() ?
+      static_cast<size_t>(result - self.begin()) : BasicStringPiece<STR>::npos;
+}
+
+size_t find(const StringPiece& self, char c, size_t pos) {
+  return findT(self, c, pos);
+}
+
+size_t find(const StringPiece16& self, char16 c, size_t pos) {
+  return findT(self, c, pos);
+}
+
+template<typename STR>
+size_t rfindT(const BasicStringPiece<STR>& self,
+              const BasicStringPiece<STR>& s,
+              size_t pos) {
+  if (self.size() < s.size())
+    return BasicStringPiece<STR>::npos;
+
+  if (s.empty())
+    return std::min(self.size(), pos);
+
+  typename BasicStringPiece<STR>::const_iterator last =
+      self.begin() + std::min(self.size() - s.size(), pos) + s.size();
+  typename BasicStringPiece<STR>::const_iterator result =
+      std::find_end(self.begin(), last, s.begin(), s.end());
+  return result != last ?
+      static_cast<size_t>(result - self.begin()) : BasicStringPiece<STR>::npos;
+}
+
+size_t rfind(const StringPiece& self, const StringPiece& s, size_t pos) {
+  return rfindT(self, s, pos);
+}
+
+size_t rfind(const StringPiece16& self, const StringPiece16& s, size_t pos) {
+  return rfindT(self, s, pos);
+}
+
+template<typename STR>
+size_t rfindT(const BasicStringPiece<STR>& self,
+              typename STR::value_type c,
+              size_t pos) {
+  if (self.size() == 0)
+    return BasicStringPiece<STR>::npos;
+
+  for (size_t i = std::min(pos, self.size() - 1); ;
+       --i) {
+    if (self.data()[i] == c)
+      return i;
+    if (i == 0)
+      break;
+  }
+  return BasicStringPiece<STR>::npos;
+}
+
+size_t rfind(const StringPiece& self, char c, size_t pos) {
+  return rfindT(self, c, pos);
+}
+
+size_t rfind(const StringPiece16& self, char16 c, size_t pos) {
+  return rfindT(self, c, pos);
+}
+
+// 8-bit version using lookup table.
+size_t find_first_of(const StringPiece& self,
+                     const StringPiece& s,
+                     size_t pos) {
+  if (self.size() == 0 || s.size() == 0)
+    return StringPiece::npos;
+
+  // Avoid the cost of BuildLookupTable() for a single-character search.
+  if (s.size() == 1)
+    return find(self, s.data()[0], pos);
+
+  bool lookup[UCHAR_MAX + 1] = { false };
+  BuildLookupTable(s, lookup);
+  for (size_t i = pos; i < self.size(); ++i) {
+    if (lookup[static_cast<unsigned char>(self.data()[i])]) {
+      return i;
+    }
+  }
+  return StringPiece::npos;
+}
+
+// 16-bit brute force version.
+size_t find_first_of(const StringPiece16& self,
+                     const StringPiece16& s,
+                     size_t pos) {
+  StringPiece16::const_iterator found =
+      std::find_first_of(self.begin() + pos, self.end(), s.begin(), s.end());
+  if (found == self.end())
+    return StringPiece16::npos;
+  return found - self.begin();
+}
+
+// 8-bit version using lookup table.
+size_t find_first_not_of(const StringPiece& self,
+                         const StringPiece& s,
+                         size_t pos) {
+  if (self.size() == 0)
+    return StringPiece::npos;
+
+  if (s.size() == 0)
+    return 0;
+
+  // Avoid the cost of BuildLookupTable() for a single-character search.
+  if (s.size() == 1)
+    return find_first_not_of(self, s.data()[0], pos);
+
+  bool lookup[UCHAR_MAX + 1] = { false };
+  BuildLookupTable(s, lookup);
+  for (size_t i = pos; i < self.size(); ++i) {
+    if (!lookup[static_cast<unsigned char>(self.data()[i])]) {
+      return i;
+    }
+  }
+  return StringPiece::npos;
+}
+
+// 16-bit brute-force version.
+BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
+                                     const StringPiece16& s,
+                                     size_t pos) {
+  if (self.size() == 0)
+    return StringPiece16::npos;
+
+  for (size_t self_i = pos; self_i < self.size(); ++self_i) {
+    bool found = false;
+    for (size_t s_i = 0; s_i < s.size(); ++s_i) {
+      if (self[self_i] == s[s_i]) {
+        found = true;
+        break;
+      }
+    }
+    if (!found)
+      return self_i;
+  }
+  return StringPiece16::npos;
+}
+
+template<typename STR>
+size_t find_first_not_ofT(const BasicStringPiece<STR>& self,
+                          typename STR::value_type c,
+                          size_t pos) {
+  if (self.size() == 0)
+    return BasicStringPiece<STR>::npos;
+
+  for (; pos < self.size(); ++pos) {
+    if (self.data()[pos] != c) {
+      return pos;
+    }
+  }
+  return BasicStringPiece<STR>::npos;
+}
+
+size_t find_first_not_of(const StringPiece& self,
+                         char c,
+                         size_t pos) {
+  return find_first_not_ofT(self, c, pos);
+}
+
+size_t find_first_not_of(const StringPiece16& self,
+                         char16 c,
+                         size_t pos) {
+  return find_first_not_ofT(self, c, pos);
+}
+
+// 8-bit version using lookup table.
+size_t find_last_of(const StringPiece& self, const StringPiece& s, size_t pos) {
+  if (self.size() == 0 || s.size() == 0)
+    return StringPiece::npos;
+
+  // Avoid the cost of BuildLookupTable() for a single-character search.
+  if (s.size() == 1)
+    return rfind(self, s.data()[0], pos);
+
+  bool lookup[UCHAR_MAX + 1] = { false };
+  BuildLookupTable(s, lookup);
+  for (size_t i = std::min(pos, self.size() - 1); ; --i) {
+    if (lookup[static_cast<unsigned char>(self.data()[i])])
+      return i;
+    if (i == 0)
+      break;
+  }
+  return StringPiece::npos;
+}
+
+// 16-bit brute-force version.
+size_t find_last_of(const StringPiece16& self,
+                    const StringPiece16& s,
+                    size_t pos) {
+  if (self.size() == 0)
+    return StringPiece16::npos;
+
+  for (size_t self_i = std::min(pos, self.size() - 1); ;
+       --self_i) {
+    for (size_t s_i = 0; s_i < s.size(); s_i++) {
+      if (self.data()[self_i] == s[s_i])
+        return self_i;
+    }
+    if (self_i == 0)
+      break;
+  }
+  return StringPiece16::npos;
+}
+
+// 8-bit version using lookup table.
+size_t find_last_not_of(const StringPiece& self,
+                        const StringPiece& s,
+                        size_t pos) {
+  if (self.size() == 0)
+    return StringPiece::npos;
+
+  size_t i = std::min(pos, self.size() - 1);
+  if (s.size() == 0)
+    return i;
+
+  // Avoid the cost of BuildLookupTable() for a single-character search.
+  if (s.size() == 1)
+    return find_last_not_of(self, s.data()[0], pos);
+
+  bool lookup[UCHAR_MAX + 1] = { false };
+  BuildLookupTable(s, lookup);
+  for (; ; --i) {
+    if (!lookup[static_cast<unsigned char>(self.data()[i])])
+      return i;
+    if (i == 0)
+      break;
+  }
+  return StringPiece::npos;
+}
+
+// 16-bit brute-force version.
+size_t find_last_not_of(const StringPiece16& self,
+                        const StringPiece16& s,
+                        size_t pos) {
+  if (self.size() == 0)
+    return StringPiece::npos;
+
+  for (size_t self_i = std::min(pos, self.size() - 1); ; --self_i) {
+    bool found = false;
+    for (size_t s_i = 0; s_i < s.size(); s_i++) {
+      if (self.data()[self_i] == s[s_i]) {
+        found = true;
+        break;
+      }
+    }
+    if (!found)
+      return self_i;
+    if (self_i == 0)
+      break;
+  }
+  return StringPiece16::npos;
+}
+
+template<typename STR>
+size_t find_last_not_ofT(const BasicStringPiece<STR>& self,
+                         typename STR::value_type c,
+                         size_t pos) {
+  if (self.size() == 0)
+    return BasicStringPiece<STR>::npos;
+
+  for (size_t i = std::min(pos, self.size() - 1); ; --i) {
+    if (self.data()[i] != c)
+      return i;
+    if (i == 0)
+      break;
+  }
+  return BasicStringPiece<STR>::npos;
+}
+
+size_t find_last_not_of(const StringPiece& self,
+                        char c,
+                        size_t pos) {
+  return find_last_not_ofT(self, c, pos);
+}
+
+size_t find_last_not_of(const StringPiece16& self,
+                        char16 c,
+                        size_t pos) {
+  return find_last_not_ofT(self, c, pos);
+}
+
+template<typename STR>
+BasicStringPiece<STR> substrT(const BasicStringPiece<STR>& self,
+                              size_t pos,
+                              size_t n) {
+  if (pos > self.size()) pos = self.size();
+  if (n > self.size() - pos) n = self.size() - pos;
+  return BasicStringPiece<STR>(self.data() + pos, n);
+}
+
+StringPiece substr(const StringPiece& self,
+                   size_t pos,
+                   size_t n) {
+  return substrT(self, pos, n);
+}
+
+StringPiece16 substr(const StringPiece16& self,
+                     size_t pos,
+                     size_t n) {
+  return substrT(self, pos, n);
+}
+
+#if DCHECK_IS_ON()
+void AssertIteratorsInOrder(std::string::const_iterator begin,
+                            std::string::const_iterator end) {
+  DCHECK(begin <= end) << "StringPiece iterators swapped or invalid.";
+}
+void AssertIteratorsInOrder(string16::const_iterator begin,
+                            string16::const_iterator end) {
+  DCHECK(begin <= end) << "StringPiece iterators swapped or invalid.";
+}
+#endif
+
+}  // namespace internal
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_piece.h b/native/zucchini/vendor/libchrome/base/strings/string_piece.h
new file mode 100644
index 0000000..775ea7c
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/string_piece.h
@@ -0,0 +1,483 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+// Copied from strings/stringpiece.h with modifications
+//
+// A string-like object that points to a sized piece of memory.
+//
+// You can use StringPiece as a function or method parameter.  A StringPiece
+// parameter can receive a double-quoted string literal argument, a "const
+// char*" argument, a string argument, or a StringPiece argument with no data
+// copying.  Systematic use of StringPiece for arguments reduces data
+// copies and strlen() calls.
+//
+// Prefer passing StringPieces by value:
+//   void MyFunction(StringPiece arg);
+// If circumstances require, you may also pass by const reference:
+//   void MyFunction(const StringPiece& arg);  // not preferred
+// Both of these have the same lifetime semantics.  Passing by value
+// generates slightly smaller code.  For more discussion, Googlers can see
+// the thread go/stringpiecebyvalue on c-users.
+
+#ifndef BASE_STRINGS_STRING_PIECE_H_
+#define BASE_STRINGS_STRING_PIECE_H_
+
+#include <stddef.h>
+
+#include <iosfwd>
+#include <string>
+
+#include "base/base_export.h"
+#include "base/logging.h"
+#include "base/strings/char_traits.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_piece_forward.h"
+
+namespace base {
+
+// internal --------------------------------------------------------------------
+
+// Many of the StringPiece functions use different implementations for the
+// 8-bit and 16-bit versions, and we don't want lots of template expansions in
+// this (very common) header that will slow down compilation.
+//
+// So here we define overloaded functions called by the StringPiece template.
+// For those that share an implementation, the two versions will expand to a
+// template internal to the .cc file.
+namespace internal {
+
+BASE_EXPORT void CopyToString(const StringPiece& self, std::string* target);
+BASE_EXPORT void CopyToString(const StringPiece16& self, string16* target);
+
+BASE_EXPORT void AppendToString(const StringPiece& self, std::string* target);
+BASE_EXPORT void AppendToString(const StringPiece16& self, string16* target);
+
+BASE_EXPORT size_t copy(const StringPiece& self,
+                        char* buf,
+                        size_t n,
+                        size_t pos);
+BASE_EXPORT size_t copy(const StringPiece16& self,
+                        char16* buf,
+                        size_t n,
+                        size_t pos);
+
+BASE_EXPORT size_t find(const StringPiece& self,
+                        const StringPiece& s,
+                        size_t pos);
+BASE_EXPORT size_t find(const StringPiece16& self,
+                        const StringPiece16& s,
+                        size_t pos);
+BASE_EXPORT size_t find(const StringPiece& self,
+                        char c,
+                        size_t pos);
+BASE_EXPORT size_t find(const StringPiece16& self,
+                        char16 c,
+                        size_t pos);
+
+BASE_EXPORT size_t rfind(const StringPiece& self,
+                         const StringPiece& s,
+                         size_t pos);
+BASE_EXPORT size_t rfind(const StringPiece16& self,
+                         const StringPiece16& s,
+                         size_t pos);
+BASE_EXPORT size_t rfind(const StringPiece& self,
+                         char c,
+                         size_t pos);
+BASE_EXPORT size_t rfind(const StringPiece16& self,
+                         char16 c,
+                         size_t pos);
+
+BASE_EXPORT size_t find_first_of(const StringPiece& self,
+                                 const StringPiece& s,
+                                 size_t pos);
+BASE_EXPORT size_t find_first_of(const StringPiece16& self,
+                                 const StringPiece16& s,
+                                 size_t pos);
+
+BASE_EXPORT size_t find_first_not_of(const StringPiece& self,
+                                     const StringPiece& s,
+                                     size_t pos);
+BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
+                                     const StringPiece16& s,
+                                     size_t pos);
+BASE_EXPORT size_t find_first_not_of(const StringPiece& self,
+                                     char c,
+                                     size_t pos);
+BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
+                                     char16 c,
+                                     size_t pos);
+
+BASE_EXPORT size_t find_last_of(const StringPiece& self,
+                                const StringPiece& s,
+                                size_t pos);
+BASE_EXPORT size_t find_last_of(const StringPiece16& self,
+                                const StringPiece16& s,
+                                size_t pos);
+BASE_EXPORT size_t find_last_of(const StringPiece& self,
+                                char c,
+                                size_t pos);
+BASE_EXPORT size_t find_last_of(const StringPiece16& self,
+                                char16 c,
+                                size_t pos);
+
+BASE_EXPORT size_t find_last_not_of(const StringPiece& self,
+                                    const StringPiece& s,
+                                    size_t pos);
+BASE_EXPORT size_t find_last_not_of(const StringPiece16& self,
+                                    const StringPiece16& s,
+                                    size_t pos);
+BASE_EXPORT size_t find_last_not_of(const StringPiece16& self,
+                                    char16 c,
+                                    size_t pos);
+BASE_EXPORT size_t find_last_not_of(const StringPiece& self,
+                                    char c,
+                                    size_t pos);
+
+BASE_EXPORT StringPiece substr(const StringPiece& self,
+                               size_t pos,
+                               size_t n);
+BASE_EXPORT StringPiece16 substr(const StringPiece16& self,
+                                 size_t pos,
+                                 size_t n);
+
+#if DCHECK_IS_ON()
+// Asserts that begin <= end to catch some errors with iterator usage.
+BASE_EXPORT void AssertIteratorsInOrder(std::string::const_iterator begin,
+                                        std::string::const_iterator end);
+BASE_EXPORT void AssertIteratorsInOrder(string16::const_iterator begin,
+                                        string16::const_iterator end);
+#endif
+
+}  // namespace internal
+
+// BasicStringPiece ------------------------------------------------------------
+
+// Defines the types, methods, operators, and data members common to both
+// StringPiece and StringPiece16. Do not refer to this class directly, but
+// rather to BasicStringPiece, StringPiece, or StringPiece16.
+//
+// This is templatized by string class type rather than character type, so
+// BasicStringPiece<std::string> or BasicStringPiece<base::string16>.
+template <typename STRING_TYPE> class BasicStringPiece {
+ public:
+  // Standard STL container boilerplate.
+  typedef size_t size_type;
+  typedef typename STRING_TYPE::value_type value_type;
+  typedef const value_type* pointer;
+  typedef const value_type& reference;
+  typedef const value_type& const_reference;
+  typedef ptrdiff_t difference_type;
+  typedef const value_type* const_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+  static const size_type npos;
+
+ public:
+  // We provide non-explicit singleton constructors so users can pass
+  // in a "const char*" or a "string" wherever a "StringPiece" is
+  // expected (likewise for char16, string16, StringPiece16).
+  constexpr BasicStringPiece() : ptr_(NULL), length_(0) {}
+  // TODO(dcheng): Construction from nullptr is not allowed for
+  // std::basic_string_view, so remove the special handling for it.
+  // Note: This doesn't just use STRING_TYPE::traits_type::length(), since that
+  // isn't constexpr until C++17.
+  constexpr BasicStringPiece(const value_type* str)
+      : ptr_(str), length_(!str ? 0 : CharTraits<value_type>::length(str)) {}
+  BasicStringPiece(const STRING_TYPE& str)
+      : ptr_(str.data()), length_(str.size()) {}
+  constexpr BasicStringPiece(const value_type* offset, size_type len)
+      : ptr_(offset), length_(len) {}
+  BasicStringPiece(const typename STRING_TYPE::const_iterator& begin,
+                   const typename STRING_TYPE::const_iterator& end) {
+#if DCHECK_IS_ON()
+    // This assertion is done out-of-line to avoid bringing in logging.h and
+    // instantiating logging macros for every instantiation.
+    internal::AssertIteratorsInOrder(begin, end);
+#endif
+    length_ = static_cast<size_t>(std::distance(begin, end));
+
+    // The length test before assignment is to avoid dereferencing an iterator
+    // that may point to the end() of a string.
+    ptr_ = length_ > 0 ? &*begin : nullptr;
+  }
+
+  // data() may return a pointer to a buffer with embedded NULs, and the
+  // returned buffer may or may not be null terminated.  Therefore it is
+  // typically a mistake to pass data() to a routine that expects a NUL
+  // terminated string.
+  constexpr const value_type* data() const { return ptr_; }
+  constexpr size_type size() const { return length_; }
+  constexpr size_type length() const { return length_; }
+  bool empty() const { return length_ == 0; }
+
+  void clear() {
+    ptr_ = NULL;
+    length_ = 0;
+  }
+  void set(const value_type* data, size_type len) {
+    ptr_ = data;
+    length_ = len;
+  }
+  void set(const value_type* str) {
+    ptr_ = str;
+    length_ = str ? STRING_TYPE::traits_type::length(str) : 0;
+  }
+
+  constexpr value_type operator[](size_type i) const {
+    CHECK(i < length_);
+    return ptr_[i];
+  }
+
+  value_type front() const {
+    CHECK_NE(0UL, length_);
+    return ptr_[0];
+  }
+
+  value_type back() const {
+    CHECK_NE(0UL, length_);
+    return ptr_[length_ - 1];
+  }
+
+  constexpr void remove_prefix(size_type n) {
+    CHECK(n <= length_);
+    ptr_ += n;
+    length_ -= n;
+  }
+
+  constexpr void remove_suffix(size_type n) {
+    CHECK(n <= length_);
+    length_ -= n;
+  }
+
+  constexpr int compare(BasicStringPiece x) const noexcept {
+    int r = CharTraits<value_type>::compare(
+        ptr_, x.ptr_, (length_ < x.length_ ? length_ : x.length_));
+    if (r == 0) {
+      if (length_ < x.length_) r = -1;
+      else if (length_ > x.length_) r = +1;
+    }
+    return r;
+  }
+
+  // This is the style of conversion preferred by std::string_view in C++17.
+  explicit operator STRING_TYPE() const { return as_string(); }
+
+  STRING_TYPE as_string() const {
+    // std::string doesn't like to take a NULL pointer even with a 0 size.
+    return empty() ? STRING_TYPE() : STRING_TYPE(data(), size());
+  }
+
+  const_iterator begin() const { return ptr_; }
+  const_iterator end() const { return ptr_ + length_; }
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(ptr_ + length_);
+  }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(ptr_);
+  }
+
+  size_type max_size() const { return length_; }
+  size_type capacity() const { return length_; }
+
+  // Sets the value of the given string target type to be the current string.
+  // This saves a temporary over doing |a = b.as_string()|
+  void CopyToString(STRING_TYPE* target) const {
+    internal::CopyToString(*this, target);
+  }
+
+  void AppendToString(STRING_TYPE* target) const {
+    internal::AppendToString(*this, target);
+  }
+
+  size_type copy(value_type* buf, size_type n, size_type pos = 0) const {
+    return internal::copy(*this, buf, n, pos);
+  }
+
+  // Does "this" start with "x"
+  constexpr bool starts_with(BasicStringPiece x) const noexcept {
+    return (
+        (this->length_ >= x.length_) &&
+        (CharTraits<value_type>::compare(this->ptr_, x.ptr_, x.length_) == 0));
+  }
+
+  // Does "this" end with "x"
+  constexpr bool ends_with(BasicStringPiece x) const noexcept {
+    return ((this->length_ >= x.length_) &&
+            (CharTraits<value_type>::compare(
+                 this->ptr_ + (this->length_ - x.length_), x.ptr_, x.length_) ==
+             0));
+  }
+
+  // find: Search for a character or substring at a given offset.
+  size_type find(const BasicStringPiece<STRING_TYPE>& s,
+                 size_type pos = 0) const {
+    return internal::find(*this, s, pos);
+  }
+  size_type find(value_type c, size_type pos = 0) const {
+    return internal::find(*this, c, pos);
+  }
+
+  // rfind: Reverse find.
+  size_type rfind(const BasicStringPiece& s,
+                  size_type pos = BasicStringPiece::npos) const {
+    return internal::rfind(*this, s, pos);
+  }
+  size_type rfind(value_type c, size_type pos = BasicStringPiece::npos) const {
+    return internal::rfind(*this, c, pos);
+  }
+
+  // find_first_of: Find the first occurence of one of a set of characters.
+  size_type find_first_of(const BasicStringPiece& s,
+                          size_type pos = 0) const {
+    return internal::find_first_of(*this, s, pos);
+  }
+  size_type find_first_of(value_type c, size_type pos = 0) const {
+    return find(c, pos);
+  }
+
+  // find_first_not_of: Find the first occurence not of a set of characters.
+  size_type find_first_not_of(const BasicStringPiece& s,
+                              size_type pos = 0) const {
+    return internal::find_first_not_of(*this, s, pos);
+  }
+  size_type find_first_not_of(value_type c, size_type pos = 0) const {
+    return internal::find_first_not_of(*this, c, pos);
+  }
+
+  // find_last_of: Find the last occurence of one of a set of characters.
+  size_type find_last_of(const BasicStringPiece& s,
+                         size_type pos = BasicStringPiece::npos) const {
+    return internal::find_last_of(*this, s, pos);
+  }
+  size_type find_last_of(value_type c,
+                         size_type pos = BasicStringPiece::npos) const {
+    return rfind(c, pos);
+  }
+
+  // find_last_not_of: Find the last occurence not of a set of characters.
+  size_type find_last_not_of(const BasicStringPiece& s,
+                             size_type pos = BasicStringPiece::npos) const {
+    return internal::find_last_not_of(*this, s, pos);
+  }
+  size_type find_last_not_of(value_type c,
+                             size_type pos = BasicStringPiece::npos) const {
+    return internal::find_last_not_of(*this, c, pos);
+  }
+
+  // substr.
+  BasicStringPiece substr(size_type pos,
+                          size_type n = BasicStringPiece::npos) const {
+    return internal::substr(*this, pos, n);
+  }
+
+ protected:
+  const value_type* ptr_;
+  size_type length_;
+};
+
+template <typename STRING_TYPE>
+const typename BasicStringPiece<STRING_TYPE>::size_type
+BasicStringPiece<STRING_TYPE>::npos =
+    typename BasicStringPiece<STRING_TYPE>::size_type(-1);
+
+// MSVC doesn't like complex extern templates and DLLs.
+#if !defined(COMPILER_MSVC)
+extern template class BASE_EXPORT BasicStringPiece<std::string>;
+extern template class BASE_EXPORT BasicStringPiece<string16>;
+#endif
+
+// StingPiece operators --------------------------------------------------------
+
+BASE_EXPORT bool operator==(const StringPiece& x, const StringPiece& y);
+
+inline bool operator!=(const StringPiece& x, const StringPiece& y) {
+  return !(x == y);
+}
+
+inline bool operator<(const StringPiece& x, const StringPiece& y) {
+  const int r = CharTraits<StringPiece::value_type>::compare(
+      x.data(), y.data(), (x.size() < y.size() ? x.size() : y.size()));
+  return ((r < 0) || ((r == 0) && (x.size() < y.size())));
+}
+
+inline bool operator>(const StringPiece& x, const StringPiece& y) {
+  return y < x;
+}
+
+inline bool operator<=(const StringPiece& x, const StringPiece& y) {
+  return !(x > y);
+}
+
+inline bool operator>=(const StringPiece& x, const StringPiece& y) {
+  return !(x < y);
+}
+
+// StringPiece16 operators -----------------------------------------------------
+
+inline bool operator==(const StringPiece16& x, const StringPiece16& y) {
+  if (x.size() != y.size())
+    return false;
+
+  return CharTraits<StringPiece16::value_type>::compare(x.data(), y.data(),
+                                                        x.size()) == 0;
+}
+
+inline bool operator!=(const StringPiece16& x, const StringPiece16& y) {
+  return !(x == y);
+}
+
+inline bool operator<(const StringPiece16& x, const StringPiece16& y) {
+  const int r = CharTraits<StringPiece16::value_type>::compare(
+      x.data(), y.data(), (x.size() < y.size() ? x.size() : y.size()));
+  return ((r < 0) || ((r == 0) && (x.size() < y.size())));
+}
+
+inline bool operator>(const StringPiece16& x, const StringPiece16& y) {
+  return y < x;
+}
+
+inline bool operator<=(const StringPiece16& x, const StringPiece16& y) {
+  return !(x > y);
+}
+
+inline bool operator>=(const StringPiece16& x, const StringPiece16& y) {
+  return !(x < y);
+}
+
+BASE_EXPORT std::ostream& operator<<(std::ostream& o,
+                                     const StringPiece& piece);
+
+// Hashing ---------------------------------------------------------------------
+
+// We provide appropriate hash functions so StringPiece and StringPiece16 can
+// be used as keys in hash sets and maps.
+
+// This hash function is copied from base/strings/string16.h. We don't use the
+// ones already defined for string and string16 directly because it would
+// require the string constructors to be called, which we don't want.
+#define HASH_STRING_PIECE(StringPieceType, string_piece)         \
+  std::size_t result = 0;                                        \
+  for (StringPieceType::const_iterator i = string_piece.begin(); \
+       i != string_piece.end(); ++i)                             \
+    result = (result * 131) + *i;                                \
+  return result;
+
+struct StringPieceHash {
+  std::size_t operator()(const StringPiece& sp) const {
+    HASH_STRING_PIECE(StringPiece, sp);
+  }
+};
+struct StringPiece16Hash {
+  std::size_t operator()(const StringPiece16& sp16) const {
+    HASH_STRING_PIECE(StringPiece16, sp16);
+  }
+};
+struct WStringPieceHash {
+  std::size_t operator()(const WStringPiece& wsp) const {
+    HASH_STRING_PIECE(WStringPiece, wsp);
+  }
+};
+
+}  // namespace base
+
+#endif  // BASE_STRINGS_STRING_PIECE_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_piece_forward.h b/native/zucchini/vendor/libchrome/base/strings/string_piece_forward.h
new file mode 100644
index 0000000..b50b980
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/string_piece_forward.h
@@ -0,0 +1,24 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Forward declaration of StringPiece types from base/strings/string_piece.h
+
+#ifndef BASE_STRINGS_STRING_PIECE_FORWARD_H_
+#define BASE_STRINGS_STRING_PIECE_FORWARD_H_
+
+#include <string>
+
+#include "base/strings/string16.h"
+
+namespace base {
+
+template <typename STRING_TYPE>
+class BasicStringPiece;
+typedef BasicStringPiece<std::string> StringPiece;
+typedef BasicStringPiece<string16> StringPiece16;
+typedef BasicStringPiece<std::wstring> WStringPiece;
+
+}  // namespace base
+
+#endif  // BASE_STRINGS_STRING_PIECE_FORWARD_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_util.cc b/native/zucchini/vendor/libchrome/base/strings/string_util.cc
new file mode 100644
index 0000000..32e5ff2
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/string_util.cc
@@ -0,0 +1,1124 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/strings/string_util.h"
+
+#include <ctype.h>
+#include <errno.h>
+#include <math.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <wchar.h>
+#include <wctype.h>
+
+#include <algorithm>
+#include <limits>
+#include <vector>
+
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/singleton.h"
+#include "base/strings/utf_string_conversion_utils.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/third_party/icu/icu_utf.h"
+#include "build/build_config.h"
+
+namespace base {
+
+namespace {
+
+// Force the singleton used by EmptyString[16] to be a unique type. This
+// prevents other code that might accidentally use Singleton<string> from
+// getting our internal one.
+struct EmptyStrings {
+  EmptyStrings() = default;
+  const std::string s;
+  const string16 s16;
+
+  static EmptyStrings* GetInstance() {
+    return Singleton<EmptyStrings>::get();
+  }
+};
+
+// Used by ReplaceStringPlaceholders to track the position in the string of
+// replaced parameters.
+struct ReplacementOffset {
+  ReplacementOffset(uintptr_t parameter, size_t offset)
+      : parameter(parameter),
+        offset(offset) {}
+
+  // Index of the parameter.
+  uintptr_t parameter;
+
+  // Starting position in the string.
+  size_t offset;
+};
+
+static bool CompareParameter(const ReplacementOffset& elem1,
+                             const ReplacementOffset& elem2) {
+  return elem1.parameter < elem2.parameter;
+}
+
+// Overloaded function to append one string onto the end of another. Having a
+// separate overload for |source| as both string and StringPiece allows for more
+// efficient usage from functions templated to work with either type (avoiding a
+// redundant call to the BasicStringPiece constructor in both cases).
+template <typename string_type>
+inline void AppendToString(string_type* target, const string_type& source) {
+  target->append(source);
+}
+
+template <typename string_type>
+inline void AppendToString(string_type* target,
+                           const BasicStringPiece<string_type>& source) {
+  source.AppendToString(target);
+}
+
+// Assuming that a pointer is the size of a "machine word", then
+// uintptr_t is an integer type that is also a machine word.
+typedef uintptr_t MachineWord;
+const uintptr_t kMachineWordAlignmentMask = sizeof(MachineWord) - 1;
+
+inline bool IsAlignedToMachineWord(const void* pointer) {
+  return !(reinterpret_cast<MachineWord>(pointer) & kMachineWordAlignmentMask);
+}
+
+template<typename T> inline T* AlignToMachineWord(T* pointer) {
+  return reinterpret_cast<T*>(reinterpret_cast<MachineWord>(pointer) &
+                              ~kMachineWordAlignmentMask);
+}
+
+template<size_t size, typename CharacterType> struct NonASCIIMask;
+template<> struct NonASCIIMask<4, char16> {
+    static inline uint32_t value() { return 0xFF80FF80U; }
+};
+template<> struct NonASCIIMask<4, char> {
+    static inline uint32_t value() { return 0x80808080U; }
+};
+template<> struct NonASCIIMask<8, char16> {
+    static inline uint64_t value() { return 0xFF80FF80FF80FF80ULL; }
+};
+template<> struct NonASCIIMask<8, char> {
+    static inline uint64_t value() { return 0x8080808080808080ULL; }
+};
+#if defined(WCHAR_T_IS_UTF32)
+template<> struct NonASCIIMask<4, wchar_t> {
+    static inline uint32_t value() { return 0xFFFFFF80U; }
+};
+template<> struct NonASCIIMask<8, wchar_t> {
+    static inline uint64_t value() { return 0xFFFFFF80FFFFFF80ULL; }
+};
+#endif  // WCHAR_T_IS_UTF32
+
+}  // namespace
+
+bool IsWprintfFormatPortable(const wchar_t* format) {
+  for (const wchar_t* position = format; *position != '\0'; ++position) {
+    if (*position == '%') {
+      bool in_specification = true;
+      bool modifier_l = false;
+      while (in_specification) {
+        // Eat up characters until reaching a known specifier.
+        if (*++position == '\0') {
+          // The format string ended in the middle of a specification.  Call
+          // it portable because no unportable specifications were found.  The
+          // string is equally broken on all platforms.
+          return true;
+        }
+
+        if (*position == 'l') {
+          // 'l' is the only thing that can save the 's' and 'c' specifiers.
+          modifier_l = true;
+        } else if (((*position == 's' || *position == 'c') && !modifier_l) ||
+                   *position == 'S' || *position == 'C' || *position == 'F' ||
+                   *position == 'D' || *position == 'O' || *position == 'U') {
+          // Not portable.
+          return false;
+        }
+
+        if (wcschr(L"diouxXeEfgGaAcspn%", *position)) {
+          // Portable, keep scanning the rest of the format string.
+          in_specification = false;
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+namespace {
+
+template<typename StringType>
+StringType ToLowerASCIIImpl(BasicStringPiece<StringType> str) {
+  StringType ret;
+  ret.reserve(str.size());
+  for (size_t i = 0; i < str.size(); i++)
+    ret.push_back(ToLowerASCII(str[i]));
+  return ret;
+}
+
+template<typename StringType>
+StringType ToUpperASCIIImpl(BasicStringPiece<StringType> str) {
+  StringType ret;
+  ret.reserve(str.size());
+  for (size_t i = 0; i < str.size(); i++)
+    ret.push_back(ToUpperASCII(str[i]));
+  return ret;
+}
+
+}  // namespace
+
+std::string ToLowerASCII(StringPiece str) {
+  return ToLowerASCIIImpl<std::string>(str);
+}
+
+string16 ToLowerASCII(StringPiece16 str) {
+  return ToLowerASCIIImpl<string16>(str);
+}
+
+std::string ToUpperASCII(StringPiece str) {
+  return ToUpperASCIIImpl<std::string>(str);
+}
+
+string16 ToUpperASCII(StringPiece16 str) {
+  return ToUpperASCIIImpl<string16>(str);
+}
+
+template<class StringType>
+int CompareCaseInsensitiveASCIIT(BasicStringPiece<StringType> a,
+                                 BasicStringPiece<StringType> b) {
+  // Find the first characters that aren't equal and compare them.  If the end
+  // of one of the strings is found before a nonequal character, the lengths
+  // of the strings are compared.
+  size_t i = 0;
+  while (i < a.length() && i < b.length()) {
+    typename StringType::value_type lower_a = ToLowerASCII(a[i]);
+    typename StringType::value_type lower_b = ToLowerASCII(b[i]);
+    if (lower_a < lower_b)
+      return -1;
+    if (lower_a > lower_b)
+      return 1;
+    i++;
+  }
+
+  // End of one string hit before finding a different character. Expect the
+  // common case to be "strings equal" at this point so check that first.
+  if (a.length() == b.length())
+    return 0;
+
+  if (a.length() < b.length())
+    return -1;
+  return 1;
+}
+
+int CompareCaseInsensitiveASCII(StringPiece a, StringPiece b) {
+  return CompareCaseInsensitiveASCIIT<std::string>(a, b);
+}
+
+int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
+  return CompareCaseInsensitiveASCIIT<string16>(a, b);
+}
+
+bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b) {
+  if (a.length() != b.length())
+    return false;
+  return CompareCaseInsensitiveASCIIT<std::string>(a, b) == 0;
+}
+
+bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
+  if (a.length() != b.length())
+    return false;
+  return CompareCaseInsensitiveASCIIT<string16>(a, b) == 0;
+}
+
+const std::string& EmptyString() {
+  return EmptyStrings::GetInstance()->s;
+}
+
+const string16& EmptyString16() {
+  return EmptyStrings::GetInstance()->s16;
+}
+
+template <class StringType>
+bool ReplaceCharsT(const StringType& input,
+                   BasicStringPiece<StringType> find_any_of_these,
+                   BasicStringPiece<StringType> replace_with,
+                   StringType* output);
+
+bool ReplaceChars(const string16& input,
+                  StringPiece16 replace_chars,
+                  const string16& replace_with,
+                  string16* output) {
+  return ReplaceCharsT(input, replace_chars, StringPiece16(replace_with),
+                       output);
+}
+
+bool ReplaceChars(const std::string& input,
+                  StringPiece replace_chars,
+                  const std::string& replace_with,
+                  std::string* output) {
+  return ReplaceCharsT(input, replace_chars, StringPiece(replace_with), output);
+}
+
+bool RemoveChars(const string16& input,
+                 StringPiece16 remove_chars,
+                 string16* output) {
+  return ReplaceCharsT(input, remove_chars, StringPiece16(), output);
+}
+
+bool RemoveChars(const std::string& input,
+                 StringPiece remove_chars,
+                 std::string* output) {
+  return ReplaceCharsT(input, remove_chars, StringPiece(), output);
+}
+
+template<typename Str>
+TrimPositions TrimStringT(const Str& input,
+                          BasicStringPiece<Str> trim_chars,
+                          TrimPositions positions,
+                          Str* output) {
+  // Find the edges of leading/trailing whitespace as desired. Need to use
+  // a StringPiece version of input to be able to call find* on it with the
+  // StringPiece version of trim_chars (normally the trim_chars will be a
+  // constant so avoid making a copy).
+  BasicStringPiece<Str> input_piece(input);
+  const size_t last_char = input.length() - 1;
+  const size_t first_good_char = (positions & TRIM_LEADING) ?
+      input_piece.find_first_not_of(trim_chars) : 0;
+  const size_t last_good_char = (positions & TRIM_TRAILING) ?
+      input_piece.find_last_not_of(trim_chars) : last_char;
+
+  // When the string was all trimmed, report that we stripped off characters
+  // from whichever position the caller was interested in. For empty input, we
+  // stripped no characters, but we still need to clear |output|.
+  if (input.empty() ||
+      (first_good_char == Str::npos) || (last_good_char == Str::npos)) {
+    bool input_was_empty = input.empty();  // in case output == &input
+    output->clear();
+    return input_was_empty ? TRIM_NONE : positions;
+  }
+
+  // Trim.
+  *output =
+      input.substr(first_good_char, last_good_char - first_good_char + 1);
+
+  // Return where we trimmed from.
+  return static_cast<TrimPositions>(
+      ((first_good_char == 0) ? TRIM_NONE : TRIM_LEADING) |
+      ((last_good_char == last_char) ? TRIM_NONE : TRIM_TRAILING));
+}
+
+bool TrimString(const string16& input,
+                StringPiece16 trim_chars,
+                string16* output) {
+  return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
+}
+
+bool TrimString(const std::string& input,
+                StringPiece trim_chars,
+                std::string* output) {
+  return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
+}
+
+template<typename Str>
+BasicStringPiece<Str> TrimStringPieceT(BasicStringPiece<Str> input,
+                                       BasicStringPiece<Str> trim_chars,
+                                       TrimPositions positions) {
+  size_t begin = (positions & TRIM_LEADING) ?
+      input.find_first_not_of(trim_chars) : 0;
+  size_t end = (positions & TRIM_TRAILING) ?
+      input.find_last_not_of(trim_chars) + 1 : input.size();
+  return input.substr(begin, end - begin);
+}
+
+StringPiece16 TrimString(StringPiece16 input,
+                         StringPiece16 trim_chars,
+                         TrimPositions positions) {
+  return TrimStringPieceT(input, trim_chars, positions);
+}
+
+StringPiece TrimString(StringPiece input,
+                       StringPiece trim_chars,
+                       TrimPositions positions) {
+  return TrimStringPieceT(input, trim_chars, positions);
+}
+
+void TruncateUTF8ToByteSize(const std::string& input,
+                            const size_t byte_size,
+                            std::string* output) {
+  DCHECK(output);
+  if (byte_size > input.length()) {
+    *output = input;
+    return;
+  }
+  DCHECK_LE(byte_size,
+            static_cast<uint32_t>(std::numeric_limits<int32_t>::max()));
+  // Note: This cast is necessary because CBU8_NEXT uses int32_ts.
+  int32_t truncation_length = static_cast<int32_t>(byte_size);
+  int32_t char_index = truncation_length - 1;
+  const char* data = input.data();
+
+  // Using CBU8, we will move backwards from the truncation point
+  // to the beginning of the string looking for a valid UTF8
+  // character.  Once a full UTF8 character is found, we will
+  // truncate the string to the end of that character.
+  while (char_index >= 0) {
+    int32_t prev = char_index;
+    base_icu::UChar32 code_point = 0;
+    CBU8_NEXT(data, char_index, truncation_length, code_point);
+    if (!IsValidCharacter(code_point) ||
+        !IsValidCodepoint(code_point)) {
+      char_index = prev - 1;
+    } else {
+      break;
+    }
+  }
+
+  if (char_index >= 0 )
+    *output = input.substr(0, char_index);
+  else
+    output->clear();
+}
+
+TrimPositions TrimWhitespace(const string16& input,
+                             TrimPositions positions,
+                             string16* output) {
+  return TrimStringT(input, StringPiece16(kWhitespaceUTF16), positions, output);
+}
+
+StringPiece16 TrimWhitespace(StringPiece16 input,
+                             TrimPositions positions) {
+  return TrimStringPieceT(input, StringPiece16(kWhitespaceUTF16), positions);
+}
+
+TrimPositions TrimWhitespaceASCII(const std::string& input,
+                                  TrimPositions positions,
+                                  std::string* output) {
+  return TrimStringT(input, StringPiece(kWhitespaceASCII), positions, output);
+}
+
+StringPiece TrimWhitespaceASCII(StringPiece input, TrimPositions positions) {
+  return TrimStringPieceT(input, StringPiece(kWhitespaceASCII), positions);
+}
+
+template<typename STR>
+STR CollapseWhitespaceT(const STR& text,
+                        bool trim_sequences_with_line_breaks) {
+  STR result;
+  result.resize(text.size());
+
+  // Set flags to pretend we're already in a trimmed whitespace sequence, so we
+  // will trim any leading whitespace.
+  bool in_whitespace = true;
+  bool already_trimmed = true;
+
+  int chars_written = 0;
+  for (typename STR::const_iterator i(text.begin()); i != text.end(); ++i) {
+    if (IsUnicodeWhitespace(*i)) {
+      if (!in_whitespace) {
+        // Reduce all whitespace sequences to a single space.
+        in_whitespace = true;
+        result[chars_written++] = L' ';
+      }
+      if (trim_sequences_with_line_breaks && !already_trimmed &&
+          ((*i == '\n') || (*i == '\r'))) {
+        // Whitespace sequences containing CR or LF are eliminated entirely.
+        already_trimmed = true;
+        --chars_written;
+      }
+    } else {
+      // Non-whitespace chracters are copied straight across.
+      in_whitespace = false;
+      already_trimmed = false;
+      result[chars_written++] = *i;
+    }
+  }
+
+  if (in_whitespace && !already_trimmed) {
+    // Any trailing whitespace is eliminated.
+    --chars_written;
+  }
+
+  result.resize(chars_written);
+  return result;
+}
+
+string16 CollapseWhitespace(const string16& text,
+                            bool trim_sequences_with_line_breaks) {
+  return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
+}
+
+std::string CollapseWhitespaceASCII(const std::string& text,
+                                    bool trim_sequences_with_line_breaks) {
+  return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
+}
+
+bool ContainsOnlyChars(StringPiece input, StringPiece characters) {
+  return input.find_first_not_of(characters) == StringPiece::npos;
+}
+
+bool ContainsOnlyChars(StringPiece16 input, StringPiece16 characters) {
+  return input.find_first_not_of(characters) == StringPiece16::npos;
+}
+
+template <class Char>
+inline bool DoIsStringASCII(const Char* characters, size_t length) {
+  MachineWord all_char_bits = 0;
+  const Char* end = characters + length;
+
+  // Prologue: align the input.
+  while (!IsAlignedToMachineWord(characters) && characters != end) {
+    all_char_bits |= *characters;
+    ++characters;
+  }
+
+  // Compare the values of CPU word size.
+  const Char* word_end = AlignToMachineWord(end);
+  const size_t loop_increment = sizeof(MachineWord) / sizeof(Char);
+  while (characters < word_end) {
+    all_char_bits |= *(reinterpret_cast<const MachineWord*>(characters));
+    characters += loop_increment;
+  }
+
+  // Process the remaining bytes.
+  while (characters != end) {
+    all_char_bits |= *characters;
+    ++characters;
+  }
+
+  MachineWord non_ascii_bit_mask =
+      NonASCIIMask<sizeof(MachineWord), Char>::value();
+  return !(all_char_bits & non_ascii_bit_mask);
+}
+
+bool IsStringASCII(StringPiece str) {
+  return DoIsStringASCII(str.data(), str.length());
+}
+
+bool IsStringASCII(StringPiece16 str) {
+  return DoIsStringASCII(str.data(), str.length());
+}
+
+#if defined(WCHAR_T_IS_UTF32)
+bool IsStringASCII(WStringPiece str) {
+  return DoIsStringASCII(str.data(), str.length());
+}
+#endif
+
+bool IsStringUTF8(StringPiece str) {
+  const char *src = str.data();
+  int32_t src_len = static_cast<int32_t>(str.length());
+  int32_t char_index = 0;
+
+  while (char_index < src_len) {
+    int32_t code_point;
+    CBU8_NEXT(src, char_index, src_len, code_point);
+    if (!IsValidCharacter(code_point))
+      return false;
+  }
+  return true;
+}
+
+// Implementation note: Normally this function will be called with a hardcoded
+// constant for the lowercase_ascii parameter. Constructing a StringPiece from
+// a C constant requires running strlen, so the result will be two passes
+// through the buffers, one to file the length of lowercase_ascii, and one to
+// compare each letter.
+//
+// This function could have taken a const char* to avoid this and only do one
+// pass through the string. But the strlen is faster than the case-insensitive
+// compares and lets us early-exit in the case that the strings are different
+// lengths (will often be the case for non-matches). So whether one approach or
+// the other will be faster depends on the case.
+//
+// The hardcoded strings are typically very short so it doesn't matter, and the
+// string piece gives additional flexibility for the caller (doesn't have to be
+// null terminated) so we choose the StringPiece route.
+template<typename Str>
+static inline bool DoLowerCaseEqualsASCII(BasicStringPiece<Str> str,
+                                          StringPiece lowercase_ascii) {
+  if (str.size() != lowercase_ascii.size())
+    return false;
+  for (size_t i = 0; i < str.size(); i++) {
+    if (ToLowerASCII(str[i]) != lowercase_ascii[i])
+      return false;
+  }
+  return true;
+}
+
+bool LowerCaseEqualsASCII(StringPiece str, StringPiece lowercase_ascii) {
+  return DoLowerCaseEqualsASCII<std::string>(str, lowercase_ascii);
+}
+
+bool LowerCaseEqualsASCII(StringPiece16 str, StringPiece lowercase_ascii) {
+  return DoLowerCaseEqualsASCII<string16>(str, lowercase_ascii);
+}
+
+bool EqualsASCII(StringPiece16 str, StringPiece ascii) {
+  if (str.length() != ascii.length())
+    return false;
+  return std::equal(ascii.begin(), ascii.end(), str.begin());
+}
+
+template<typename Str>
+bool StartsWithT(BasicStringPiece<Str> str,
+                 BasicStringPiece<Str> search_for,
+                 CompareCase case_sensitivity) {
+  if (search_for.size() > str.size())
+    return false;
+
+  BasicStringPiece<Str> source = str.substr(0, search_for.size());
+
+  switch (case_sensitivity) {
+    case CompareCase::SENSITIVE:
+      return source == search_for;
+
+    case CompareCase::INSENSITIVE_ASCII:
+      return std::equal(
+          search_for.begin(), search_for.end(),
+          source.begin(),
+          CaseInsensitiveCompareASCII<typename Str::value_type>());
+
+    default:
+      NOTREACHED();
+      return false;
+  }
+}
+
+bool StartsWith(StringPiece str,
+                StringPiece search_for,
+                CompareCase case_sensitivity) {
+  return StartsWithT<std::string>(str, search_for, case_sensitivity);
+}
+
+bool StartsWith(StringPiece16 str,
+                StringPiece16 search_for,
+                CompareCase case_sensitivity) {
+  return StartsWithT<string16>(str, search_for, case_sensitivity);
+}
+
+template <typename Str>
+bool EndsWithT(BasicStringPiece<Str> str,
+               BasicStringPiece<Str> search_for,
+               CompareCase case_sensitivity) {
+  if (search_for.size() > str.size())
+    return false;
+
+  BasicStringPiece<Str> source = str.substr(str.size() - search_for.size(),
+                                            search_for.size());
+
+  switch (case_sensitivity) {
+    case CompareCase::SENSITIVE:
+      return source == search_for;
+
+    case CompareCase::INSENSITIVE_ASCII:
+      return std::equal(
+          source.begin(), source.end(),
+          search_for.begin(),
+          CaseInsensitiveCompareASCII<typename Str::value_type>());
+
+    default:
+      NOTREACHED();
+      return false;
+  }
+}
+
+bool EndsWith(StringPiece str,
+              StringPiece search_for,
+              CompareCase case_sensitivity) {
+  return EndsWithT<std::string>(str, search_for, case_sensitivity);
+}
+
+bool EndsWith(StringPiece16 str,
+              StringPiece16 search_for,
+              CompareCase case_sensitivity) {
+  return EndsWithT<string16>(str, search_for, case_sensitivity);
+}
+
+char HexDigitToInt(wchar_t c) {
+  DCHECK(IsHexDigit(c));
+  if (c >= '0' && c <= '9')
+    return static_cast<char>(c - '0');
+  if (c >= 'A' && c <= 'F')
+    return static_cast<char>(c - 'A' + 10);
+  if (c >= 'a' && c <= 'f')
+    return static_cast<char>(c - 'a' + 10);
+  return 0;
+}
+
+bool IsUnicodeWhitespace(wchar_t c) {
+  // kWhitespaceWide is a NULL-terminated string
+  for (const wchar_t* cur = kWhitespaceWide; *cur; ++cur) {
+    if (*cur == c)
+      return true;
+  }
+  return false;
+}
+
+static const char* const kByteStringsUnlocalized[] = {
+  " B",
+  " kB",
+  " MB",
+  " GB",
+  " TB",
+  " PB"
+};
+
+string16 FormatBytesUnlocalized(int64_t bytes) {
+  double unit_amount = static_cast<double>(bytes);
+  size_t dimension = 0;
+  const int kKilo = 1024;
+  while (unit_amount >= kKilo &&
+         dimension < arraysize(kByteStringsUnlocalized) - 1) {
+    unit_amount /= kKilo;
+    dimension++;
+  }
+
+  char buf[64];
+  if (bytes != 0 && dimension > 0 && unit_amount < 100) {
+    base::snprintf(buf, arraysize(buf), "%.1lf%s", unit_amount,
+                   kByteStringsUnlocalized[dimension]);
+  } else {
+    base::snprintf(buf, arraysize(buf), "%.0lf%s", unit_amount,
+                   kByteStringsUnlocalized[dimension]);
+  }
+
+  return ASCIIToUTF16(buf);
+}
+
+// A Matcher for DoReplaceMatchesAfterOffset() that matches substrings.
+template <class StringType>
+struct SubstringMatcher {
+  BasicStringPiece<StringType> find_this;
+
+  size_t Find(const StringType& input, size_t pos) {
+    return input.find(find_this.data(), pos, find_this.length());
+  }
+  size_t MatchSize() { return find_this.length(); }
+};
+
+// A Matcher for DoReplaceMatchesAfterOffset() that matches single characters.
+template <class StringType>
+struct CharacterMatcher {
+  BasicStringPiece<StringType> find_any_of_these;
+
+  size_t Find(const StringType& input, size_t pos) {
+    return input.find_first_of(find_any_of_these.data(), pos,
+                               find_any_of_these.length());
+  }
+  constexpr size_t MatchSize() { return 1; }
+};
+
+enum class ReplaceType { REPLACE_ALL, REPLACE_FIRST };
+
+// Runs in O(n) time in the length of |str|, and transforms the string without
+// reallocating when possible. Returns |true| if any matches were found.
+//
+// This is parameterized on a |Matcher| traits type, so that it can be the
+// implementation for both ReplaceChars() and ReplaceSubstringsAfterOffset().
+template <class StringType, class Matcher>
+bool DoReplaceMatchesAfterOffset(StringType* str,
+                                 size_t initial_offset,
+                                 Matcher matcher,
+                                 BasicStringPiece<StringType> replace_with,
+                                 ReplaceType replace_type) {
+  using CharTraits = typename StringType::traits_type;
+
+  const size_t find_length = matcher.MatchSize();
+  if (!find_length)
+    return false;
+
+  // If the find string doesn't appear, there's nothing to do.
+  size_t first_match = matcher.Find(*str, initial_offset);
+  if (first_match == StringType::npos)
+    return false;
+
+  // If we're only replacing one instance, there's no need to do anything
+  // complicated.
+  const size_t replace_length = replace_with.length();
+  if (replace_type == ReplaceType::REPLACE_FIRST) {
+    str->replace(first_match, find_length, replace_with.data(), replace_length);
+    return true;
+  }
+
+  // If the find and replace strings are the same length, we can simply use
+  // replace() on each instance, and finish the entire operation in O(n) time.
+  if (find_length == replace_length) {
+    auto* buffer = &((*str)[0]);
+    for (size_t offset = first_match; offset != StringType::npos;
+         offset = matcher.Find(*str, offset + replace_length)) {
+      CharTraits::copy(buffer + offset, replace_with.data(), replace_length);
+    }
+    return true;
+  }
+
+  // Since the find and replace strings aren't the same length, a loop like the
+  // one above would be O(n^2) in the worst case, as replace() will shift the
+  // entire remaining string each time. We need to be more clever to keep things
+  // O(n).
+  //
+  // When the string is being shortened, it's possible to just shift the matches
+  // down in one pass while finding, and truncate the length at the end of the
+  // search.
+  //
+  // If the string is being lengthened, more work is required. The strategy used
+  // here is to make two find() passes through the string. The first pass counts
+  // the number of matches to determine the new size. The second pass will
+  // either construct the new string into a new buffer (if the existing buffer
+  // lacked capacity), or else -- if there is room -- create a region of scratch
+  // space after |first_match| by shifting the tail of the string to a higher
+  // index, and doing in-place moves from the tail to lower indices thereafter.
+  size_t str_length = str->length();
+  size_t expansion = 0;
+  if (replace_length > find_length) {
+    // This operation lengthens the string; determine the new length by counting
+    // matches.
+    const size_t expansion_per_match = (replace_length - find_length);
+    size_t num_matches = 0;
+    for (size_t match = first_match; match != StringType::npos;
+         match = matcher.Find(*str, match + find_length)) {
+      expansion += expansion_per_match;
+      ++num_matches;
+    }
+    const size_t final_length = str_length + expansion;
+
+    if (str->capacity() < final_length) {
+      // If we'd have to allocate a new buffer to grow the string, build the
+      // result directly into the new allocation via append().
+      StringType src(str->get_allocator());
+      str->swap(src);
+      str->reserve(final_length);
+
+      size_t pos = 0;
+      for (size_t match = first_match;; match = matcher.Find(src, pos)) {
+        str->append(src, pos, match - pos);
+        str->append(replace_with.data(), replace_length);
+        pos = match + find_length;
+
+        // A mid-loop test/break enables skipping the final Find() call; the
+        // number of matches is known, so don't search past the last one.
+        if (!--num_matches)
+          break;
+      }
+
+      // Handle substring after the final match.
+      str->append(src, pos, str_length - pos);
+      return true;
+    }
+
+    // Prepare for the copy/move loop below -- expand the string to its final
+    // size by shifting the data after the first match to the end of the resized
+    // string.
+    size_t shift_src = first_match + find_length;
+    size_t shift_dst = shift_src + expansion;
+
+    // Big |expansion| factors (relative to |str_length|) require padding up to
+    // |shift_dst|.
+    if (shift_dst > str_length)
+      str->resize(shift_dst);
+
+    str->replace(shift_dst, str_length - shift_src, *str, shift_src,
+                 str_length - shift_src);
+    str_length = final_length;
+  }
+
+  // We can alternate replacement and move operations. This won't overwrite the
+  // unsearched region of the string so long as |write_offset| <= |read_offset|;
+  // that condition is always satisfied because:
+  //
+  //   (a) If the string is being shortened, |expansion| is zero and
+  //       |write_offset| grows slower than |read_offset|.
+  //
+  //   (b) If the string is being lengthened, |write_offset| grows faster than
+  //       |read_offset|, but |expansion| is big enough so that |write_offset|
+  //       will only catch up to |read_offset| at the point of the last match.
+  auto* buffer = &((*str)[0]);
+  size_t write_offset = first_match;
+  size_t read_offset = first_match + expansion;
+  do {
+    if (replace_length) {
+      CharTraits::copy(buffer + write_offset, replace_with.data(),
+                       replace_length);
+      write_offset += replace_length;
+    }
+    read_offset += find_length;
+
+    // min() clamps StringType::npos (the largest unsigned value) to str_length.
+    size_t match = std::min(matcher.Find(*str, read_offset), str_length);
+
+    size_t length = match - read_offset;
+    if (length) {
+      CharTraits::move(buffer + write_offset, buffer + read_offset, length);
+      write_offset += length;
+      read_offset += length;
+    }
+  } while (read_offset < str_length);
+
+  // If we're shortening the string, truncate it now.
+  str->resize(write_offset);
+  return true;
+}
+
+template <class StringType>
+bool ReplaceCharsT(const StringType& input,
+                   BasicStringPiece<StringType> find_any_of_these,
+                   BasicStringPiece<StringType> replace_with,
+                   StringType* output) {
+  // Commonly, this is called with output and input being the same string; in
+  // that case, this assignment is inexpensive.
+  *output = input;
+
+  return DoReplaceMatchesAfterOffset(
+      output, 0, CharacterMatcher<StringType>{find_any_of_these}, replace_with,
+      ReplaceType::REPLACE_ALL);
+}
+
+void ReplaceFirstSubstringAfterOffset(string16* str,
+                                      size_t start_offset,
+                                      StringPiece16 find_this,
+                                      StringPiece16 replace_with) {
+  DoReplaceMatchesAfterOffset(str, start_offset,
+                              SubstringMatcher<string16>{find_this},
+                              replace_with, ReplaceType::REPLACE_FIRST);
+}
+
+void ReplaceFirstSubstringAfterOffset(std::string* str,
+                                      size_t start_offset,
+                                      StringPiece find_this,
+                                      StringPiece replace_with) {
+  DoReplaceMatchesAfterOffset(str, start_offset,
+                              SubstringMatcher<std::string>{find_this},
+                              replace_with, ReplaceType::REPLACE_FIRST);
+}
+
+void ReplaceSubstringsAfterOffset(string16* str,
+                                  size_t start_offset,
+                                  StringPiece16 find_this,
+                                  StringPiece16 replace_with) {
+  DoReplaceMatchesAfterOffset(str, start_offset,
+                              SubstringMatcher<string16>{find_this},
+                              replace_with, ReplaceType::REPLACE_ALL);
+}
+
+void ReplaceSubstringsAfterOffset(std::string* str,
+                                  size_t start_offset,
+                                  StringPiece find_this,
+                                  StringPiece replace_with) {
+  DoReplaceMatchesAfterOffset(str, start_offset,
+                              SubstringMatcher<std::string>{find_this},
+                              replace_with, ReplaceType::REPLACE_ALL);
+}
+
+template <class string_type>
+inline typename string_type::value_type* WriteIntoT(string_type* str,
+                                                    size_t length_with_null) {
+  DCHECK_GT(length_with_null, 1u);
+  str->reserve(length_with_null);
+  str->resize(length_with_null - 1);
+  return &((*str)[0]);
+}
+
+char* WriteInto(std::string* str, size_t length_with_null) {
+  return WriteIntoT(str, length_with_null);
+}
+
+char16* WriteInto(string16* str, size_t length_with_null) {
+  return WriteIntoT(str, length_with_null);
+}
+
+#if defined(_MSC_VER) && !defined(__clang__)
+// Work around VC++ code-gen bug. https://crbug.com/804884
+#pragma optimize("", off)
+#endif
+
+// Generic version for all JoinString overloads. |list_type| must be a sequence
+// (std::vector or std::initializer_list) of strings/StringPieces (std::string,
+// string16, StringPiece or StringPiece16). |string_type| is either std::string
+// or string16.
+template <typename list_type, typename string_type>
+static string_type JoinStringT(const list_type& parts,
+                               BasicStringPiece<string_type> sep) {
+  if (parts.size() == 0)
+    return string_type();
+
+  // Pre-allocate the eventual size of the string. Start with the size of all of
+  // the separators (note that this *assumes* parts.size() > 0).
+  size_t total_size = (parts.size() - 1) * sep.size();
+  for (const auto& part : parts)
+    total_size += part.size();
+  string_type result;
+  result.reserve(total_size);
+
+  auto iter = parts.begin();
+  DCHECK(iter != parts.end());
+  AppendToString(&result, *iter);
+  ++iter;
+
+  for (; iter != parts.end(); ++iter) {
+    sep.AppendToString(&result);
+    // Using the overloaded AppendToString allows this template function to work
+    // on both strings and StringPieces without creating an intermediate
+    // StringPiece object.
+    AppendToString(&result, *iter);
+  }
+
+  // Sanity-check that we pre-allocated correctly.
+  DCHECK_EQ(total_size, result.size());
+
+  return result;
+}
+
+std::string JoinString(const std::vector<std::string>& parts,
+                       StringPiece separator) {
+  return JoinStringT(parts, separator);
+}
+
+string16 JoinString(const std::vector<string16>& parts,
+                    StringPiece16 separator) {
+  return JoinStringT(parts, separator);
+}
+
+#if defined(_MSC_VER) && !defined(__clang__)
+// Work around VC++ code-gen bug. https://crbug.com/804884
+#pragma optimize("", on)
+#endif
+
+std::string JoinString(const std::vector<StringPiece>& parts,
+                       StringPiece separator) {
+  return JoinStringT(parts, separator);
+}
+
+string16 JoinString(const std::vector<StringPiece16>& parts,
+                    StringPiece16 separator) {
+  return JoinStringT(parts, separator);
+}
+
+std::string JoinString(std::initializer_list<StringPiece> parts,
+                       StringPiece separator) {
+  return JoinStringT(parts, separator);
+}
+
+string16 JoinString(std::initializer_list<StringPiece16> parts,
+                    StringPiece16 separator) {
+  return JoinStringT(parts, separator);
+}
+
+template<class FormatStringType, class OutStringType>
+OutStringType DoReplaceStringPlaceholders(
+    const FormatStringType& format_string,
+    const std::vector<OutStringType>& subst,
+    std::vector<size_t>* offsets) {
+  size_t substitutions = subst.size();
+  DCHECK_LT(substitutions, 10U);
+
+  size_t sub_length = 0;
+  for (const auto& cur : subst)
+    sub_length += cur.length();
+
+  OutStringType formatted;
+  formatted.reserve(format_string.length() + sub_length);
+
+  std::vector<ReplacementOffset> r_offsets;
+  for (auto i = format_string.begin(); i != format_string.end(); ++i) {
+    if ('$' == *i) {
+      if (i + 1 != format_string.end()) {
+        ++i;
+        if ('$' == *i) {
+          while (i != format_string.end() && '$' == *i) {
+            formatted.push_back('$');
+            ++i;
+          }
+          --i;
+        } else {
+          if (*i < '1' || *i > '9') {
+            DLOG(ERROR) << "Invalid placeholder: $" << *i;
+            continue;
+          }
+          uintptr_t index = *i - '1';
+          if (offsets) {
+            ReplacementOffset r_offset(index,
+                                       static_cast<int>(formatted.size()));
+            r_offsets.insert(
+                std::upper_bound(r_offsets.begin(), r_offsets.end(), r_offset,
+                                 &CompareParameter),
+                r_offset);
+          }
+          if (index < substitutions)
+            formatted.append(subst.at(index));
+        }
+      }
+    } else {
+      formatted.push_back(*i);
+    }
+  }
+  if (offsets) {
+    for (const auto& cur : r_offsets)
+      offsets->push_back(cur.offset);
+  }
+  return formatted;
+}
+
+string16 ReplaceStringPlaceholders(const string16& format_string,
+                                   const std::vector<string16>& subst,
+                                   std::vector<size_t>* offsets) {
+  return DoReplaceStringPlaceholders(format_string, subst, offsets);
+}
+
+std::string ReplaceStringPlaceholders(StringPiece format_string,
+                                      const std::vector<std::string>& subst,
+                                      std::vector<size_t>* offsets) {
+  return DoReplaceStringPlaceholders(format_string, subst, offsets);
+}
+
+string16 ReplaceStringPlaceholders(const string16& format_string,
+                                   const string16& a,
+                                   size_t* offset) {
+  std::vector<size_t> offsets;
+  std::vector<string16> subst;
+  subst.push_back(a);
+  string16 result = ReplaceStringPlaceholders(format_string, subst, &offsets);
+
+  DCHECK_EQ(1U, offsets.size());
+  if (offset)
+    *offset = offsets[0];
+  return result;
+}
+
+// The following code is compatible with the OpenBSD lcpy interface.  See:
+//   http://www.gratisoft.us/todd/papers/strlcpy.html
+//   ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/{wcs,str}lcpy.c
+
+namespace {
+
+template <typename CHAR>
+size_t lcpyT(CHAR* dst, const CHAR* src, size_t dst_size) {
+  for (size_t i = 0; i < dst_size; ++i) {
+    if ((dst[i] = src[i]) == 0)  // We hit and copied the terminating NULL.
+      return i;
+  }
+
+  // We were left off at dst_size.  We over copied 1 byte.  Null terminate.
+  if (dst_size != 0)
+    dst[dst_size - 1] = 0;
+
+  // Count the rest of the |src|, and return it's length in characters.
+  while (src[dst_size]) ++dst_size;
+  return dst_size;
+}
+
+}  // namespace
+
+size_t strlcpy(char* dst, const char* src, size_t dst_size) {
+  return lcpyT<char>(dst, src, dst_size);
+}
+size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
+  return lcpyT<wchar_t>(dst, src, dst_size);
+}
+
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_util.h b/native/zucchini/vendor/libchrome/base/strings/string_util.h
new file mode 100644
index 0000000..d6780ec
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/string_util.h
@@ -0,0 +1,485 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// This file defines utility functions for working with strings.
+
+#ifndef BASE_STRINGS_STRING_UTIL_H_
+#define BASE_STRINGS_STRING_UTIL_H_
+
+#include <ctype.h>
+#include <stdarg.h>   // va_list
+#include <stddef.h>
+#include <stdint.h>
+
+#include <initializer_list>
+#include <string>
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/compiler_specific.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_piece.h"  // For implicit conversions.
+#include "build/build_config.h"
+
+namespace base {
+
+// C standard-library functions that aren't cross-platform are provided as
+// "base::...", and their prototypes are listed below. These functions are
+// then implemented as inline calls to the platform-specific equivalents in the
+// platform-specific headers.
+
+// Wrapper for vsnprintf that always null-terminates and always returns the
+// number of characters that would be in an untruncated formatted
+// string, even when truncation occurs.
+int vsnprintf(char* buffer, size_t size, const char* format, va_list arguments)
+    PRINTF_FORMAT(3, 0);
+
+// Some of these implementations need to be inlined.
+
+// We separate the declaration from the implementation of this inline
+// function just so the PRINTF_FORMAT works.
+inline int snprintf(char* buffer,
+                    size_t size,
+                    _Printf_format_string_ const char* format,
+                    ...) PRINTF_FORMAT(3, 4);
+inline int snprintf(char* buffer,
+                    size_t size,
+                    _Printf_format_string_ const char* format,
+                    ...) {
+  va_list arguments;
+  va_start(arguments, format);
+  int result = vsnprintf(buffer, size, format, arguments);
+  va_end(arguments);
+  return result;
+}
+
+// BSD-style safe and consistent string copy functions.
+// Copies |src| to |dst|, where |dst_size| is the total allocated size of |dst|.
+// Copies at most |dst_size|-1 characters, and always NULL terminates |dst|, as
+// long as |dst_size| is not 0.  Returns the length of |src| in characters.
+// If the return value is >= dst_size, then the output was truncated.
+// NOTE: All sizes are in number of characters, NOT in bytes.
+BASE_EXPORT size_t strlcpy(char* dst, const char* src, size_t dst_size);
+BASE_EXPORT size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size);
+
+// Scan a wprintf format string to determine whether it's portable across a
+// variety of systems.  This function only checks that the conversion
+// specifiers used by the format string are supported and have the same meaning
+// on a variety of systems.  It doesn't check for other errors that might occur
+// within a format string.
+//
+// Nonportable conversion specifiers for wprintf are:
+//  - 's' and 'c' without an 'l' length modifier.  %s and %c operate on char
+//     data on all systems except Windows, which treat them as wchar_t data.
+//     Use %ls and %lc for wchar_t data instead.
+//  - 'S' and 'C', which operate on wchar_t data on all systems except Windows,
+//     which treat them as char data.  Use %ls and %lc for wchar_t data
+//     instead.
+//  - 'F', which is not identified by Windows wprintf documentation.
+//  - 'D', 'O', and 'U', which are deprecated and not available on all systems.
+//     Use %ld, %lo, and %lu instead.
+//
+// Note that there is no portable conversion specifier for char data when
+// working with wprintf.
+//
+// This function is intended to be called from base::vswprintf.
+BASE_EXPORT bool IsWprintfFormatPortable(const wchar_t* format);
+
+// ASCII-specific tolower.  The standard library's tolower is locale sensitive,
+// so we don't want to use it here.
+inline char ToLowerASCII(char c) {
+  return (c >= 'A' && c <= 'Z') ? (c + ('a' - 'A')) : c;
+}
+inline char16 ToLowerASCII(char16 c) {
+  return (c >= 'A' && c <= 'Z') ? (c + ('a' - 'A')) : c;
+}
+
+// ASCII-specific toupper.  The standard library's toupper is locale sensitive,
+// so we don't want to use it here.
+inline char ToUpperASCII(char c) {
+  return (c >= 'a' && c <= 'z') ? (c + ('A' - 'a')) : c;
+}
+inline char16 ToUpperASCII(char16 c) {
+  return (c >= 'a' && c <= 'z') ? (c + ('A' - 'a')) : c;
+}
+
+// Converts the given string to it's ASCII-lowercase equivalent.
+BASE_EXPORT std::string ToLowerASCII(StringPiece str);
+BASE_EXPORT string16 ToLowerASCII(StringPiece16 str);
+
+// Converts the given string to it's ASCII-uppercase equivalent.
+BASE_EXPORT std::string ToUpperASCII(StringPiece str);
+BASE_EXPORT string16 ToUpperASCII(StringPiece16 str);
+
+// Functor for case-insensitive ASCII comparisons for STL algorithms like
+// std::search.
+//
+// Note that a full Unicode version of this functor is not possible to write
+// because case mappings might change the number of characters, depend on
+// context (combining accents), and require handling UTF-16. If you need
+// proper Unicode support, use base::i18n::ToLower/FoldCase and then just
+// use a normal operator== on the result.
+template<typename Char> struct CaseInsensitiveCompareASCII {
+ public:
+  bool operator()(Char x, Char y) const {
+    return ToLowerASCII(x) == ToLowerASCII(y);
+  }
+};
+
+// Like strcasecmp for case-insensitive ASCII characters only. Returns:
+//   -1  (a < b)
+//    0  (a == b)
+//    1  (a > b)
+// (unlike strcasecmp which can return values greater or less than 1/-1). For
+// full Unicode support, use base::i18n::ToLower or base::i18h::FoldCase
+// and then just call the normal string operators on the result.
+BASE_EXPORT int CompareCaseInsensitiveASCII(StringPiece a, StringPiece b);
+BASE_EXPORT int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);
+
+// Equality for ASCII case-insensitive comparisons. For full Unicode support,
+// use base::i18n::ToLower or base::i18h::FoldCase and then compare with either
+// == or !=.
+BASE_EXPORT bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b);
+BASE_EXPORT bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);
+
+// These threadsafe functions return references to globally unique empty
+// strings.
+//
+// It is likely faster to construct a new empty string object (just a few
+// instructions to set the length to 0) than to get the empty string singleton
+// returned by these functions (which requires threadsafe singleton access).
+//
+// Therefore, DO NOT USE THESE AS A GENERAL-PURPOSE SUBSTITUTE FOR DEFAULT
+// CONSTRUCTORS. There is only one case where you should use these: functions
+// which need to return a string by reference (e.g. as a class member
+// accessor), and don't have an empty string to use (e.g. in an error case).
+// These should not be used as initializers, function arguments, or return
+// values for functions which return by value or outparam.
+BASE_EXPORT const std::string& EmptyString();
+BASE_EXPORT const string16& EmptyString16();
+
+// Contains the set of characters representing whitespace in the corresponding
+// encoding. Null-terminated. The ASCII versions are the whitespaces as defined
+// by HTML5, and don't include control characters.
+BASE_EXPORT extern const wchar_t kWhitespaceWide[];  // Includes Unicode.
+BASE_EXPORT extern const char16 kWhitespaceUTF16[];  // Includes Unicode.
+BASE_EXPORT extern const char kWhitespaceASCII[];
+BASE_EXPORT extern const char16 kWhitespaceASCIIAs16[];  // No unicode.
+
+// Null-terminated string representing the UTF-8 byte order mark.
+BASE_EXPORT extern const char kUtf8ByteOrderMark[];
+
+// Removes characters in |remove_chars| from anywhere in |input|.  Returns true
+// if any characters were removed.  |remove_chars| must be null-terminated.
+// NOTE: Safe to use the same variable for both |input| and |output|.
+BASE_EXPORT bool RemoveChars(const string16& input,
+                             StringPiece16 remove_chars,
+                             string16* output);
+BASE_EXPORT bool RemoveChars(const std::string& input,
+                             StringPiece remove_chars,
+                             std::string* output);
+
+// Replaces characters in |replace_chars| from anywhere in |input| with
+// |replace_with|.  Each character in |replace_chars| will be replaced with
+// the |replace_with| string.  Returns true if any characters were replaced.
+// |replace_chars| must be null-terminated.
+// NOTE: Safe to use the same variable for both |input| and |output|.
+BASE_EXPORT bool ReplaceChars(const string16& input,
+                              StringPiece16 replace_chars,
+                              const string16& replace_with,
+                              string16* output);
+BASE_EXPORT bool ReplaceChars(const std::string& input,
+                              StringPiece replace_chars,
+                              const std::string& replace_with,
+                              std::string* output);
+
+enum TrimPositions {
+  TRIM_NONE     = 0,
+  TRIM_LEADING  = 1 << 0,
+  TRIM_TRAILING = 1 << 1,
+  TRIM_ALL      = TRIM_LEADING | TRIM_TRAILING,
+};
+
+// Removes characters in |trim_chars| from the beginning and end of |input|.
+// The 8-bit version only works on 8-bit characters, not UTF-8. Returns true if
+// any characters were removed.
+//
+// It is safe to use the same variable for both |input| and |output| (this is
+// the normal usage to trim in-place).
+BASE_EXPORT bool TrimString(const string16& input,
+                            StringPiece16 trim_chars,
+                            string16* output);
+BASE_EXPORT bool TrimString(const std::string& input,
+                            StringPiece trim_chars,
+                            std::string* output);
+
+// StringPiece versions of the above. The returned pieces refer to the original
+// buffer.
+BASE_EXPORT StringPiece16 TrimString(StringPiece16 input,
+                                     StringPiece16 trim_chars,
+                                     TrimPositions positions);
+BASE_EXPORT StringPiece TrimString(StringPiece input,
+                                   StringPiece trim_chars,
+                                   TrimPositions positions);
+
+// Truncates a string to the nearest UTF-8 character that will leave
+// the string less than or equal to the specified byte size.
+BASE_EXPORT void TruncateUTF8ToByteSize(const std::string& input,
+                                        const size_t byte_size,
+                                        std::string* output);
+
+// Trims any whitespace from either end of the input string.
+//
+// The StringPiece versions return a substring referencing the input buffer.
+// The ASCII versions look only for ASCII whitespace.
+//
+// The std::string versions return where whitespace was found.
+// NOTE: Safe to use the same variable for both input and output.
+BASE_EXPORT TrimPositions TrimWhitespace(const string16& input,
+                                         TrimPositions positions,
+                                         string16* output);
+BASE_EXPORT StringPiece16 TrimWhitespace(StringPiece16 input,
+                                         TrimPositions positions);
+BASE_EXPORT TrimPositions TrimWhitespaceASCII(const std::string& input,
+                                              TrimPositions positions,
+                                              std::string* output);
+BASE_EXPORT StringPiece TrimWhitespaceASCII(StringPiece input,
+                                            TrimPositions positions);
+
+// Searches for CR or LF characters.  Removes all contiguous whitespace
+// strings that contain them.  This is useful when trying to deal with text
+// copied from terminals.
+// Returns |text|, with the following three transformations:
+// (1) Leading and trailing whitespace is trimmed.
+// (2) If |trim_sequences_with_line_breaks| is true, any other whitespace
+//     sequences containing a CR or LF are trimmed.
+// (3) All other whitespace sequences are converted to single spaces.
+BASE_EXPORT string16 CollapseWhitespace(
+    const string16& text,
+    bool trim_sequences_with_line_breaks);
+BASE_EXPORT std::string CollapseWhitespaceASCII(
+    const std::string& text,
+    bool trim_sequences_with_line_breaks);
+
+// Returns true if |input| is empty or contains only characters found in
+// |characters|.
+BASE_EXPORT bool ContainsOnlyChars(StringPiece input, StringPiece characters);
+BASE_EXPORT bool ContainsOnlyChars(StringPiece16 input,
+                                   StringPiece16 characters);
+
+// Returns true if the specified string matches the criteria. How can a wide
+// string be 8-bit or UTF8? It contains only characters that are < 256 (in the
+// first case) or characters that use only 8-bits and whose 8-bit
+// representation looks like a UTF-8 string (the second case).
+//
+// Note that IsStringUTF8 checks not only if the input is structurally
+// valid but also if it doesn't contain any non-character codepoint
+// (e.g. U+FFFE). It's done on purpose because all the existing callers want
+// to have the maximum 'discriminating' power from other encodings. If
+// there's a use case for just checking the structural validity, we have to
+// add a new function for that.
+//
+// IsStringASCII assumes the input is likely all ASCII, and does not leave early
+// if it is not the case.
+BASE_EXPORT bool IsStringUTF8(StringPiece str);
+BASE_EXPORT bool IsStringASCII(StringPiece str);
+BASE_EXPORT bool IsStringASCII(StringPiece16 str);
+#if defined(WCHAR_T_IS_UTF32)
+BASE_EXPORT bool IsStringASCII(WStringPiece str);
+#endif
+
+// Compare the lower-case form of the given string against the given
+// previously-lower-cased ASCII string (typically a constant).
+BASE_EXPORT bool LowerCaseEqualsASCII(StringPiece str,
+                                      StringPiece lowecase_ascii);
+BASE_EXPORT bool LowerCaseEqualsASCII(StringPiece16 str,
+                                      StringPiece lowecase_ascii);
+
+// Performs a case-sensitive string compare of the given 16-bit string against
+// the given 8-bit ASCII string (typically a constant). The behavior is
+// undefined if the |ascii| string is not ASCII.
+BASE_EXPORT bool EqualsASCII(StringPiece16 str, StringPiece ascii);
+
+// Indicates case sensitivity of comparisons. Only ASCII case insensitivity
+// is supported. Full Unicode case-insensitive conversions would need to go in
+// base/i18n so it can use ICU.
+//
+// If you need to do Unicode-aware case-insensitive StartsWith/EndsWith, it's
+// best to call base::i18n::ToLower() or base::i18n::FoldCase() (see
+// base/i18n/case_conversion.h for usage advice) on the arguments, and then use
+// the results to a case-sensitive comparison.
+enum class CompareCase {
+  SENSITIVE,
+  INSENSITIVE_ASCII,
+};
+
+BASE_EXPORT bool StartsWith(StringPiece str,
+                            StringPiece search_for,
+                            CompareCase case_sensitivity);
+BASE_EXPORT bool StartsWith(StringPiece16 str,
+                            StringPiece16 search_for,
+                            CompareCase case_sensitivity);
+BASE_EXPORT bool EndsWith(StringPiece str,
+                          StringPiece search_for,
+                          CompareCase case_sensitivity);
+BASE_EXPORT bool EndsWith(StringPiece16 str,
+                          StringPiece16 search_for,
+                          CompareCase case_sensitivity);
+
+// Determines the type of ASCII character, independent of locale (the C
+// library versions will change based on locale).
+template <typename Char>
+inline bool IsAsciiWhitespace(Char c) {
+  return c == ' ' || c == '\r' || c == '\n' || c == '\t';
+}
+template <typename Char>
+inline bool IsAsciiAlpha(Char c) {
+  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
+}
+template <typename Char>
+inline bool IsAsciiUpper(Char c) {
+  return c >= 'A' && c <= 'Z';
+}
+template <typename Char>
+inline bool IsAsciiLower(Char c) {
+  return c >= 'a' && c <= 'z';
+}
+template <typename Char>
+inline bool IsAsciiDigit(Char c) {
+  return c >= '0' && c <= '9';
+}
+
+template <typename Char>
+inline bool IsHexDigit(Char c) {
+  return (c >= '0' && c <= '9') ||
+         (c >= 'A' && c <= 'F') ||
+         (c >= 'a' && c <= 'f');
+}
+
+// Returns the integer corresponding to the given hex character. For example:
+//    '4' -> 4
+//    'a' -> 10
+//    'B' -> 11
+// Assumes the input is a valid hex character. DCHECKs in debug builds if not.
+BASE_EXPORT char HexDigitToInt(wchar_t c);
+
+// Returns true if it's a Unicode whitespace character.
+BASE_EXPORT bool IsUnicodeWhitespace(wchar_t c);
+
+// Return a byte string in human-readable format with a unit suffix. Not
+// appropriate for use in any UI; use of FormatBytes and friends in ui/base is
+// highly recommended instead. TODO(avi): Figure out how to get callers to use
+// FormatBytes instead; remove this.
+BASE_EXPORT string16 FormatBytesUnlocalized(int64_t bytes);
+
+// Starting at |start_offset| (usually 0), replace the first instance of
+// |find_this| with |replace_with|.
+BASE_EXPORT void ReplaceFirstSubstringAfterOffset(
+    base::string16* str,
+    size_t start_offset,
+    StringPiece16 find_this,
+    StringPiece16 replace_with);
+BASE_EXPORT void ReplaceFirstSubstringAfterOffset(
+    std::string* str,
+    size_t start_offset,
+    StringPiece find_this,
+    StringPiece replace_with);
+
+// Starting at |start_offset| (usually 0), look through |str| and replace all
+// instances of |find_this| with |replace_with|.
+//
+// This does entire substrings; use std::replace in <algorithm> for single
+// characters, for example:
+//   std::replace(str.begin(), str.end(), 'a', 'b');
+BASE_EXPORT void ReplaceSubstringsAfterOffset(
+    string16* str,
+    size_t start_offset,
+    StringPiece16 find_this,
+    StringPiece16 replace_with);
+BASE_EXPORT void ReplaceSubstringsAfterOffset(
+    std::string* str,
+    size_t start_offset,
+    StringPiece find_this,
+    StringPiece replace_with);
+
+// Reserves enough memory in |str| to accommodate |length_with_null| characters,
+// sets the size of |str| to |length_with_null - 1| characters, and returns a
+// pointer to the underlying contiguous array of characters.  This is typically
+// used when calling a function that writes results into a character array, but
+// the caller wants the data to be managed by a string-like object.  It is
+// convenient in that is can be used inline in the call, and fast in that it
+// avoids copying the results of the call from a char* into a string.
+//
+// |length_with_null| must be at least 2, since otherwise the underlying string
+// would have size 0, and trying to access &((*str)[0]) in that case can result
+// in a number of problems.
+//
+// Internally, this takes linear time because the resize() call 0-fills the
+// underlying array for potentially all
+// (|length_with_null - 1| * sizeof(string_type::value_type)) bytes.  Ideally we
+// could avoid this aspect of the resize() call, as we expect the caller to
+// immediately write over this memory, but there is no other way to set the size
+// of the string, and not doing that will mean people who access |str| rather
+// than str.c_str() will get back a string of whatever size |str| had on entry
+// to this function (probably 0).
+BASE_EXPORT char* WriteInto(std::string* str, size_t length_with_null);
+BASE_EXPORT char16* WriteInto(string16* str, size_t length_with_null);
+
+// Does the opposite of SplitString()/SplitStringPiece(). Joins a vector or list
+// of strings into a single string, inserting |separator| (which may be empty)
+// in between all elements.
+//
+// If possible, callers should build a vector of StringPieces and use the
+// StringPiece variant, so that they do not create unnecessary copies of
+// strings. For example, instead of using SplitString, modifying the vector,
+// then using JoinString, use SplitStringPiece followed by JoinString so that no
+// copies of those strings are created until the final join operation.
+//
+// Use StrCat (in base/strings/strcat.h) if you don't need a separator.
+BASE_EXPORT std::string JoinString(const std::vector<std::string>& parts,
+                                   StringPiece separator);
+BASE_EXPORT string16 JoinString(const std::vector<string16>& parts,
+                                StringPiece16 separator);
+BASE_EXPORT std::string JoinString(const std::vector<StringPiece>& parts,
+                                   StringPiece separator);
+BASE_EXPORT string16 JoinString(const std::vector<StringPiece16>& parts,
+                                StringPiece16 separator);
+// Explicit initializer_list overloads are required to break ambiguity when used
+// with a literal initializer list (otherwise the compiler would not be able to
+// decide between the string and StringPiece overloads).
+BASE_EXPORT std::string JoinString(std::initializer_list<StringPiece> parts,
+                                   StringPiece separator);
+BASE_EXPORT string16 JoinString(std::initializer_list<StringPiece16> parts,
+                                StringPiece16 separator);
+
+// Replace $1-$2-$3..$9 in the format string with values from |subst|.
+// Additionally, any number of consecutive '$' characters is replaced by that
+// number less one. Eg $$->$, $$$->$$, etc. The offsets parameter here can be
+// NULL. This only allows you to use up to nine replacements.
+BASE_EXPORT string16 ReplaceStringPlaceholders(
+    const string16& format_string,
+    const std::vector<string16>& subst,
+    std::vector<size_t>* offsets);
+
+BASE_EXPORT std::string ReplaceStringPlaceholders(
+    StringPiece format_string,
+    const std::vector<std::string>& subst,
+    std::vector<size_t>* offsets);
+
+// Single-string shortcut for ReplaceStringHolders. |offset| may be NULL.
+BASE_EXPORT string16 ReplaceStringPlaceholders(const string16& format_string,
+                                               const string16& a,
+                                               size_t* offset);
+
+}  // namespace base
+
+#if defined(OS_WIN)
+#include "base/strings/string_util_win.h"
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+#include "base/strings/string_util_posix.h"
+#else
+#error Define string operations appropriately for your platform
+#endif
+
+#endif  // BASE_STRINGS_STRING_UTIL_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_util_posix.h b/native/zucchini/vendor/libchrome/base/strings/string_util_posix.h
new file mode 100644
index 0000000..8299118
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/string_util_posix.h
@@ -0,0 +1,37 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_STRINGS_STRING_UTIL_POSIX_H_
+#define BASE_STRINGS_STRING_UTIL_POSIX_H_
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include <wchar.h>
+
+#include "base/logging.h"
+
+namespace base {
+
+// Chromium code style is to not use malloc'd strings; this is only for use
+// for interaction with APIs that require it.
+inline char* strdup(const char* str) {
+  return ::strdup(str);
+}
+
+inline int vsnprintf(char* buffer, size_t size,
+                     const char* format, va_list arguments) {
+  return ::vsnprintf(buffer, size, format, arguments);
+}
+
+inline int vswprintf(wchar_t* buffer, size_t size,
+                     const wchar_t* format, va_list arguments) {
+  DCHECK(IsWprintfFormatPortable(format));
+  return ::vswprintf(buffer, size, format, arguments);
+}
+
+}  // namespace base
+
+#endif  // BASE_STRINGS_STRING_UTIL_POSIX_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/stringprintf.cc b/native/zucchini/vendor/libchrome/base/strings/stringprintf.cc
new file mode 100644
index 0000000..415845d
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/stringprintf.cc
@@ -0,0 +1,189 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/strings/stringprintf.h"
+
+#include <errno.h>
+#include <stddef.h>
+
+#include <vector>
+
+#include "base/macros.h"
+#include "base/scoped_clear_errno.h"
+#include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
+#include "build/build_config.h"
+
+namespace base {
+
+namespace {
+
+// Overloaded wrappers around vsnprintf and vswprintf. The buf_size parameter
+// is the size of the buffer. These return the number of characters in the
+// formatted string excluding the NUL terminator. If the buffer is not
+// large enough to accommodate the formatted string without truncation, they
+// return the number of characters that would be in the fully-formatted string
+// (vsnprintf, and vswprintf on Windows), or -1 (vswprintf on POSIX platforms).
+inline int vsnprintfT(char* buffer,
+                      size_t buf_size,
+                      const char* format,
+                      va_list argptr) {
+  return base::vsnprintf(buffer, buf_size, format, argptr);
+}
+
+#if defined(OS_WIN)
+inline int vsnprintfT(wchar_t* buffer,
+                      size_t buf_size,
+                      const wchar_t* format,
+                      va_list argptr) {
+  return base::vswprintf(buffer, buf_size, format, argptr);
+}
+#endif
+
+// Templatized backend for StringPrintF/StringAppendF. This does not finalize
+// the va_list, the caller is expected to do that.
+template <class StringType>
+static void StringAppendVT(StringType* dst,
+                           const typename StringType::value_type* format,
+                           va_list ap) {
+  // First try with a small fixed size buffer.
+  // This buffer size should be kept in sync with StringUtilTest.GrowBoundary
+  // and StringUtilTest.StringPrintfBounds.
+  typename StringType::value_type stack_buf[1024];
+
+  va_list ap_copy;
+  va_copy(ap_copy, ap);
+
+#if !defined(OS_WIN)
+  ScopedClearErrno clear_errno;
+#endif
+  int result = vsnprintfT(stack_buf, arraysize(stack_buf), format, ap_copy);
+  va_end(ap_copy);
+
+  if (result >= 0 && result < static_cast<int>(arraysize(stack_buf))) {
+    // It fit.
+    dst->append(stack_buf, result);
+    return;
+  }
+
+  // Repeatedly increase buffer size until it fits.
+  int mem_length = arraysize(stack_buf);
+  while (true) {
+    if (result < 0) {
+#if defined(OS_WIN)
+      // On Windows, vsnprintfT always returns the number of characters in a
+      // fully-formatted string, so if we reach this point, something else is
+      // wrong and no amount of buffer-doubling is going to fix it.
+      return;
+#else
+      if (errno != 0 && errno != EOVERFLOW)
+        return;
+      // Try doubling the buffer size.
+      mem_length *= 2;
+#endif
+    } else {
+      // We need exactly "result + 1" characters.
+      mem_length = result + 1;
+    }
+
+    if (mem_length > 32 * 1024 * 1024) {
+      // That should be plenty, don't try anything larger.  This protects
+      // against huge allocations when using vsnprintfT implementations that
+      // return -1 for reasons other than overflow without setting errno.
+      DLOG(WARNING) << "Unable to printf the requested string due to size.";
+      return;
+    }
+
+    std::vector<typename StringType::value_type> mem_buf(mem_length);
+
+    // NOTE: You can only use a va_list once.  Since we're in a while loop, we
+    // need to make a new copy each time so we don't use up the original.
+    va_copy(ap_copy, ap);
+    result = vsnprintfT(&mem_buf[0], mem_length, format, ap_copy);
+    va_end(ap_copy);
+
+    if ((result >= 0) && (result < mem_length)) {
+      // It fit.
+      dst->append(&mem_buf[0], result);
+      return;
+    }
+  }
+}
+
+}  // namespace
+
+std::string StringPrintf(const char* format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  std::string result;
+  StringAppendV(&result, format, ap);
+  va_end(ap);
+  return result;
+}
+
+#if defined(OS_WIN)
+std::wstring StringPrintf(const wchar_t* format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  std::wstring result;
+  StringAppendV(&result, format, ap);
+  va_end(ap);
+  return result;
+}
+#endif
+
+std::string StringPrintV(const char* format, va_list ap) {
+  std::string result;
+  StringAppendV(&result, format, ap);
+  return result;
+}
+
+const std::string& SStringPrintf(std::string* dst, const char* format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  dst->clear();
+  StringAppendV(dst, format, ap);
+  va_end(ap);
+  return *dst;
+}
+
+#if defined(OS_WIN)
+const std::wstring& SStringPrintf(std::wstring* dst,
+                                  const wchar_t* format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  dst->clear();
+  StringAppendV(dst, format, ap);
+  va_end(ap);
+  return *dst;
+}
+#endif
+
+void StringAppendF(std::string* dst, const char* format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  StringAppendV(dst, format, ap);
+  va_end(ap);
+}
+
+#if defined(OS_WIN)
+void StringAppendF(std::wstring* dst, const wchar_t* format, ...) {
+  va_list ap;
+  va_start(ap, format);
+  StringAppendV(dst, format, ap);
+  va_end(ap);
+}
+#endif
+
+void StringAppendV(std::string* dst, const char* format, va_list ap) {
+  StringAppendVT(dst, format, ap);
+}
+
+#if defined(OS_WIN)
+void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap) {
+  StringAppendVT(dst, format, ap);
+}
+#endif
+
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/strings/stringprintf.h b/native/zucchini/vendor/libchrome/base/strings/stringprintf.h
new file mode 100644
index 0000000..7a75d89
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/stringprintf.h
@@ -0,0 +1,66 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_STRINGS_STRINGPRINTF_H_
+#define BASE_STRINGS_STRINGPRINTF_H_
+
+#include <stdarg.h>   // va_list
+
+#include <string>
+
+#include "base/base_export.h"
+#include "base/compiler_specific.h"
+#include "build/build_config.h"
+
+namespace base {
+
+// Return a C++ string given printf-like input.
+BASE_EXPORT std::string StringPrintf(_Printf_format_string_ const char* format,
+                                     ...)
+    PRINTF_FORMAT(1, 2) WARN_UNUSED_RESULT;
+#if defined(OS_WIN)
+BASE_EXPORT std::wstring StringPrintf(
+    _Printf_format_string_ const wchar_t* format,
+    ...) WPRINTF_FORMAT(1, 2) WARN_UNUSED_RESULT;
+#endif
+
+// Return a C++ string given vprintf-like input.
+BASE_EXPORT std::string StringPrintV(const char* format, va_list ap)
+    PRINTF_FORMAT(1, 0) WARN_UNUSED_RESULT;
+
+// Store result into a supplied string and return it.
+BASE_EXPORT const std::string& SStringPrintf(
+    std::string* dst,
+    _Printf_format_string_ const char* format,
+    ...) PRINTF_FORMAT(2, 3);
+#if defined(OS_WIN)
+BASE_EXPORT const std::wstring& SStringPrintf(
+    std::wstring* dst,
+    _Printf_format_string_ const wchar_t* format,
+    ...) WPRINTF_FORMAT(2, 3);
+#endif
+
+// Append result to a supplied string.
+BASE_EXPORT void StringAppendF(std::string* dst,
+                               _Printf_format_string_ const char* format,
+                               ...) PRINTF_FORMAT(2, 3);
+#if defined(OS_WIN)
+BASE_EXPORT void StringAppendF(std::wstring* dst,
+                               _Printf_format_string_ const wchar_t* format,
+                               ...) WPRINTF_FORMAT(2, 3);
+#endif
+
+// Lower-level routine that takes a va_list and appends to a specified
+// string.  All other routines are just convenience wrappers around it.
+BASE_EXPORT void StringAppendV(std::string* dst, const char* format, va_list ap)
+    PRINTF_FORMAT(2, 0);
+#if defined(OS_WIN)
+BASE_EXPORT void StringAppendV(std::wstring* dst,
+                               const wchar_t* format, va_list ap)
+    WPRINTF_FORMAT(2, 0);
+#endif
+
+}  // namespace base
+
+#endif  // BASE_STRINGS_STRINGPRINTF_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/sys_string_conversions.h b/native/zucchini/vendor/libchrome/base/strings/sys_string_conversions.h
new file mode 100644
index 0000000..1ad0307
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/sys_string_conversions.h
@@ -0,0 +1,84 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_STRINGS_SYS_STRING_CONVERSIONS_H_
+#define BASE_STRINGS_SYS_STRING_CONVERSIONS_H_
+
+// Provides system-dependent string type conversions for cases where it's
+// necessary to not use ICU. Generally, you should not need this in Chrome,
+// but it is used in some shared code. Dependencies should be minimal.
+
+#include <stdint.h>
+
+#include <string>
+
+#include "base/base_export.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_piece.h"
+#include "build/build_config.h"
+
+#if defined(OS_MACOSX)
+#include <CoreFoundation/CoreFoundation.h>
+#ifdef __OBJC__
+@class NSString;
+#else
+class NSString;
+#endif
+#endif  // OS_MACOSX
+
+namespace base {
+
+// Converts between wide and UTF-8 representations of a string. On error, the
+// result is system-dependent.
+BASE_EXPORT std::string SysWideToUTF8(const std::wstring& wide);
+BASE_EXPORT std::wstring SysUTF8ToWide(StringPiece utf8);
+
+// Converts between wide and the system multi-byte representations of a string.
+// DANGER: This will lose information and can change (on Windows, this can
+// change between reboots).
+BASE_EXPORT std::string SysWideToNativeMB(const std::wstring& wide);
+BASE_EXPORT std::wstring SysNativeMBToWide(StringPiece native_mb);
+
+// Windows-specific ------------------------------------------------------------
+
+#if defined(OS_WIN)
+
+// Converts between 8-bit and wide strings, using the given code page. The
+// code page identifier is one accepted by the Windows function
+// MultiByteToWideChar().
+BASE_EXPORT std::wstring SysMultiByteToWide(StringPiece mb, uint32_t code_page);
+BASE_EXPORT std::string SysWideToMultiByte(const std::wstring& wide,
+                                           uint32_t code_page);
+
+#endif  // defined(OS_WIN)
+
+// Mac-specific ----------------------------------------------------------------
+
+#if defined(OS_MACOSX)
+
+// Converts between STL strings and CFStringRefs/NSStrings.
+
+// Creates a string, and returns it with a refcount of 1. You are responsible
+// for releasing it. Returns NULL on failure.
+BASE_EXPORT CFStringRef SysUTF8ToCFStringRef(const std::string& utf8);
+BASE_EXPORT CFStringRef SysUTF16ToCFStringRef(const string16& utf16);
+
+// Same, but returns an autoreleased NSString.
+BASE_EXPORT NSString* SysUTF8ToNSString(const std::string& utf8);
+BASE_EXPORT NSString* SysUTF16ToNSString(const string16& utf16);
+
+// Converts a CFStringRef to an STL string. Returns an empty string on failure.
+BASE_EXPORT std::string SysCFStringRefToUTF8(CFStringRef ref);
+BASE_EXPORT string16 SysCFStringRefToUTF16(CFStringRef ref);
+
+// Same, but accepts NSString input. Converts nil NSString* to the appropriate
+// string type of length 0.
+BASE_EXPORT std::string SysNSStringToUTF8(NSString* ref);
+BASE_EXPORT string16 SysNSStringToUTF16(NSString* ref);
+
+#endif  // defined(OS_MACOSX)
+
+}  // namespace base
+
+#endif  // BASE_STRINGS_SYS_STRING_CONVERSIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/utf_string_conversion_utils.h b/native/zucchini/vendor/libchrome/base/strings/utf_string_conversion_utils.h
new file mode 100644
index 0000000..2d95870
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/utf_string_conversion_utils.h
@@ -0,0 +1,100 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_STRINGS_UTF_STRING_CONVERSION_UTILS_H_
+#define BASE_STRINGS_UTF_STRING_CONVERSION_UTILS_H_
+
+// Low-level UTF handling functions. Most code will want to use the functions
+// in utf_string_conversions.h
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base/base_export.h"
+#include "base/strings/string16.h"
+
+namespace base {
+
+inline bool IsValidCodepoint(uint32_t code_point) {
+  // Excludes the surrogate code points ([0xD800, 0xDFFF]) and
+  // codepoints larger than 0x10FFFF (the highest codepoint allowed).
+  // Non-characters and unassigned codepoints are allowed.
+  return code_point < 0xD800u ||
+         (code_point >= 0xE000u && code_point <= 0x10FFFFu);
+}
+
+inline bool IsValidCharacter(uint32_t code_point) {
+  // Excludes non-characters (U+FDD0..U+FDEF, and all codepoints ending in
+  // 0xFFFE or 0xFFFF) from the set of valid code points.
+  return code_point < 0xD800u || (code_point >= 0xE000u &&
+      code_point < 0xFDD0u) || (code_point > 0xFDEFu &&
+      code_point <= 0x10FFFFu && (code_point & 0xFFFEu) != 0xFFFEu);
+}
+
+// ReadUnicodeCharacter --------------------------------------------------------
+
+// Reads a UTF-8 stream, placing the next code point into the given output
+// |*code_point|. |src| represents the entire string to read, and |*char_index|
+// is the character offset within the string to start reading at. |*char_index|
+// will be updated to index the last character read, such that incrementing it
+// (as in a for loop) will take the reader to the next character.
+//
+// Returns true on success. On false, |*code_point| will be invalid.
+BASE_EXPORT bool ReadUnicodeCharacter(const char* src,
+                                      int32_t src_len,
+                                      int32_t* char_index,
+                                      uint32_t* code_point_out);
+
+// Reads a UTF-16 character. The usage is the same as the 8-bit version above.
+BASE_EXPORT bool ReadUnicodeCharacter(const char16* src,
+                                      int32_t src_len,
+                                      int32_t* char_index,
+                                      uint32_t* code_point);
+
+#if defined(WCHAR_T_IS_UTF32)
+// Reads UTF-32 character. The usage is the same as the 8-bit version above.
+BASE_EXPORT bool ReadUnicodeCharacter(const wchar_t* src,
+                                      int32_t src_len,
+                                      int32_t* char_index,
+                                      uint32_t* code_point);
+#endif  // defined(WCHAR_T_IS_UTF32)
+
+// WriteUnicodeCharacter -------------------------------------------------------
+
+// Appends a UTF-8 character to the given 8-bit string.  Returns the number of
+// bytes written.
+BASE_EXPORT size_t WriteUnicodeCharacter(uint32_t code_point,
+                                         std::string* output);
+
+// Appends the given code point as a UTF-16 character to the given 16-bit
+// string.  Returns the number of 16-bit values written.
+BASE_EXPORT size_t WriteUnicodeCharacter(uint32_t code_point, string16* output);
+
+#if defined(WCHAR_T_IS_UTF32)
+// Appends the given UTF-32 character to the given 32-bit string.  Returns the
+// number of 32-bit values written.
+inline size_t WriteUnicodeCharacter(uint32_t code_point, std::wstring* output) {
+  // This is the easy case, just append the character.
+  output->push_back(code_point);
+  return 1;
+}
+#endif  // defined(WCHAR_T_IS_UTF32)
+
+// Generalized Unicode converter -----------------------------------------------
+
+// Guesses the length of the output in UTF-8 in bytes, clears that output
+// string, and reserves that amount of space.  We assume that the input
+// character types are unsigned, which will be true for UTF-16 and -32 on our
+// systems.
+template<typename CHAR>
+void PrepareForUTF8Output(const CHAR* src, size_t src_len, std::string* output);
+
+// Prepares an output buffer (containing either UTF-16 or -32 data) given some
+// UTF-8 input that will be converted to it.  See PrepareForUTF8Output().
+template<typename STRING>
+void PrepareForUTF16Or32Output(const char* src, size_t src_len, STRING* output);
+
+}  // namespace base
+
+#endif  // BASE_STRINGS_UTF_STRING_CONVERSION_UTILS_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/utf_string_conversions.h b/native/zucchini/vendor/libchrome/base/strings/utf_string_conversions.h
new file mode 100644
index 0000000..14f94ac
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/strings/utf_string_conversions.h
@@ -0,0 +1,54 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_STRINGS_UTF_STRING_CONVERSIONS_H_
+#define BASE_STRINGS_UTF_STRING_CONVERSIONS_H_
+
+#include <stddef.h>
+
+#include <string>
+
+#include "base/base_export.h"
+#include "base/strings/string16.h"
+#include "base/strings/string_piece.h"
+
+namespace base {
+
+// These convert between UTF-8, -16, and -32 strings. They are potentially slow,
+// so avoid unnecessary conversions. The low-level versions return a boolean
+// indicating whether the conversion was 100% valid. In this case, it will still
+// do the best it can and put the result in the output buffer. The versions that
+// return strings ignore this error and just return the best conversion
+// possible.
+BASE_EXPORT bool WideToUTF8(const wchar_t* src, size_t src_len,
+                            std::string* output);
+BASE_EXPORT std::string WideToUTF8(WStringPiece wide);
+BASE_EXPORT bool UTF8ToWide(const char* src, size_t src_len,
+                            std::wstring* output);
+BASE_EXPORT std::wstring UTF8ToWide(StringPiece utf8);
+
+BASE_EXPORT bool WideToUTF16(const wchar_t* src, size_t src_len,
+                             string16* output);
+BASE_EXPORT string16 WideToUTF16(WStringPiece wide);
+BASE_EXPORT bool UTF16ToWide(const char16* src, size_t src_len,
+                             std::wstring* output);
+BASE_EXPORT std::wstring UTF16ToWide(StringPiece16 utf16);
+
+BASE_EXPORT bool UTF8ToUTF16(const char* src, size_t src_len, string16* output);
+BASE_EXPORT string16 UTF8ToUTF16(StringPiece utf8);
+BASE_EXPORT bool UTF16ToUTF8(const char16* src, size_t src_len,
+                             std::string* output);
+BASE_EXPORT std::string UTF16ToUTF8(StringPiece16 utf16);
+
+// This converts an ASCII string, typically a hardcoded constant, to a UTF16
+// string.
+BASE_EXPORT string16 ASCIIToUTF16(StringPiece ascii);
+
+// Converts to 7-bit ASCII by truncating. The result must be known to be ASCII
+// beforehand.
+BASE_EXPORT std::string UTF16ToASCII(StringPiece16 utf16);
+
+}  // namespace base
+
+#endif  // BASE_STRINGS_UTF_STRING_CONVERSIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/synchronization/lock.h b/native/zucchini/vendor/libchrome/base/synchronization/lock.h
new file mode 100644
index 0000000..d1c647c
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/synchronization/lock.h
@@ -0,0 +1,151 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_SYNCHRONIZATION_LOCK_H_
+#define BASE_SYNCHRONIZATION_LOCK_H_
+
+#include "base/base_export.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/synchronization/lock_impl.h"
+#include "base/threading/platform_thread.h"
+#include "build/build_config.h"
+
+namespace base {
+
+// A convenient wrapper for an OS specific critical section.  The only real
+// intelligence in this class is in debug mode for the support for the
+// AssertAcquired() method.
+class BASE_EXPORT Lock {
+ public:
+#if !DCHECK_IS_ON()
+   // Optimized wrapper implementation
+  Lock() : lock_() {}
+  ~Lock() {}
+  void Acquire() { lock_.Lock(); }
+  void Release() { lock_.Unlock(); }
+
+  // If the lock is not held, take it and return true. If the lock is already
+  // held by another thread, immediately return false. This must not be called
+  // by a thread already holding the lock (what happens is undefined and an
+  // assertion may fail).
+  bool Try() { return lock_.Try(); }
+
+  // Null implementation if not debug.
+  void AssertAcquired() const {}
+#else
+  Lock();
+  ~Lock();
+
+  // NOTE: We do not permit recursive locks and will commonly fire a DCHECK() if
+  // a thread attempts to acquire the lock a second time (while already holding
+  // it).
+  void Acquire() {
+    lock_.Lock();
+    CheckUnheldAndMark();
+  }
+  void Release() {
+    CheckHeldAndUnmark();
+    lock_.Unlock();
+  }
+
+  bool Try() {
+    bool rv = lock_.Try();
+    if (rv) {
+      CheckUnheldAndMark();
+    }
+    return rv;
+  }
+
+  void AssertAcquired() const;
+#endif  // DCHECK_IS_ON()
+
+  // Whether Lock mitigates priority inversion when used from different thread
+  // priorities.
+  static bool HandlesMultipleThreadPriorities() {
+#if defined(OS_WIN)
+    // Windows mitigates priority inversion by randomly boosting the priority of
+    // ready threads.
+    // https://msdn.microsoft.com/library/windows/desktop/ms684831.aspx
+    return true;
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+    // POSIX mitigates priority inversion by setting the priority of a thread
+    // holding a Lock to the maximum priority of any other thread waiting on it.
+    return internal::LockImpl::PriorityInheritanceAvailable();
+#else
+#error Unsupported platform
+#endif
+  }
+
+  // Both Windows and POSIX implementations of ConditionVariable need to be
+  // able to see our lock and tweak our debugging counters, as they release and
+  // acquire locks inside of their condition variable APIs.
+  friend class ConditionVariable;
+
+ private:
+#if DCHECK_IS_ON()
+  // Members and routines taking care of locks assertions.
+  // Note that this checks for recursive locks and allows them
+  // if the variable is set.  This is allowed by the underlying implementation
+  // on windows but not on Posix, so we're doing unneeded checks on Posix.
+  // It's worth it to share the code.
+  void CheckHeldAndUnmark();
+  void CheckUnheldAndMark();
+
+  // All private data is implicitly protected by lock_.
+  // Be VERY careful to only access members under that lock.
+  base::PlatformThreadRef owning_thread_ref_;
+#endif  // DCHECK_IS_ON()
+
+  // Platform specific underlying lock implementation.
+  internal::LockImpl lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(Lock);
+};
+
+// A helper class that acquires the given Lock while the AutoLock is in scope.
+class AutoLock {
+ public:
+  struct AlreadyAcquired {};
+
+  explicit AutoLock(Lock& lock) : lock_(lock) {
+    lock_.Acquire();
+  }
+
+  AutoLock(Lock& lock, const AlreadyAcquired&) : lock_(lock) {
+    lock_.AssertAcquired();
+  }
+
+  ~AutoLock() {
+    lock_.AssertAcquired();
+    lock_.Release();
+  }
+
+ private:
+  Lock& lock_;
+  DISALLOW_COPY_AND_ASSIGN(AutoLock);
+};
+
+// AutoUnlock is a helper that will Release() the |lock| argument in the
+// constructor, and re-Acquire() it in the destructor.
+class AutoUnlock {
+ public:
+  explicit AutoUnlock(Lock& lock) : lock_(lock) {
+    // We require our caller to have the lock.
+    lock_.AssertAcquired();
+    lock_.Release();
+  }
+
+  ~AutoUnlock() {
+    lock_.Acquire();
+  }
+
+ private:
+  Lock& lock_;
+  DISALLOW_COPY_AND_ASSIGN(AutoUnlock);
+};
+
+}  // namespace base
+
+#endif  // BASE_SYNCHRONIZATION_LOCK_H_
diff --git a/native/zucchini/vendor/libchrome/base/synchronization/lock_impl.h b/native/zucchini/vendor/libchrome/base/synchronization/lock_impl.h
new file mode 100644
index 0000000..221d763
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/synchronization/lock_impl.h
@@ -0,0 +1,78 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_SYNCHRONIZATION_LOCK_IMPL_H_
+#define BASE_SYNCHRONIZATION_LOCK_IMPL_H_
+
+#include "base/base_export.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include "base/win/windows_types.h"
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+#include <errno.h>
+#include <pthread.h>
+#endif
+
+namespace base {
+namespace internal {
+
+// This class implements the underlying platform-specific spin-lock mechanism
+// used for the Lock class.  Most users should not use LockImpl directly, but
+// should instead use Lock.
+class BASE_EXPORT LockImpl {
+ public:
+#if defined(OS_WIN)
+  using NativeHandle = CHROME_SRWLOCK;
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  using NativeHandle = pthread_mutex_t;
+#endif
+
+  LockImpl();
+  ~LockImpl();
+
+  // If the lock is not held, take it and return true.  If the lock is already
+  // held by something else, immediately return false.
+  bool Try();
+
+  // Take the lock, blocking until it is available if necessary.
+  void Lock();
+
+  // Release the lock.  This must only be called by the lock's holder: after
+  // a successful call to Try, or a call to Lock.
+  inline void Unlock();
+
+  // Return the native underlying lock.
+  // TODO(awalker): refactor lock and condition variables so that this is
+  // unnecessary.
+  NativeHandle* native_handle() { return &native_handle_; }
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+  // Whether this lock will attempt to use priority inheritance.
+  static bool PriorityInheritanceAvailable();
+#endif
+
+ private:
+  NativeHandle native_handle_;
+
+  DISALLOW_COPY_AND_ASSIGN(LockImpl);
+};
+
+#if defined(OS_WIN)
+void LockImpl::Unlock() {
+  ::ReleaseSRWLockExclusive(reinterpret_cast<PSRWLOCK>(&native_handle_));
+}
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+void LockImpl::Unlock() {
+  int rv = pthread_mutex_unlock(&native_handle_);
+  DCHECK_EQ(rv, 0) << ". " << strerror(rv);
+}
+#endif
+
+}  // namespace internal
+}  // namespace base
+
+#endif  // BASE_SYNCHRONIZATION_LOCK_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/synchronization/lock_impl_posix.cc b/native/zucchini/vendor/libchrome/base/synchronization/lock_impl_posix.cc
new file mode 100644
index 0000000..7571f68
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/synchronization/lock_impl_posix.cc
@@ -0,0 +1,133 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/synchronization/lock_impl.h"
+
+#include <string>
+
+#include "base/debug/activity_tracker.h"
+#include "base/logging.h"
+#include "base/posix/safe_strerror.h"
+#include "base/strings/stringprintf.h"
+#include "base/synchronization/lock.h"
+#include "base/synchronization/synchronization_buildflags.h"
+#include "build/build_config.h"
+
+namespace base {
+namespace internal {
+
+namespace {
+
+#if DCHECK_IS_ON()
+const char* AdditionalHintForSystemErrorCode(int error_code) {
+  switch (error_code) {
+    case EINVAL:
+      return "Hint: This is often related to a use-after-free.";
+    default:
+      return "";
+  }
+}
+#endif  // DCHECK_IS_ON()
+
+std::string SystemErrorCodeToString(int error_code) {
+#if DCHECK_IS_ON()
+  return base::safe_strerror(error_code) + ". " +
+         AdditionalHintForSystemErrorCode(error_code);
+#else   // DCHECK_IS_ON()
+  return std::string();
+#endif  // DCHECK_IS_ON()
+}
+
+}  // namespace
+
+// Determines which platforms can consider using priority inheritance locks. Use
+// this define for platform code that may not compile if priority inheritance
+// locks aren't available. For this platform code,
+// PRIORITY_INHERITANCE_LOCKS_POSSIBLE() is a necessary but insufficient check.
+// Lock::PriorityInheritanceAvailable still must be checked as the code may
+// compile but the underlying platform still may not correctly support priority
+// inheritance locks.
+#if defined(OS_NACL) || defined(OS_ANDROID) || defined(OS_FUCHSIA)
+#define PRIORITY_INHERITANCE_LOCKS_POSSIBLE() 0
+#else
+#define PRIORITY_INHERITANCE_LOCKS_POSSIBLE() 1
+#endif
+
+LockImpl::LockImpl() {
+  pthread_mutexattr_t mta;
+  int rv = pthread_mutexattr_init(&mta);
+  DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
+#if PRIORITY_INHERITANCE_LOCKS_POSSIBLE()
+  if (PriorityInheritanceAvailable()) {
+    rv = pthread_mutexattr_setprotocol(&mta, PTHREAD_PRIO_INHERIT);
+    DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
+  }
+#endif
+#ifndef NDEBUG
+  // In debug, setup attributes for lock error checking.
+  rv = pthread_mutexattr_settype(&mta, PTHREAD_MUTEX_ERRORCHECK);
+  DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
+#endif
+  rv = pthread_mutex_init(&native_handle_, &mta);
+  DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
+  rv = pthread_mutexattr_destroy(&mta);
+  DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
+}
+
+LockImpl::~LockImpl() {
+  int rv = pthread_mutex_destroy(&native_handle_);
+  DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
+}
+
+bool LockImpl::Try() {
+  int rv = pthread_mutex_trylock(&native_handle_);
+  DCHECK(rv == 0 || rv == EBUSY) << ". " << SystemErrorCodeToString(rv);
+  return rv == 0;
+}
+
+void LockImpl::Lock() {
+  // The ScopedLockAcquireActivity below is relatively expensive and so its
+  // actions can become significant due to the very large number of locks
+  // that tend to be used throughout the build. To avoid this cost in the
+  // vast majority of the calls, simply "try" the lock first and only do the
+  // (tracked) blocking call if that fails. Since "try" itself is a system
+  // call, and thus also somewhat expensive, don't bother with it unless
+  // tracking is actually enabled.
+  if (base::debug::GlobalActivityTracker::IsEnabled())
+    if (Try())
+      return;
+
+  base::debug::ScopedLockAcquireActivity lock_activity(this);
+  int rv = pthread_mutex_lock(&native_handle_);
+  DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
+}
+
+// static
+bool LockImpl::PriorityInheritanceAvailable() {
+#if BUILDFLAG(ENABLE_MUTEX_PRIORITY_INHERITANCE)
+  return true;
+#elif PRIORITY_INHERITANCE_LOCKS_POSSIBLE() && defined(OS_MACOSX)
+  return true;
+#else
+  // Security concerns prevent the use of priority inheritance mutexes on Linux.
+  //   * CVE-2010-0622 - Linux < 2.6.33-rc7, wake_futex_pi possible DoS.
+  //     https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2010-0622
+  //   * CVE-2012-6647 - Linux < 3.5.1, futex_wait_requeue_pi possible DoS.
+  //     https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2012-6647
+  //   * CVE-2014-3153 - Linux <= 3.14.5, futex_requeue, privilege escalation.
+  //     https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-3153
+  //
+  // If the above were all addressed, we still need a runtime check to deal with
+  // the bug below.
+  //   * glibc Bug 14652: https://sourceware.org/bugzilla/show_bug.cgi?id=14652
+  //     Fixed in glibc 2.17.
+  //     Priority inheritance mutexes may deadlock with condition variables
+  //     during reacquisition of the mutex after the condition variable is
+  //     signalled.
+  return false;
+#endif
+}
+
+}  // namespace internal
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/synchronization/synchronization_buildflags.h b/native/zucchini/vendor/libchrome/base/synchronization/synchronization_buildflags.h
new file mode 100644
index 0000000..98941f4
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/synchronization/synchronization_buildflags.h
@@ -0,0 +1,4 @@
+#ifndef BASE_SYNCHRONIZATION_BUILDFLAGS_H_
+#define BASE_SYNCHRONIZATION_BUILDFLAGS_H_
+#include "build/buildflag.h"
+#endif  // BASE_SYNCHRONIZATION_BUILDFLAGS_H_
diff --git a/native/zucchini/vendor/libchrome/base/sys_info.h b/native/zucchini/vendor/libchrome/base/sys_info.h
new file mode 100644
index 0000000..36bf565
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/sys_info.h
@@ -0,0 +1,179 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_SYS_INFO_H_
+#define BASE_SYS_INFO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <map>
+#include <string>
+
+#include "base/base_export.h"
+#include "base/files/file_path.h"
+#include "base/gtest_prod_util.h"
+#include "base/time/time.h"
+#include "build/build_config.h"
+
+namespace base {
+
+namespace debug {
+FORWARD_DECLARE_TEST(SystemMetricsTest, ParseMeminfo);
+}
+
+struct SystemMemoryInfoKB;
+
+class BASE_EXPORT SysInfo {
+ public:
+  // Return the number of logical processors/cores on the current machine.
+  static int NumberOfProcessors();
+
+  // Return the number of bytes of physical memory on the current machine.
+  static int64_t AmountOfPhysicalMemory();
+
+  // Return the number of bytes of current available physical memory on the
+  // machine.
+  // (The amount of memory that can be allocated without any significant
+  // impact on the system. It can lead to freeing inactive file-backed
+  // and/or speculative file-backed memory).
+  static int64_t AmountOfAvailablePhysicalMemory();
+
+  // Return the number of bytes of virtual memory of this process. A return
+  // value of zero means that there is no limit on the available virtual
+  // memory.
+  static int64_t AmountOfVirtualMemory();
+
+  // Return the number of megabytes of physical memory on the current machine.
+  static int AmountOfPhysicalMemoryMB() {
+    return static_cast<int>(AmountOfPhysicalMemory() / 1024 / 1024);
+  }
+
+  // Return the number of megabytes of available virtual memory, or zero if it
+  // is unlimited.
+  static int AmountOfVirtualMemoryMB() {
+    return static_cast<int>(AmountOfVirtualMemory() / 1024 / 1024);
+  }
+
+  // Return the available disk space in bytes on the volume containing |path|,
+  // or -1 on failure.
+  static int64_t AmountOfFreeDiskSpace(const FilePath& path);
+
+  // Return the total disk space in bytes on the volume containing |path|, or -1
+  // on failure.
+  static int64_t AmountOfTotalDiskSpace(const FilePath& path);
+
+  // Returns system uptime.
+  static TimeDelta Uptime();
+
+  // Returns a descriptive string for the current machine model or an empty
+  // string if the machine model is unknown or an error occured.
+  // e.g. "MacPro1,1" on Mac, "iPhone9,3" on iOS or "Nexus 5" on Android. Only
+  // implemented on OS X, iOS, Android, and Chrome OS. This returns an empty
+  // string on other platforms.
+  static std::string HardwareModelName();
+
+  // Returns the name of the host operating system.
+  static std::string OperatingSystemName();
+
+  // Returns the version of the host operating system.
+  static std::string OperatingSystemVersion();
+
+  // Retrieves detailed numeric values for the OS version.
+  // DON'T USE THIS ON THE MAC OR WINDOWS to determine the current OS release
+  // for OS version-specific feature checks and workarounds. If you must use
+  // an OS version check instead of a feature check, use the base::mac::IsOS*
+  // family from base/mac/mac_util.h, or base::win::GetVersion from
+  // base/win/windows_version.h.
+  static void OperatingSystemVersionNumbers(int32_t* major_version,
+                                            int32_t* minor_version,
+                                            int32_t* bugfix_version);
+
+  // Returns the architecture of the running operating system.
+  // Exact return value may differ across platforms.
+  // e.g. a 32-bit x86 kernel on a 64-bit capable CPU will return "x86",
+  //      whereas a x86-64 kernel on the same CPU will return "x86_64"
+  static std::string OperatingSystemArchitecture();
+
+  // Avoid using this. Use base/cpu.h to get information about the CPU instead.
+  // http://crbug.com/148884
+  // Returns the CPU model name of the system. If it can not be figured out,
+  // an empty string is returned.
+  static std::string CPUModelName();
+
+  // Return the smallest amount of memory (in bytes) which the VM system will
+  // allocate.
+  static size_t VMAllocationGranularity();
+
+#if defined(OS_CHROMEOS)
+  typedef std::map<std::string, std::string> LsbReleaseMap;
+
+  // Returns the contents of /etc/lsb-release as a map.
+  static const LsbReleaseMap& GetLsbReleaseMap();
+
+  // If |key| is present in the LsbReleaseMap, sets |value| and returns true.
+  static bool GetLsbReleaseValue(const std::string& key, std::string* value);
+
+  // Convenience function for GetLsbReleaseValue("CHROMEOS_RELEASE_BOARD",...).
+  // Returns "unknown" if CHROMEOS_RELEASE_BOARD is not set. Otherwise, returns
+  // the full name of the board. Note that the returned value often differs
+  // between developers' systems and devices that use official builds. E.g. for
+  // a developer-built image, the function could return 'glimmer', while in an
+  // official build, it may be something like 'glimmer-signed-mp-v4keys'.
+  //
+  // NOTE: Strings returned by this function should be treated as opaque values
+  // within Chrome (e.g. for reporting metrics elsewhere). If you need to make
+  // Chrome behave differently for different Chrome OS devices, either directly
+  // check for the hardware feature that you care about (preferred) or add a
+  // command-line flag to Chrome and pass it from session_manager (based on
+  // whether a USE flag is set or not). See https://goo.gl/BbBkzg for more
+  // details.
+  static std::string GetLsbReleaseBoard();
+
+  // Returns the creation time of /etc/lsb-release. (Used to get the date and
+  // time of the Chrome OS build).
+  static Time GetLsbReleaseTime();
+
+  // Returns true when actually running in a Chrome OS environment.
+  static bool IsRunningOnChromeOS();
+
+  // Test method to force re-parsing of lsb-release.
+  static void SetChromeOSVersionInfoForTest(const std::string& lsb_release,
+                                            const Time& lsb_release_time);
+#endif  // defined(OS_CHROMEOS)
+
+#if defined(OS_ANDROID)
+  // Returns the Android build's codename.
+  static std::string GetAndroidBuildCodename();
+
+  // Returns the Android build ID.
+  static std::string GetAndroidBuildID();
+
+  static int DalvikHeapSizeMB();
+  static int DalvikHeapGrowthLimitMB();
+#endif  // defined(OS_ANDROID)
+
+  // Returns true if this is a low-end device.
+  // Low-end device refers to devices having a very low amount of total
+  // system memory, typically <= 1GB.
+  // See also SysUtils.java, method isLowEndDevice.
+  static bool IsLowEndDevice();
+
+ private:
+  FRIEND_TEST_ALL_PREFIXES(SysInfoTest, AmountOfAvailablePhysicalMemory);
+  FRIEND_TEST_ALL_PREFIXES(debug::SystemMetricsTest, ParseMeminfo);
+
+  static int64_t AmountOfPhysicalMemoryImpl();
+  static int64_t AmountOfAvailablePhysicalMemoryImpl();
+  static bool IsLowEndDeviceImpl();
+
+#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_AIX)
+  static int64_t AmountOfAvailablePhysicalMemory(
+      const SystemMemoryInfoKB& meminfo);
+#endif
+};
+
+}  // namespace base
+
+#endif  // BASE_SYS_INFO_H_
diff --git a/native/zucchini/vendor/libchrome/base/task_runner.h b/native/zucchini/vendor/libchrome/base/task_runner.h
new file mode 100644
index 0000000..1d302ab
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/task_runner.h
@@ -0,0 +1,154 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_TASK_RUNNER_H_
+#define BASE_TASK_RUNNER_H_
+
+#include <stddef.h>
+
+#include "base/base_export.h"
+#include "base/callback.h"
+#include "base/location.h"
+#include "base/memory/ref_counted.h"
+#include "base/time/time.h"
+
+namespace base {
+
+struct TaskRunnerTraits;
+
+// A TaskRunner is an object that runs posted tasks (in the form of
+// Closure objects).  The TaskRunner interface provides a way of
+// decoupling task posting from the mechanics of how each task will be
+// run.  TaskRunner provides very weak guarantees as to how posted
+// tasks are run (or if they're run at all).  In particular, it only
+// guarantees:
+//
+//   - Posting a task will not run it synchronously.  That is, no
+//     Post*Task method will call task.Run() directly.
+//
+//   - Increasing the delay can only delay when the task gets run.
+//     That is, increasing the delay may not affect when the task gets
+//     run, or it could make it run later than it normally would, but
+//     it won't make it run earlier than it normally would.
+//
+// TaskRunner does not guarantee the order in which posted tasks are
+// run, whether tasks overlap, or whether they're run on a particular
+// thread.  Also it does not guarantee a memory model for shared data
+// between tasks.  (In other words, you should use your own
+// synchronization/locking primitives if you need to share data
+// between tasks.)
+//
+// Implementations of TaskRunner should be thread-safe in that all
+// methods must be safe to call on any thread.  Ownership semantics
+// for TaskRunners are in general not clear, which is why the
+// interface itself is RefCountedThreadSafe.
+//
+// Some theoretical implementations of TaskRunner:
+//
+//   - A TaskRunner that uses a thread pool to run posted tasks.
+//
+//   - A TaskRunner that, for each task, spawns a non-joinable thread
+//     to run that task and immediately quit.
+//
+//   - A TaskRunner that stores the list of posted tasks and has a
+//     method Run() that runs each runnable task in random order.
+class BASE_EXPORT TaskRunner
+    : public RefCountedThreadSafe<TaskRunner, TaskRunnerTraits> {
+ public:
+  // Posts the given task to be run.  Returns true if the task may be
+  // run at some point in the future, and false if the task definitely
+  // will not be run.
+  //
+  // Equivalent to PostDelayedTask(from_here, task, 0).
+  bool PostTask(const Location& from_here, OnceClosure task);
+
+  // Like PostTask, but tries to run the posted task only after |delay_ms|
+  // has passed. Implementations should use a tick clock, rather than wall-
+  // clock time, to implement |delay|.
+  virtual bool PostDelayedTask(const Location& from_here,
+                               OnceClosure task,
+                               base::TimeDelta delay) = 0;
+
+  // Returns true iff tasks posted to this TaskRunner are sequenced
+  // with this call.
+  //
+  // In particular:
+  // - Returns true if this is a SequencedTaskRunner to which the
+  //   current task was posted.
+  // - Returns true if this is a SequencedTaskRunner bound to the
+  //   same sequence as the SequencedTaskRunner to which the current
+  //   task was posted.
+  // - Returns true if this is a SingleThreadTaskRunner bound to
+  //   the current thread.
+  // TODO(http://crbug.com/665062):
+  //   This API doesn't make sense for parallel TaskRunners.
+  //   Introduce alternate static APIs for documentation purposes of "this runs
+  //   in pool X", have RunsTasksInCurrentSequence() return false for parallel
+  //   TaskRunners, and ultimately move this method down to SequencedTaskRunner.
+  virtual bool RunsTasksInCurrentSequence() const = 0;
+
+  // Posts |task| on the current TaskRunner.  On completion, |reply|
+  // is posted to the thread that called PostTaskAndReply().  Both
+  // |task| and |reply| are guaranteed to be deleted on the thread
+  // from which PostTaskAndReply() is invoked.  This allows objects
+  // that must be deleted on the originating thread to be bound into
+  // the |task| and |reply| Closures.  In particular, it can be useful
+  // to use WeakPtr<> in the |reply| Closure so that the reply
+  // operation can be canceled. See the following pseudo-code:
+  //
+  // class DataBuffer : public RefCountedThreadSafe<DataBuffer> {
+  //  public:
+  //   // Called to add data into a buffer.
+  //   void AddData(void* buf, size_t length);
+  //   ...
+  // };
+  //
+  //
+  // class DataLoader : public SupportsWeakPtr<DataLoader> {
+  //  public:
+  //    void GetData() {
+  //      scoped_refptr<DataBuffer> buffer = new DataBuffer();
+  //      target_thread_.task_runner()->PostTaskAndReply(
+  //          FROM_HERE,
+  //          base::Bind(&DataBuffer::AddData, buffer),
+  //          base::Bind(&DataLoader::OnDataReceived, AsWeakPtr(), buffer));
+  //    }
+  //
+  //  private:
+  //    void OnDataReceived(scoped_refptr<DataBuffer> buffer) {
+  //      // Do something with buffer.
+  //    }
+  // };
+  //
+  //
+  // Things to notice:
+  //   * Results of |task| are shared with |reply| by binding a shared argument
+  //     (a DataBuffer instance).
+  //   * The DataLoader object has no special thread safety.
+  //   * The DataLoader object can be deleted while |task| is still running,
+  //     and the reply will cancel itself safely because it is bound to a
+  //     WeakPtr<>.
+  bool PostTaskAndReply(const Location& from_here,
+                        OnceClosure task,
+                        OnceClosure reply);
+
+ protected:
+  friend struct TaskRunnerTraits;
+
+  TaskRunner();
+  virtual ~TaskRunner();
+
+  // Called when this object should be destroyed.  By default simply
+  // deletes |this|, but can be overridden to do something else, like
+  // delete on a certain thread.
+  virtual void OnDestruct() const;
+};
+
+struct BASE_EXPORT TaskRunnerTraits {
+  static void Destruct(const TaskRunner* task_runner);
+};
+
+}  // namespace base
+
+#endif  // BASE_TASK_RUNNER_H_
diff --git a/native/zucchini/vendor/libchrome/base/template_util.h b/native/zucchini/vendor/libchrome/base/template_util.h
new file mode 100644
index 0000000..e4d03a2
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/template_util.h
@@ -0,0 +1,154 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_TEMPLATE_UTIL_H_
+#define BASE_TEMPLATE_UTIL_H_
+
+#include <stddef.h>
+#include <iosfwd>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "build/build_config.h"
+
+// Some versions of libstdc++ have partial support for type_traits, but misses
+// a smaller subset while removing some of the older non-standard stuff. Assume
+// that all versions below 5.0 fall in this category, along with one 5.0
+// experimental release. Test for this by consulting compiler major version,
+// the only reliable option available, so theoretically this could fail should
+// you attempt to mix an earlier version of libstdc++ with >= GCC5. But
+// that's unlikely to work out, especially as GCC5 changed ABI.
+#define CR_GLIBCXX_5_0_0 20150123
+// `!defined(__clang__)` is a local android patch
+#if !defined(__clang__) && ((defined(__GNUC__) && __GNUC__ < 5) || \
+    (defined(__GLIBCXX__) && __GLIBCXX__ == CR_GLIBCXX_5_0_0))
+#define CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX
+#endif
+
+// This hacks around using gcc with libc++ which has some incompatibilies.
+// - is_trivially_* doesn't work: https://llvm.org/bugs/show_bug.cgi?id=27538
+// TODO(danakj): Remove this when android builders are all using a newer version
+// of gcc, or the android ndk is updated to a newer libc++ that works with older
+// gcc versions.
+#if !defined(__clang__) && defined(_LIBCPP_VERSION)
+#define CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
+#endif
+
+namespace base {
+
+template <class T> struct is_non_const_reference : std::false_type {};
+template <class T> struct is_non_const_reference<T&> : std::true_type {};
+template <class T> struct is_non_const_reference<const T&> : std::false_type {};
+
+namespace internal {
+
+// Implementation detail of base::void_t below.
+template <typename...>
+struct make_void {
+  using type = void;
+};
+
+}  // namespace internal
+
+// base::void_t is an implementation of std::void_t from C++17.
+//
+// We use |base::internal::make_void| as a helper struct to avoid a C++14
+// defect:
+//   http://en.cppreference.com/w/cpp/types/void_t
+//   http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#1558
+template <typename... Ts>
+using void_t = typename ::base::internal::make_void<Ts...>::type;
+
+namespace internal {
+
+// Uses expression SFINAE to detect whether using operator<< would work.
+template <typename T, typename = void>
+struct SupportsOstreamOperator : std::false_type {};
+template <typename T>
+struct SupportsOstreamOperator<T,
+                               decltype(void(std::declval<std::ostream&>()
+                                             << std::declval<T>()))>
+    : std::true_type {};
+
+// Used to detech whether the given type is an iterator.  This is normally used
+// with std::enable_if to provide disambiguation for functions that take
+// templatzed iterators as input.
+template <typename T, typename = void>
+struct is_iterator : std::false_type {};
+
+template <typename T>
+struct is_iterator<T,
+                   void_t<typename std::iterator_traits<T>::iterator_category>>
+    : std::true_type {};
+
+}  // namespace internal
+
+// is_trivially_copyable is especially hard to get right.
+// - Older versions of libstdc++ will fail to have it like they do for other
+//   type traits. This has become a subset of the second point, but used to be
+//   handled independently.
+// - An experimental release of gcc includes most of type_traits but misses
+//   is_trivially_copyable, so we still have to avoid using libstdc++ in this
+//   case, which is covered by CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX.
+// - When compiling libc++ from before r239653, with a gcc compiler, the
+//   std::is_trivially_copyable can fail. So we need to work around that by not
+//   using the one in libc++ in this case. This is covered by the
+//   CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX define, and is discussed in
+//   https://llvm.org/bugs/show_bug.cgi?id=27538#c1 where they point out that
+//   in libc++'s commit r239653 this is fixed by libc++ checking for gcc 5.1.
+// - In both of the above cases we are using the gcc compiler. When defining
+//   this ourselves on compiler intrinsics, the __is_trivially_copyable()
+//   intrinsic is not available on gcc before version 5.1 (see the discussion in
+//   https://llvm.org/bugs/show_bug.cgi?id=27538#c1 again), so we must check for
+//   that version.
+// - When __is_trivially_copyable() is not available because we are on gcc older
+//   than 5.1, we need to fall back to something, so we use __has_trivial_copy()
+//   instead based on what was done one-off in bit_cast() previously.
+
+// TODO(crbug.com/554293): Remove this when all platforms have this in the std
+// namespace and it works with gcc as needed.
+#if defined(CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX) || \
+    defined(CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX)
+template <typename T>
+struct is_trivially_copyable {
+// TODO(danakj): Remove this when android builders are all using a newer version
+// of gcc, or the android ndk is updated to a newer libc++ that does this for
+// us.
+#if _GNUC_VER >= 501
+  static constexpr bool value = __is_trivially_copyable(T);
+#else
+  static constexpr bool value =
+      __has_trivial_copy(T) && __has_trivial_destructor(T);
+#endif
+};
+#else
+template <class T>
+using is_trivially_copyable = std::is_trivially_copyable<T>;
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 7
+// Workaround for g++7 and earlier family.
+// Due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80654, without this
+// Optional<std::vector<T>> where T is non-copyable causes a compile error.
+// As we know it is not trivially copy constructible, explicitly declare so.
+template <typename T>
+struct is_trivially_copy_constructible
+    : std::is_trivially_copy_constructible<T> {};
+
+template <typename... T>
+struct is_trivially_copy_constructible<std::vector<T...>> : std::false_type {};
+#else
+// Otherwise use std::is_trivially_copy_constructible as is.
+template <typename T>
+using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
+#endif
+
+}  // namespace base
+
+#undef CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
+#undef CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX
+
+#endif  // BASE_TEMPLATE_UTIL_H_
diff --git a/native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE b/native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE
new file mode 100644
index 0000000..2882e4e
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE
@@ -0,0 +1,76 @@
+COPYRIGHT AND PERMISSION NOTICE (ICU 58 and later)
+
+Copyright © 1991-2017 Unicode, Inc. All rights reserved.
+Distributed under the Terms of Use in http://www.unicode.org/copyright.html
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Unicode data files and any associated documentation
+(the "Data Files") or Unicode software and any associated documentation
+(the "Software") to deal in the Data Files or Software
+without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, and/or sell copies of
+the Data Files or Software, and to permit persons to whom the Data Files
+or Software are furnished to do so, provided that either
+(a) this copyright and permission notice appear with all copies
+of the Data Files or Software, or
+(b) this copyright and permission notice appear in associated
+Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT OF THIRD PARTY RIGHTS.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
+NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
+DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder
+shall not be used in advertising or otherwise to promote the sale,
+use or other dealings in these Data Files or Software without prior
+written authorization of the copyright holder.
+
+---------------------
+
+Third-Party Software Licenses
+
+This section contains third-party software notices and/or additional
+terms for licensed third-party software components included within ICU
+libraries.
+
+1. ICU License - ICU 1.8.1 to ICU 57.1
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright (c) 1995-2016 International Business Machines Corporation and others
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, provided that the above
+copyright notice(s) and this permission notice appear in all copies of
+the Software and that both the above copyright notice(s) and this
+permission notice appear in supporting documentation.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY
+SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER
+RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder
+shall not be used in advertising or otherwise to promote the sale, use
+or other dealings in this Software without prior written authorization
+of the copyright holder.
+
+All trademarks and registered trademarks mentioned herein are the
+property of their respective owners.
diff --git a/native/zucchini/vendor/libchrome/base/third_party/icu/icu_utf.h b/native/zucchini/vendor/libchrome/base/third_party/icu/icu_utf.h
new file mode 100644
index 0000000..2ba8231
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/third_party/icu/icu_utf.h
@@ -0,0 +1,442 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+/*
+******************************************************************************
+*
+*   Copyright (C) 1999-2015, International Business Machines
+*   Corporation and others.  All Rights Reserved.
+*
+******************************************************************************
+*/
+
+#ifndef BASE_THIRD_PARTY_ICU_ICU_UTF_H_
+#define BASE_THIRD_PARTY_ICU_ICU_UTF_H_
+
+#include <stdint.h>
+
+namespace base_icu {
+
+// source/common/unicode/umachine.h
+
+/** The ICU boolean type @stable ICU 2.0 */
+typedef int8_t UBool;
+
+/**
+ * Define UChar32 as a type for single Unicode code points.
+ * UChar32 is a signed 32-bit integer (same as int32_t).
+ *
+ * The Unicode code point range is 0..0x10ffff.
+ * All other values (negative or >=0x110000) are illegal as Unicode code points.
+ * They may be used as sentinel values to indicate "done", "error"
+ * or similar non-code point conditions.
+ *
+ * Before ICU 2.4 (Jitterbug 2146), UChar32 was defined
+ * to be wchar_t if that is 32 bits wide (wchar_t may be signed or unsigned)
+ * or else to be uint32_t.
+ * That is, the definition of UChar32 was platform-dependent.
+ *
+ * @see U_SENTINEL
+ * @stable ICU 2.4
+ */
+typedef int32_t UChar32;
+
+/**
+ * This value is intended for sentinel values for APIs that
+ * (take or) return single code points (UChar32).
+ * It is outside of the Unicode code point range 0..0x10ffff.
+ *
+ * For example, a "done" or "error" value in a new API
+ * could be indicated with U_SENTINEL.
+ *
+ * ICU APIs designed before ICU 2.4 usually define service-specific "done"
+ * values, mostly 0xffff.
+ * Those may need to be distinguished from
+ * actual U+ffff text contents by calling functions like
+ * CharacterIterator::hasNext() or UnicodeString::length().
+ *
+ * @return -1
+ * @see UChar32
+ * @stable ICU 2.4
+ */
+#define CBU_SENTINEL (-1)
+
+// source/common/unicode/utf.h
+
+/**
+ * Is this code point a Unicode noncharacter?
+ * @param c 32-bit code point
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define CBU_IS_UNICODE_NONCHAR(c) \
+    ((c)>=0xfdd0 && \
+     ((c)<=0xfdef || ((c)&0xfffe)==0xfffe) && (c)<=0x10ffff)
+
+/**
+ * Is c a Unicode code point value (0..U+10ffff)
+ * that can be assigned a character?
+ *
+ * Code points that are not characters include:
+ * - single surrogate code points (U+d800..U+dfff, 2048 code points)
+ * - the last two code points on each plane (U+__fffe and U+__ffff, 34 code points)
+ * - U+fdd0..U+fdef (new with Unicode 3.1, 32 code points)
+ * - the highest Unicode code point value is U+10ffff
+ *
+ * This means that all code points below U+d800 are character code points,
+ * and that boundary is tested first for performance.
+ *
+ * @param c 32-bit code point
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define CBU_IS_UNICODE_CHAR(c) \
+    ((uint32_t)(c)<0xd800 || \
+        (0xdfff<(c) && (c)<=0x10ffff && !CBU_IS_UNICODE_NONCHAR(c)))
+
+/**
+ * Is this code point a surrogate (U+d800..U+dfff)?
+ * @param c 32-bit code point
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define CBU_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800)
+
+/**
+ * Assuming c is a surrogate code point (U_IS_SURROGATE(c)),
+ * is it a lead surrogate?
+ * @param c 32-bit code point
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define CBU_IS_SURROGATE_LEAD(c) (((c)&0x400)==0)
+
+// source/common/unicode/utf8.h
+
+/**
+ * Internal bit vector for 3-byte UTF-8 validity check, for use in U8_IS_VALID_LEAD3_AND_T1.
+ * Each bit indicates whether one lead byte + first trail byte pair starts a valid sequence.
+ * Lead byte E0..EF bits 3..0 are used as byte index,
+ * first trail byte bits 7..5 are used as bit index into that byte.
+ * @see U8_IS_VALID_LEAD3_AND_T1
+ * @internal
+ */
+#define CBU8_LEAD3_T1_BITS "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30"
+
+/**
+ * Internal 3-byte UTF-8 validity check.
+ * Non-zero if lead byte E0..EF and first trail byte 00..FF start a valid sequence.
+ * @internal
+ */
+#define CBU8_IS_VALID_LEAD3_AND_T1(lead, t1) (CBU8_LEAD3_T1_BITS[(lead)&0xf]&(1<<((uint8_t)(t1)>>5)))
+
+/**
+ * Internal bit vector for 4-byte UTF-8 validity check, for use in U8_IS_VALID_LEAD4_AND_T1.
+ * Each bit indicates whether one lead byte + first trail byte pair starts a valid sequence.
+ * First trail byte bits 7..4 are used as byte index,
+ * lead byte F0..F4 bits 2..0 are used as bit index into that byte.
+ * @see U8_IS_VALID_LEAD4_AND_T1
+ * @internal
+ */
+#define CBU8_LEAD4_T1_BITS "\x00\x00\x00\x00\x00\x00\x00\x00\x1E\x0F\x0F\x0F\x00\x00\x00\x00"
+
+/**
+ * Internal 4-byte UTF-8 validity check.
+ * Non-zero if lead byte F0..F4 and first trail byte 00..FF start a valid sequence.
+ * @internal
+ */
+#define CBU8_IS_VALID_LEAD4_AND_T1(lead, t1) (CBU8_LEAD4_T1_BITS[(uint8_t)(t1)>>4]&(1<<((lead)&7)))
+
+/**
+ * Function for handling "next code point" with error-checking.
+ *
+ * This is internal since it is not meant to be called directly by external clie
+nts;
+ * however it is U_STABLE (not U_INTERNAL) since it is called by public macros i
+n this
+ * file and thus must remain stable, and should not be hidden when other interna
+l
+ * functions are hidden (otherwise public macros would fail to compile).
+ * @internal
+ */
+UChar32
+utf8_nextCharSafeBody(const uint8_t *s, int32_t *pi, int32_t length, ::base_icu::UChar32 c, ::base_icu::UBool strict);
+
+/**
+ * Does this code unit (byte) encode a code point by itself (US-ASCII 0..0x7f)?
+ * @param c 8-bit code unit (byte)
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define CBU8_IS_SINGLE(c) (((c)&0x80)==0)
+
+/**
+ * Is this code unit (byte) a UTF-8 lead byte? (0xC2..0xF4)
+ * @param c 8-bit code unit (byte)
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define CBU8_IS_LEAD(c) ((uint8_t)((c)-0xc2)<=0x32)
+
+/**
+ * Is this code unit (byte) a UTF-8 trail byte? (0x80..0xBF)
+ * @param c 8-bit code unit (byte)
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define CBU8_IS_TRAIL(c) ((int8_t)(c)<-0x40)
+
+/**
+ * How many code units (bytes) are used for the UTF-8 encoding
+ * of this Unicode code point?
+ * @param c 32-bit code point
+ * @return 1..4, or 0 if c is a surrogate or not a Unicode code point
+ * @stable ICU 2.4
+ */
+#define CBU8_LENGTH(c) \
+    ((uint32_t)(c)<=0x7f ? 1 : \
+        ((uint32_t)(c)<=0x7ff ? 2 : \
+            ((uint32_t)(c)<=0xd7ff ? 3 : \
+                ((uint32_t)(c)<=0xdfff || (uint32_t)(c)>0x10ffff ? 0 : \
+                    ((uint32_t)(c)<=0xffff ? 3 : 4)\
+                ) \
+            ) \
+        ) \
+    )
+
+/**
+ * The maximum number of UTF-8 code units (bytes) per Unicode code point (U+0000..U+10ffff).
+ * @return 4
+ * @stable ICU 2.4
+ */
+#define CBU8_MAX_LENGTH 4
+
+/**
+ * Get a code point from a string at a code point boundary offset,
+ * and advance the offset to the next code point boundary.
+ * (Post-incrementing forward iteration.)
+ * "Safe" macro, checks for illegal sequences and for string boundaries.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * The offset may point to the lead byte of a multi-byte sequence,
+ * in which case the macro will read the whole sequence.
+ * If the offset points to a trail byte or an illegal UTF-8 sequence, then
+ * c is set to a negative value.
+ *
+ * @param s const uint8_t * string
+ * @param i int32_t string offset, must be i<length
+ * @param length int32_t string length
+ * @param c output UChar32 variable, set to <0 in case of an error
+ * @see U8_NEXT_UNSAFE
+ * @stable ICU 2.4
+ */
+#define CBU8_NEXT(s, i, length, c) { \
+    (c)=(uint8_t)(s)[(i)++]; \
+    if(!CBU8_IS_SINGLE(c)) { \
+        uint8_t __t1, __t2; \
+        if( /* handle U+0800..U+FFFF inline */ \
+                (0xe0<=(c) && (c)<0xf0) && \
+                (((i)+1)<(length) || (length)<0) && \
+                CBU8_IS_VALID_LEAD3_AND_T1((c), __t1=(s)[i]) && \
+                (__t2=(s)[(i)+1]-0x80)<=0x3f) { \
+            (c)=(((c)&0xf)<<12)|((__t1&0x3f)<<6)|__t2; \
+            (i)+=2; \
+        } else if( /* handle U+0080..U+07FF inline */ \
+                ((c)<0xe0 && (c)>=0xc2) && \
+                ((i)!=(length)) && \
+                (__t1=(s)[i]-0x80)<=0x3f) { \
+            (c)=(((c)&0x1f)<<6)|__t1; \
+            ++(i); \
+        } else { \
+            /* function call for "complicated" and error cases */ \
+            (c)=::base_icu::utf8_nextCharSafeBody((const uint8_t *)s, &(i), (length), c, -1); \
+        } \
+    } \
+}
+
+/**
+ * Append a code point to a string, overwriting 1 to 4 bytes.
+ * The offset points to the current end of the string contents
+ * and is advanced (post-increment).
+ * "Unsafe" macro, assumes a valid code point and sufficient space in the string.
+ * Otherwise, the result is undefined.
+ *
+ * @param s const uint8_t * string buffer
+ * @param i string offset
+ * @param c code point to append
+ * @see U8_APPEND
+ * @stable ICU 2.4
+ */
+#define CBU8_APPEND_UNSAFE(s, i, c) { \
+    if((uint32_t)(c)<=0x7f) { \
+        (s)[(i)++]=(uint8_t)(c); \
+    } else { \
+        if((uint32_t)(c)<=0x7ff) { \
+            (s)[(i)++]=(uint8_t)(((c)>>6)|0xc0); \
+        } else { \
+            if((uint32_t)(c)<=0xffff) { \
+                (s)[(i)++]=(uint8_t)(((c)>>12)|0xe0); \
+            } else { \
+                (s)[(i)++]=(uint8_t)(((c)>>18)|0xf0); \
+                (s)[(i)++]=(uint8_t)((((c)>>12)&0x3f)|0x80); \
+            } \
+            (s)[(i)++]=(uint8_t)((((c)>>6)&0x3f)|0x80); \
+        } \
+        (s)[(i)++]=(uint8_t)(((c)&0x3f)|0x80); \
+    } \
+}
+
+// source/common/unicode/utf16.h
+
+/**
+ * Does this code unit alone encode a code point (BMP, not a surrogate)?
+ * @param c 16-bit code unit
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define CBU16_IS_SINGLE(c) !CBU_IS_SURROGATE(c)
+
+/**
+ * Is this code unit a lead surrogate (U+d800..U+dbff)?
+ * @param c 16-bit code unit
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define CBU16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800)
+
+/**
+ * Is this code unit a trail surrogate (U+dc00..U+dfff)?
+ * @param c 16-bit code unit
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define CBU16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00)
+
+/**
+ * Is this code unit a surrogate (U+d800..U+dfff)?
+ * @param c 16-bit code unit
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define CBU16_IS_SURROGATE(c) CBU_IS_SURROGATE(c)
+
+/**
+ * Assuming c is a surrogate code point (U16_IS_SURROGATE(c)),
+ * is it a lead surrogate?
+ * @param c 16-bit code unit
+ * @return TRUE or FALSE
+ * @stable ICU 2.4
+ */
+#define CBU16_IS_SURROGATE_LEAD(c) (((c)&0x400)==0)
+
+/**
+ * Helper constant for U16_GET_SUPPLEMENTARY.
+ * @internal
+ */
+#define CBU16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000)
+
+/**
+ * Get a supplementary code point value (U+10000..U+10ffff)
+ * from its lead and trail surrogates.
+ * The result is undefined if the input values are not
+ * lead and trail surrogates.
+ *
+ * @param lead lead surrogate (U+d800..U+dbff)
+ * @param trail trail surrogate (U+dc00..U+dfff)
+ * @return supplementary code point (U+10000..U+10ffff)
+ * @stable ICU 2.4
+ */
+#define CBU16_GET_SUPPLEMENTARY(lead, trail) \
+    (((::base_icu::UChar32)(lead)<<10UL)+(::base_icu::UChar32)(trail)-CBU16_SURROGATE_OFFSET)
+
+/**
+ * Get the lead surrogate (0xd800..0xdbff) for a
+ * supplementary code point (0x10000..0x10ffff).
+ * @param supplementary 32-bit code point (U+10000..U+10ffff)
+ * @return lead surrogate (U+d800..U+dbff) for supplementary
+ * @stable ICU 2.4
+ */
+#define CBU16_LEAD(supplementary) (::base_icu::UChar)(((supplementary)>>10)+0xd7c0)
+
+/**
+ * Get the trail surrogate (0xdc00..0xdfff) for a
+ * supplementary code point (0x10000..0x10ffff).
+ * @param supplementary 32-bit code point (U+10000..U+10ffff)
+ * @return trail surrogate (U+dc00..U+dfff) for supplementary
+ * @stable ICU 2.4
+ */
+#define CBU16_TRAIL(supplementary) (::base_icu::UChar)(((supplementary)&0x3ff)|0xdc00)
+
+/**
+ * How many 16-bit code units are used to encode this Unicode code point? (1 or 2)
+ * The result is not defined if c is not a Unicode code point (U+0000..U+10ffff).
+ * @param c 32-bit code point
+ * @return 1 or 2
+ * @stable ICU 2.4
+ */
+#define CBU16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2)
+
+/**
+ * The maximum number of 16-bit code units per Unicode code point (U+0000..U+10ffff).
+ * @return 2
+ * @stable ICU 2.4
+ */
+#define CBU16_MAX_LENGTH 2
+
+/**
+ * Get a code point from a string at a code point boundary offset,
+ * and advance the offset to the next code point boundary.
+ * (Post-incrementing forward iteration.)
+ * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
+ *
+ * The length can be negative for a NUL-terminated string.
+ *
+ * The offset may point to the lead surrogate unit
+ * for a supplementary code point, in which case the macro will read
+ * the following trail surrogate as well.
+ * If the offset points to a trail surrogate or
+ * to a single, unpaired lead surrogate, then c is set to that unpaired surrogate.
+ *
+ * @param s const UChar * string
+ * @param i string offset, must be i<length
+ * @param length string length
+ * @param c output UChar32 variable
+ * @see U16_NEXT_UNSAFE
+ * @stable ICU 2.4
+ */
+#define CBU16_NEXT(s, i, length, c) { \
+    (c)=(s)[(i)++]; \
+    if(CBU16_IS_LEAD(c)) { \
+        uint16_t __c2; \
+        if((i)!=(length) && CBU16_IS_TRAIL(__c2=(s)[(i)])) { \
+            ++(i); \
+            (c)=CBU16_GET_SUPPLEMENTARY((c), __c2); \
+        } \
+    } \
+}
+
+/**
+ * Append a code point to a string, overwriting 1 or 2 code units.
+ * The offset points to the current end of the string contents
+ * and is advanced (post-increment).
+ * "Unsafe" macro, assumes a valid code point and sufficient space in the string.
+ * Otherwise, the result is undefined.
+ *
+ * @param s const UChar * string buffer
+ * @param i string offset
+ * @param c code point to append
+ * @see U16_APPEND
+ * @stable ICU 2.4
+ */
+#define CBU16_APPEND_UNSAFE(s, i, c) { \
+    if((uint32_t)(c)<=0xffff) { \
+        (s)[(i)++]=(uint16_t)(c); \
+    } else { \
+        (s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \
+        (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \
+    } \
+}
+
+}  // namesapce base_icu
+
+#endif  // BASE_THIRD_PARTY_ICU_ICU_UTF_H_
diff --git a/native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE b/native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE
new file mode 100644
index 0000000..eba7b77
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE
@@ -0,0 +1,35 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is the Netscape Portable Runtime (NSPR).
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1998-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
diff --git a/native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt b/native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
new file mode 100644
index 0000000..5669081
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
@@ -0,0 +1,469 @@
+                          MOZILLA PUBLIC LICENSE
+                                Version 1.1
+
+                              ---------------
+
+1. Definitions.
+
+     1.0.1. "Commercial Use" means distribution or otherwise making the
+     Covered Code available to a third party.
+
+     1.1. "Contributor" means each entity that creates or contributes to
+     the creation of Modifications.
+
+     1.2. "Contributor Version" means the combination of the Original
+     Code, prior Modifications used by a Contributor, and the Modifications
+     made by that particular Contributor.
+
+     1.3. "Covered Code" means the Original Code or Modifications or the
+     combination of the Original Code and Modifications, in each case
+     including portions thereof.
+
+     1.4. "Electronic Distribution Mechanism" means a mechanism generally
+     accepted in the software development community for the electronic
+     transfer of data.
+
+     1.5. "Executable" means Covered Code in any form other than Source
+     Code.
+
+     1.6. "Initial Developer" means the individual or entity identified
+     as the Initial Developer in the Source Code notice required by Exhibit
+     A.
+
+     1.7. "Larger Work" means a work which combines Covered Code or
+     portions thereof with code not governed by the terms of this License.
+
+     1.8. "License" means this document.
+
+     1.8.1. "Licensable" means having the right to grant, to the maximum
+     extent possible, whether at the time of the initial grant or
+     subsequently acquired, any and all of the rights conveyed herein.
+
+     1.9. "Modifications" means any addition to or deletion from the
+     substance or structure of either the Original Code or any previous
+     Modifications. When Covered Code is released as a series of files, a
+     Modification is:
+          A. Any addition to or deletion from the contents of a file
+          containing Original Code or previous Modifications.
+
+          B. Any new file that contains any part of the Original Code or
+          previous Modifications.
+
+     1.10. "Original Code" means Source Code of computer software code
+     which is described in the Source Code notice required by Exhibit A as
+     Original Code, and which, at the time of its release under this
+     License is not already Covered Code governed by this License.
+
+     1.10.1. "Patent Claims" means any patent claim(s), now owned or
+     hereafter acquired, including without limitation,  method, process,
+     and apparatus claims, in any patent Licensable by grantor.
+
+     1.11. "Source Code" means the preferred form of the Covered Code for
+     making modifications to it, including all modules it contains, plus
+     any associated interface definition files, scripts used to control
+     compilation and installation of an Executable, or source code
+     differential comparisons against either the Original Code or another
+     well known, available Covered Code of the Contributor's choice. The
+     Source Code can be in a compressed or archival form, provided the
+     appropriate decompression or de-archiving software is widely available
+     for no charge.
+
+     1.12. "You" (or "Your")  means an individual or a legal entity
+     exercising rights under, and complying with all of the terms of, this
+     License or a future version of this License issued under Section 6.1.
+     For legal entities, "You" includes any entity which controls, is
+     controlled by, or is under common control with You. For purposes of
+     this definition, "control" means (a) the power, direct or indirect,
+     to cause the direction or management of such entity, whether by
+     contract or otherwise, or (b) ownership of more than fifty percent
+     (50%) of the outstanding shares or beneficial ownership of such
+     entity.
+
+2. Source Code License.
+
+     2.1. The Initial Developer Grant.
+     The Initial Developer hereby grants You a world-wide, royalty-free,
+     non-exclusive license, subject to third party intellectual property
+     claims:
+          (a)  under intellectual property rights (other than patent or
+          trademark) Licensable by Initial Developer to use, reproduce,
+          modify, display, perform, sublicense and distribute the Original
+          Code (or portions thereof) with or without Modifications, and/or
+          as part of a Larger Work; and
+
+          (b) under Patents Claims infringed by the making, using or
+          selling of Original Code, to make, have made, use, practice,
+          sell, and offer for sale, and/or otherwise dispose of the
+          Original Code (or portions thereof).
+
+          (c) the licenses granted in this Section 2.1(a) and (b) are
+          effective on the date Initial Developer first distributes
+          Original Code under the terms of this License.
+
+          (d) Notwithstanding Section 2.1(b) above, no patent license is
+          granted: 1) for code that You delete from the Original Code; 2)
+          separate from the Original Code;  or 3) for infringements caused
+          by: i) the modification of the Original Code or ii) the
+          combination of the Original Code with other software or devices.
+
+     2.2. Contributor Grant.
+     Subject to third party intellectual property claims, each Contributor
+     hereby grants You a world-wide, royalty-free, non-exclusive license
+
+          (a)  under intellectual property rights (other than patent or
+          trademark) Licensable by Contributor, to use, reproduce, modify,
+          display, perform, sublicense and distribute the Modifications
+          created by such Contributor (or portions thereof) either on an
+          unmodified basis, with other Modifications, as Covered Code
+          and/or as part of a Larger Work; and
+
+          (b) under Patent Claims infringed by the making, using, or
+          selling of  Modifications made by that Contributor either alone
+          and/or in combination with its Contributor Version (or portions
+          of such combination), to make, use, sell, offer for sale, have
+          made, and/or otherwise dispose of: 1) Modifications made by that
+          Contributor (or portions thereof); and 2) the combination of
+          Modifications made by that Contributor with its Contributor
+          Version (or portions of such combination).
+
+          (c) the licenses granted in Sections 2.2(a) and 2.2(b) are
+          effective on the date Contributor first makes Commercial Use of
+          the Covered Code.
+
+          (d)    Notwithstanding Section 2.2(b) above, no patent license is
+          granted: 1) for any code that Contributor has deleted from the
+          Contributor Version; 2)  separate from the Contributor Version;
+          3)  for infringements caused by: i) third party modifications of
+          Contributor Version or ii)  the combination of Modifications made
+          by that Contributor with other software  (except as part of the
+          Contributor Version) or other devices; or 4) under Patent Claims
+          infringed by Covered Code in the absence of Modifications made by
+          that Contributor.
+
+3. Distribution Obligations.
+
+     3.1. Application of License.
+     The Modifications which You create or to which You contribute are
+     governed by the terms of this License, including without limitation
+     Section 2.2. The Source Code version of Covered Code may be
+     distributed only under the terms of this License or a future version
+     of this License released under Section 6.1, and You must include a
+     copy of this License with every copy of the Source Code You
+     distribute. You may not offer or impose any terms on any Source Code
+     version that alters or restricts the applicable version of this
+     License or the recipients' rights hereunder. However, You may include
+     an additional document offering the additional rights described in
+     Section 3.5.
+
+     3.2. Availability of Source Code.
+     Any Modification which You create or to which You contribute must be
+     made available in Source Code form under the terms of this License
+     either on the same media as an Executable version or via an accepted
+     Electronic Distribution Mechanism to anyone to whom you made an
+     Executable version available; and if made available via Electronic
+     Distribution Mechanism, must remain available for at least twelve (12)
+     months after the date it initially became available, or at least six
+     (6) months after a subsequent version of that particular Modification
+     has been made available to such recipients. You are responsible for
+     ensuring that the Source Code version remains available even if the
+     Electronic Distribution Mechanism is maintained by a third party.
+
+     3.3. Description of Modifications.
+     You must cause all Covered Code to which You contribute to contain a
+     file documenting the changes You made to create that Covered Code and
+     the date of any change. You must include a prominent statement that
+     the Modification is derived, directly or indirectly, from Original
+     Code provided by the Initial Developer and including the name of the
+     Initial Developer in (a) the Source Code, and (b) in any notice in an
+     Executable version or related documentation in which You describe the
+     origin or ownership of the Covered Code.
+
+     3.4. Intellectual Property Matters
+          (a) Third Party Claims.
+          If Contributor has knowledge that a license under a third party's
+          intellectual property rights is required to exercise the rights
+          granted by such Contributor under Sections 2.1 or 2.2,
+          Contributor must include a text file with the Source Code
+          distribution titled "LEGAL" which describes the claim and the
+          party making the claim in sufficient detail that a recipient will
+          know whom to contact. If Contributor obtains such knowledge after
+          the Modification is made available as described in Section 3.2,
+          Contributor shall promptly modify the LEGAL file in all copies
+          Contributor makes available thereafter and shall take other steps
+          (such as notifying appropriate mailing lists or newsgroups)
+          reasonably calculated to inform those who received the Covered
+          Code that new knowledge has been obtained.
+
+          (b) Contributor APIs.
+          If Contributor's Modifications include an application programming
+          interface and Contributor has knowledge of patent licenses which
+          are reasonably necessary to implement that API, Contributor must
+          also include this information in the LEGAL file.
+
+               (c)    Representations.
+          Contributor represents that, except as disclosed pursuant to
+          Section 3.4(a) above, Contributor believes that Contributor's
+          Modifications are Contributor's original creation(s) and/or
+          Contributor has sufficient rights to grant the rights conveyed by
+          this License.
+
+     3.5. Required Notices.
+     You must duplicate the notice in Exhibit A in each file of the Source
+     Code.  If it is not possible to put such notice in a particular Source
+     Code file due to its structure, then You must include such notice in a
+     location (such as a relevant directory) where a user would be likely
+     to look for such a notice.  If You created one or more Modification(s)
+     You may add your name as a Contributor to the notice described in
+     Exhibit A.  You must also duplicate this License in any documentation
+     for the Source Code where You describe recipients' rights or ownership
+     rights relating to Covered Code.  You may choose to offer, and to
+     charge a fee for, warranty, support, indemnity or liability
+     obligations to one or more recipients of Covered Code. However, You
+     may do so only on Your own behalf, and not on behalf of the Initial
+     Developer or any Contributor. You must make it absolutely clear than
+     any such warranty, support, indemnity or liability obligation is
+     offered by You alone, and You hereby agree to indemnify the Initial
+     Developer and every Contributor for any liability incurred by the
+     Initial Developer or such Contributor as a result of warranty,
+     support, indemnity or liability terms You offer.
+
+     3.6. Distribution of Executable Versions.
+     You may distribute Covered Code in Executable form only if the
+     requirements of Section 3.1-3.5 have been met for that Covered Code,
+     and if You include a notice stating that the Source Code version of
+     the Covered Code is available under the terms of this License,
+     including a description of how and where You have fulfilled the
+     obligations of Section 3.2. The notice must be conspicuously included
+     in any notice in an Executable version, related documentation or
+     collateral in which You describe recipients' rights relating to the
+     Covered Code. You may distribute the Executable version of Covered
+     Code or ownership rights under a license of Your choice, which may
+     contain terms different from this License, provided that You are in
+     compliance with the terms of this License and that the license for the
+     Executable version does not attempt to limit or alter the recipient's
+     rights in the Source Code version from the rights set forth in this
+     License. If You distribute the Executable version under a different
+     license You must make it absolutely clear that any terms which differ
+     from this License are offered by You alone, not by the Initial
+     Developer or any Contributor. You hereby agree to indemnify the
+     Initial Developer and every Contributor for any liability incurred by
+     the Initial Developer or such Contributor as a result of any such
+     terms You offer.
+
+     3.7. Larger Works.
+     You may create a Larger Work by combining Covered Code with other code
+     not governed by the terms of this License and distribute the Larger
+     Work as a single product. In such a case, You must make sure the
+     requirements of this License are fulfilled for the Covered Code.
+
+4. Inability to Comply Due to Statute or Regulation.
+
+     If it is impossible for You to comply with any of the terms of this
+     License with respect to some or all of the Covered Code due to
+     statute, judicial order, or regulation then You must: (a) comply with
+     the terms of this License to the maximum extent possible; and (b)
+     describe the limitations and the code they affect. Such description
+     must be included in the LEGAL file described in Section 3.4 and must
+     be included with all distributions of the Source Code. Except to the
+     extent prohibited by statute or regulation, such description must be
+     sufficiently detailed for a recipient of ordinary skill to be able to
+     understand it.
+
+5. Application of this License.
+
+     This License applies to code to which the Initial Developer has
+     attached the notice in Exhibit A and to related Covered Code.
+
+6. Versions of the License.
+
+     6.1. New Versions.
+     Netscape Communications Corporation ("Netscape") may publish revised
+     and/or new versions of the License from time to time. Each version
+     will be given a distinguishing version number.
+
+     6.2. Effect of New Versions.
+     Once Covered Code has been published under a particular version of the
+     License, You may always continue to use it under the terms of that
+     version. You may also choose to use such Covered Code under the terms
+     of any subsequent version of the License published by Netscape. No one
+     other than Netscape has the right to modify the terms applicable to
+     Covered Code created under this License.
+
+     6.3. Derivative Works.
+     If You create or use a modified version of this License (which you may
+     only do in order to apply it to code which is not already Covered Code
+     governed by this License), You must (a) rename Your license so that
+     the phrases "Mozilla", "MOZILLAPL", "MOZPL", "Netscape",
+     "MPL", "NPL" or any confusingly similar phrase do not appear in your
+     license (except to note that your license differs from this License)
+     and (b) otherwise make it clear that Your version of the license
+     contains terms which differ from the Mozilla Public License and
+     Netscape Public License. (Filling in the name of the Initial
+     Developer, Original Code or Contributor in the notice described in
+     Exhibit A shall not of themselves be deemed to be modifications of
+     this License.)
+
+7. DISCLAIMER OF WARRANTY.
+
+     COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS,
+     WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
+     WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF
+     DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING.
+     THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE
+     IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT,
+     YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE
+     COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER
+     OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF
+     ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
+
+8. TERMINATION.
+
+     8.1.  This License and the rights granted hereunder will terminate
+     automatically if You fail to comply with terms herein and fail to cure
+     such breach within 30 days of becoming aware of the breach. All
+     sublicenses to the Covered Code which are properly granted shall
+     survive any termination of this License. Provisions which, by their
+     nature, must remain in effect beyond the termination of this License
+     shall survive.
+
+     8.2.  If You initiate litigation by asserting a patent infringement
+     claim (excluding declatory judgment actions) against Initial Developer
+     or a Contributor (the Initial Developer or Contributor against whom
+     You file such action is referred to as "Participant")  alleging that:
+
+     (a)  such Participant's Contributor Version directly or indirectly
+     infringes any patent, then any and all rights granted by such
+     Participant to You under Sections 2.1 and/or 2.2 of this License
+     shall, upon 60 days notice from Participant terminate prospectively,
+     unless if within 60 days after receipt of notice You either: (i)
+     agree in writing to pay Participant a mutually agreeable reasonable
+     royalty for Your past and future use of Modifications made by such
+     Participant, or (ii) withdraw Your litigation claim with respect to
+     the Contributor Version against such Participant.  If within 60 days
+     of notice, a reasonable royalty and payment arrangement are not
+     mutually agreed upon in writing by the parties or the litigation claim
+     is not withdrawn, the rights granted by Participant to You under
+     Sections 2.1 and/or 2.2 automatically terminate at the expiration of
+     the 60 day notice period specified above.
+
+     (b)  any software, hardware, or device, other than such Participant's
+     Contributor Version, directly or indirectly infringes any patent, then
+     any rights granted to You by such Participant under Sections 2.1(b)
+     and 2.2(b) are revoked effective as of the date You first made, used,
+     sold, distributed, or had made, Modifications made by that
+     Participant.
+
+     8.3.  If You assert a patent infringement claim against Participant
+     alleging that such Participant's Contributor Version directly or
+     indirectly infringes any patent where such claim is resolved (such as
+     by license or settlement) prior to the initiation of patent
+     infringement litigation, then the reasonable value of the licenses
+     granted by such Participant under Sections 2.1 or 2.2 shall be taken
+     into account in determining the amount or value of any payment or
+     license.
+
+     8.4.  In the event of termination under Sections 8.1 or 8.2 above,
+     all end user license agreements (excluding distributors and resellers)
+     which have been validly granted by You or any distributor hereunder
+     prior to termination shall survive termination.
+
+9. LIMITATION OF LIABILITY.
+
+     UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT
+     (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL
+     DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE,
+     OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR
+     ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY
+     CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL,
+     WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER
+     COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN
+     INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF
+     LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY
+     RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW
+     PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE
+     EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO
+     THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.
+
+10. U.S. GOVERNMENT END USERS.
+
+     The Covered Code is a "commercial item," as that term is defined in
+     48 C.F.R. 2.101 (Oct. 1995), consisting of "commercial computer
+     software" and "commercial computer software documentation," as such
+     terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48
+     C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995),
+     all U.S. Government End Users acquire Covered Code with only those
+     rights set forth herein.
+
+11. MISCELLANEOUS.
+
+     This License represents the complete agreement concerning subject
+     matter hereof. If any provision of this License is held to be
+     unenforceable, such provision shall be reformed only to the extent
+     necessary to make it enforceable. This License shall be governed by
+     California law provisions (except to the extent applicable law, if
+     any, provides otherwise), excluding its conflict-of-law provisions.
+     With respect to disputes in which at least one party is a citizen of,
+     or an entity chartered or registered to do business in the United
+     States of America, any litigation relating to this License shall be
+     subject to the jurisdiction of the Federal Courts of the Northern
+     District of California, with venue lying in Santa Clara County,
+     California, with the losing party responsible for costs, including
+     without limitation, court costs and reasonable attorneys' fees and
+     expenses. The application of the United Nations Convention on
+     Contracts for the International Sale of Goods is expressly excluded.
+     Any law or regulation which provides that the language of a contract
+     shall be construed against the drafter shall not apply to this
+     License.
+
+12. RESPONSIBILITY FOR CLAIMS.
+
+     As between Initial Developer and the Contributors, each party is
+     responsible for claims and damages arising, directly or indirectly,
+     out of its utilization of rights under this License and You agree to
+     work with Initial Developer and Contributors to distribute such
+     responsibility on an equitable basis. Nothing herein is intended or
+     shall be deemed to constitute any admission of liability.
+
+13. MULTIPLE-LICENSED CODE.
+
+     Initial Developer may designate portions of the Covered Code as
+     "Multiple-Licensed".  "Multiple-Licensed" means that the Initial
+     Developer permits you to utilize portions of the Covered Code under
+     Your choice of the MPL or the alternative licenses, if any, specified
+     by the Initial Developer in the file described in Exhibit A.
+
+EXHIBIT A -Mozilla Public License.
+
+     ``The contents of this file are subject to the Mozilla Public License
+     Version 1.1 (the "License"); you may not use this file except in
+     compliance with the License. You may obtain a copy of the License at
+     https://www.mozilla.org/MPL/
+
+     Software distributed under the License is distributed on an "AS IS"
+     basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+     License for the specific language governing rights and limitations
+     under the License.
+
+     The Original Code is ______________________________________.
+
+     The Initial Developer of the Original Code is ________________________.
+     Portions created by ______________________ are Copyright (C) ______
+     _______________________. All Rights Reserved.
+
+     Contributor(s): ______________________________________.
+
+     Alternatively, the contents of this file may be used under the terms
+     of the _____ license (the  "[___] License"), in which case the
+     provisions of [______] License are applicable instead of those
+     above.  If you wish to allow use of your version of this file only
+     under the terms of the [____] License and not to allow others to use
+     your version of this file under the MPL, indicate your decision by
+     deleting  the provisions above and replace  them with the notice and
+     other provisions required by the [___] License.  If you do not delete
+     the provisions above, a recipient may use your version of this file
+     under either the MPL or the [___] License."
+
+     [NOTE: The text of this Exhibit A may differ slightly from the text of
+     the notices in the Source Code files of the Original Code. You should
+     use the text of this Exhibit A rather than the text found in the
+     Original Code Source Code for Your Modifications.]
diff --git a/native/zucchini/vendor/libchrome/base/third_party/nspr/prtime.h b/native/zucchini/vendor/libchrome/base/third_party/nspr/prtime.h
new file mode 100644
index 0000000..20bae38
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/third_party/nspr/prtime.h
@@ -0,0 +1,263 @@
+/* Portions are Copyright (C) 2011 Google Inc */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is the Netscape Portable Runtime (NSPR).
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1998-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * prtime.h --
+ *
+ *     NSPR date and time functions
+ * CVS revision 3.10
+ * This file contains definitions of NSPR's basic types required by
+ * prtime.cc. These types have been copied over from the following NSPR
+ * files prtime.h, prtypes.h(CVS revision 3.35), prlong.h(CVS revision 3.13)
+ *
+ *---------------------------------------------------------------------------
+ */
+
+#ifndef BASE_PRTIME_H__
+#define BASE_PRTIME_H__
+
+#include <stdint.h>
+
+#include "base/base_export.h"
+
+typedef int8_t PRInt8;
+typedef int16_t PRInt16;
+typedef int32_t PRInt32;
+typedef int64_t PRInt64;
+typedef int PRIntn;
+
+typedef PRIntn PRBool;
+#define PR_TRUE 1
+#define PR_FALSE 0
+
+typedef enum { PR_FAILURE = -1, PR_SUCCESS = 0 } PRStatus;
+
+#define PR_ASSERT DCHECK
+#define PR_CALLBACK
+#define PR_INT16_MAX 32767
+#define NSPR_API(__type) extern __type
+
+/*
+ * Long-long (64-bit signed integer type) support macros used by
+ * PR_ImplodeTime().
+ * See http://lxr.mozilla.org/nspr/source/pr/include/prlong.h
+ */
+
+#define LL_I2L(l, i) ((l) = (PRInt64)(i))
+#define LL_MUL(r, a, b) ((r) = (a) * (b))
+#define LL_ADD(r, a, b) ((r) = (a) + (b))
+#define LL_SUB(r, a, b) ((r) = (a) - (b))
+
+/**********************************************************************/
+/************************* TYPES AND CONSTANTS ************************/
+/**********************************************************************/
+
+#define PR_MSEC_PER_SEC		1000UL
+#define PR_USEC_PER_SEC		1000000UL
+#define PR_NSEC_PER_SEC		1000000000UL
+#define PR_USEC_PER_MSEC	1000UL
+#define PR_NSEC_PER_MSEC	1000000UL
+
+/*
+ * PRTime --
+ *
+ *     NSPR represents basic time as 64-bit signed integers relative
+ *     to midnight (00:00:00), January 1, 1970 Greenwich Mean Time (GMT).
+ *     (GMT is also known as Coordinated Universal Time, UTC.)
+ *     The units of time are in microseconds. Negative times are allowed
+ *     to represent times prior to the January 1970 epoch. Such values are
+ *     intended to be exported to other systems or converted to human
+ *     readable form.
+ *
+ *     Notes on porting: PRTime corresponds to time_t in ANSI C.  NSPR 1.0
+ *     simply uses PRInt64.
+ */
+
+typedef PRInt64 PRTime;
+
+/*
+ * Time zone and daylight saving time corrections applied to GMT to
+ * obtain the local time of some geographic location
+ */
+
+typedef struct PRTimeParameters {
+    PRInt32 tp_gmt_offset;     /* the offset from GMT in seconds */
+    PRInt32 tp_dst_offset;     /* contribution of DST in seconds */
+} PRTimeParameters;
+
+/*
+ * PRExplodedTime --
+ *
+ *     Time broken down into human-readable components such as year, month,
+ *     day, hour, minute, second, and microsecond.  Time zone and daylight
+ *     saving time corrections may be applied.  If they are applied, the
+ *     offsets from the GMT must be saved in the 'tm_params' field so that
+ *     all the information is available to reconstruct GMT.
+ *
+ *     Notes on porting: PRExplodedTime corrresponds to struct tm in
+ *     ANSI C, with the following differences:
+ *       - an additional field tm_usec;
+ *       - replacing tm_isdst by tm_params;
+ *       - the month field is spelled tm_month, not tm_mon;
+ *       - we use absolute year, AD, not the year since 1900.
+ *     The corresponding type in NSPR 1.0 is called PRTime.  Below is
+ *     a table of date/time type correspondence in the three APIs:
+ *         API          time since epoch          time in components
+ *       ANSI C             time_t                  struct tm
+ *       NSPR 1.0           PRInt64                   PRTime
+ *       NSPR 2.0           PRTime                  PRExplodedTime
+ */
+
+typedef struct PRExplodedTime {
+    PRInt32 tm_usec;		    /* microseconds past tm_sec (0-99999)  */
+    PRInt32 tm_sec;             /* seconds past tm_min (0-61, accomodating
+                                   up to two leap seconds) */	
+    PRInt32 tm_min;             /* minutes past tm_hour (0-59) */
+    PRInt32 tm_hour;            /* hours past tm_day (0-23) */
+    PRInt32 tm_mday;            /* days past tm_mon (1-31, note that it
+				                starts from 1) */
+    PRInt32 tm_month;           /* months past tm_year (0-11, Jan = 0) */
+    PRInt16 tm_year;            /* absolute year, AD (note that we do not
+				                count from 1900) */
+
+    PRInt8 tm_wday;		        /* calculated day of the week
+				                (0-6, Sun = 0) */
+    PRInt16 tm_yday;            /* calculated day of the year
+				                (0-365, Jan 1 = 0) */
+
+    PRTimeParameters tm_params;  /* time parameters used by conversion */
+} PRExplodedTime;
+
+/*
+ * PRTimeParamFn --
+ *
+ *     A function of PRTimeParamFn type returns the time zone and
+ *     daylight saving time corrections for some geographic location,
+ *     given the current time in GMT.  The input argument gmt should
+ *     point to a PRExplodedTime that is in GMT, i.e., whose
+ *     tm_params contains all 0's.
+ *
+ *     For any time zone other than GMT, the computation is intended to
+ *     consist of two steps:
+ *       - Figure out the time zone correction, tp_gmt_offset.  This number
+ *         usually depends on the geographic location only.  But it may
+ *         also depend on the current time.  For example, all of China
+ *         is one time zone right now.  But this situation may change
+ *         in the future.
+ *       - Figure out the daylight saving time correction, tp_dst_offset.
+ *         This number depends on both the geographic location and the
+ *         current time.  Most of the DST rules are expressed in local
+ *         current time.  If so, one should apply the time zone correction
+ *         to GMT before applying the DST rules.
+ */
+
+typedef PRTimeParameters (PR_CALLBACK *PRTimeParamFn)(const PRExplodedTime *gmt);
+
+/**********************************************************************/
+/****************************** FUNCTIONS *****************************/
+/**********************************************************************/
+
+NSPR_API(PRTime)
+PR_ImplodeTime(const PRExplodedTime *exploded);
+
+/*
+ * Adjust exploded time to normalize field overflows after manipulation.
+ * Note that the following fields of PRExplodedTime should not be
+ * manipulated:
+ *   - tm_month and tm_year: because the number of days in a month and
+ *     number of days in a year are not constant, it is ambiguous to
+ *     manipulate the month and year fields, although one may be tempted
+ *     to.  For example, what does "a month from January 31st" mean?
+ *   - tm_wday and tm_yday: these fields are calculated by NSPR.  Users
+ *     should treat them as "read-only".
+ */
+
+NSPR_API(void) PR_NormalizeTime(
+    PRExplodedTime *exploded, PRTimeParamFn params);
+
+/**********************************************************************/
+/*********************** TIME PARAMETER FUNCTIONS *********************/
+/**********************************************************************/
+
+/* Time parameters that represent Greenwich Mean Time */
+NSPR_API(PRTimeParameters) PR_GMTParameters(const PRExplodedTime *gmt);
+
+/*
+ * This parses a time/date string into a PRTime
+ * (microseconds after "1-Jan-1970 00:00:00 GMT").
+ * It returns PR_SUCCESS on success, and PR_FAILURE
+ * if the time/date string can't be parsed.
+ *
+ * Many formats are handled, including:
+ *
+ *   14 Apr 89 03:20:12
+ *   14 Apr 89 03:20 GMT
+ *   Fri, 17 Mar 89 4:01:33
+ *   Fri, 17 Mar 89 4:01 GMT
+ *   Mon Jan 16 16:12 PDT 1989
+ *   Mon Jan 16 16:12 +0130 1989
+ *   6 May 1992 16:41-JST (Wednesday)
+ *   22-AUG-1993 10:59:12.82
+ *   22-AUG-1993 10:59pm
+ *   22-AUG-1993 12:59am
+ *   22-AUG-1993 12:59 PM
+ *   Friday, August 04, 1995 3:54 PM
+ *   06/21/95 04:24:34 PM
+ *   20/06/95 21:07
+ *   95-06-08 19:32:48 EDT
+ *   1995-06-17T23:11:25.342156Z
+ *
+ * If the input string doesn't contain a description of the timezone,
+ * we consult the `default_to_gmt' to decide whether the string should
+ * be interpreted relative to the local time zone (PR_FALSE) or GMT (PR_TRUE).
+ * The correct value for this argument depends on what standard specified
+ * the time string which you are parsing.
+ */
+
+/*
+ * This is the only funtion that should be called from outside base, and only
+ * from the unit test.
+ */
+
+BASE_EXPORT PRStatus PR_ParseTimeString (
+	const char *string,
+	PRBool default_to_gmt,
+	PRTime *result);
+
+#endif  // BASE_PRTIME_H__
diff --git a/native/zucchini/vendor/libchrome/base/threading/platform_thread.h b/native/zucchini/vendor/libchrome/base/threading/platform_thread.h
new file mode 100644
index 0000000..faeb858
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/threading/platform_thread.h
@@ -0,0 +1,240 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// WARNING: You should *NOT* be using this class directly.  PlatformThread is
+// the low-level platform-specific abstraction to the OS's threading interface.
+// You should instead be using a message-loop driven Thread, see thread.h.
+
+#ifndef BASE_THREADING_PLATFORM_THREAD_H_
+#define BASE_THREADING_PLATFORM_THREAD_H_
+
+#include <stddef.h>
+
+#include "base/base_export.h"
+#include "base/macros.h"
+#include "base/time/time.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include "base/win/windows_types.h"
+#elif defined(OS_FUCHSIA)
+#include <zircon/types.h>
+#elif defined(OS_MACOSX)
+#include <mach/mach_types.h>
+#elif defined(OS_POSIX)
+#include <pthread.h>
+#include <unistd.h>
+#endif
+
+namespace base {
+
+// Used for logging. Always an integer value.
+#if defined(OS_WIN)
+typedef DWORD PlatformThreadId;
+#elif defined(OS_FUCHSIA)
+typedef zx_handle_t PlatformThreadId;
+#elif defined(OS_MACOSX)
+typedef mach_port_t PlatformThreadId;
+#elif defined(OS_POSIX)
+typedef pid_t PlatformThreadId;
+#endif
+
+// Used for thread checking and debugging.
+// Meant to be as fast as possible.
+// These are produced by PlatformThread::CurrentRef(), and used to later
+// check if we are on the same thread or not by using ==. These are safe
+// to copy between threads, but can't be copied to another process as they
+// have no meaning there. Also, the internal identifier can be re-used
+// after a thread dies, so a PlatformThreadRef cannot be reliably used
+// to distinguish a new thread from an old, dead thread.
+class PlatformThreadRef {
+ public:
+#if defined(OS_WIN)
+  typedef DWORD RefType;
+#else  //  OS_POSIX
+  typedef pthread_t RefType;
+#endif
+  constexpr PlatformThreadRef() : id_(0) {}
+
+  explicit constexpr PlatformThreadRef(RefType id) : id_(id) {}
+
+  bool operator==(PlatformThreadRef other) const {
+    return id_ == other.id_;
+  }
+
+  bool operator!=(PlatformThreadRef other) const { return id_ != other.id_; }
+
+  bool is_null() const {
+    return id_ == 0;
+  }
+ private:
+  RefType id_;
+};
+
+// Used to operate on threads.
+class PlatformThreadHandle {
+ public:
+#if defined(OS_WIN)
+  typedef void* Handle;
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  typedef pthread_t Handle;
+#endif
+
+  constexpr PlatformThreadHandle() : handle_(0) {}
+
+  explicit constexpr PlatformThreadHandle(Handle handle) : handle_(handle) {}
+
+  bool is_equal(const PlatformThreadHandle& other) const {
+    return handle_ == other.handle_;
+  }
+
+  bool is_null() const {
+    return !handle_;
+  }
+
+  Handle platform_handle() const {
+    return handle_;
+  }
+
+ private:
+  Handle handle_;
+};
+
+const PlatformThreadId kInvalidThreadId(0);
+
+// Valid values for priority of Thread::Options and SimpleThread::Options, and
+// SetCurrentThreadPriority(), listed in increasing order of importance.
+enum class ThreadPriority : int {
+  // Suitable for threads that shouldn't disrupt high priority work.
+  BACKGROUND,
+  // Default priority level.
+  NORMAL,
+  // Suitable for threads which generate data for the display (at ~60Hz).
+  DISPLAY,
+  // Suitable for low-latency, glitch-resistant audio.
+  REALTIME_AUDIO,
+};
+
+// A namespace for low-level thread functions.
+class BASE_EXPORT PlatformThread {
+ public:
+  // Implement this interface to run code on a background thread.  Your
+  // ThreadMain method will be called on the newly created thread.
+  class BASE_EXPORT Delegate {
+   public:
+    virtual void ThreadMain() = 0;
+
+   protected:
+    virtual ~Delegate() = default;
+  };
+
+  // Gets the current thread id, which may be useful for logging purposes.
+  static PlatformThreadId CurrentId();
+
+  // Gets the current thread reference, which can be used to check if
+  // we're on the right thread quickly.
+  static PlatformThreadRef CurrentRef();
+
+  // Get the handle representing the current thread. On Windows, this is a
+  // pseudo handle constant which will always represent the thread using it and
+  // hence should not be shared with other threads nor be used to differentiate
+  // the current thread from another.
+  static PlatformThreadHandle CurrentHandle();
+
+  // Yield the current thread so another thread can be scheduled.
+  static void YieldCurrentThread();
+
+  // Sleeps for the specified duration.
+  static void Sleep(base::TimeDelta duration);
+
+  // Sets the thread name visible to debuggers/tools. This will try to
+  // initialize the context for current thread unless it's a WorkerThread.
+  static void SetName(const std::string& name);
+
+  // Gets the thread name, if previously set by SetName.
+  static const char* GetName();
+
+  // Creates a new thread.  The |stack_size| parameter can be 0 to indicate
+  // that the default stack size should be used.  Upon success,
+  // |*thread_handle| will be assigned a handle to the newly created thread,
+  // and |delegate|'s ThreadMain method will be executed on the newly created
+  // thread.
+  // NOTE: When you are done with the thread handle, you must call Join to
+  // release system resources associated with the thread.  You must ensure that
+  // the Delegate object outlives the thread.
+  static bool Create(size_t stack_size,
+                     Delegate* delegate,
+                     PlatformThreadHandle* thread_handle) {
+    return CreateWithPriority(stack_size, delegate, thread_handle,
+                              ThreadPriority::NORMAL);
+  }
+
+  // CreateWithPriority() does the same thing as Create() except the priority of
+  // the thread is set based on |priority|.
+  static bool CreateWithPriority(size_t stack_size, Delegate* delegate,
+                                 PlatformThreadHandle* thread_handle,
+                                 ThreadPriority priority);
+
+  // CreateNonJoinable() does the same thing as Create() except the thread
+  // cannot be Join()'d.  Therefore, it also does not output a
+  // PlatformThreadHandle.
+  static bool CreateNonJoinable(size_t stack_size, Delegate* delegate);
+
+  // CreateNonJoinableWithPriority() does the same thing as CreateNonJoinable()
+  // except the priority of the thread is set based on |priority|.
+  static bool CreateNonJoinableWithPriority(size_t stack_size,
+                                            Delegate* delegate,
+                                            ThreadPriority priority);
+
+  // Joins with a thread created via the Create function.  This function blocks
+  // the caller until the designated thread exits.  This will invalidate
+  // |thread_handle|.
+  static void Join(PlatformThreadHandle thread_handle);
+
+  // Detaches and releases the thread handle. The thread is no longer joinable
+  // and |thread_handle| is invalidated after this call.
+  static void Detach(PlatformThreadHandle thread_handle);
+
+  // Returns true if SetCurrentThreadPriority() can be used to increase the
+  // priority of the current thread.
+  static bool CanIncreaseCurrentThreadPriority();
+
+  // Toggles the current thread's priority at runtime.
+  //
+  // A thread may not be able to raise its priority back up after lowering it if
+  // the process does not have a proper permission, e.g. CAP_SYS_NICE on Linux.
+  // A thread may not be able to lower its priority back down after raising it
+  // to REALTIME_AUDIO.
+  //
+  // This function must not be called from the main thread on Mac. This is to
+  // avoid performance regressions (https://crbug.com/601270).
+  //
+  // Since changing other threads' priority is not permitted in favor of
+  // security, this interface is restricted to change only the current thread
+  // priority (https://crbug.com/399473).
+  static void SetCurrentThreadPriority(ThreadPriority priority);
+
+  static ThreadPriority GetCurrentThreadPriority();
+
+#if defined(OS_LINUX)
+  // Toggles a specific thread's priority at runtime. This can be used to
+  // change the priority of a thread in a different process and will fail
+  // if the calling process does not have proper permissions. The
+  // SetCurrentThreadPriority() function above is preferred in favor of
+  // security but on platforms where sandboxed processes are not allowed to
+  // change priority this function exists to allow a non-sandboxed process
+  // to change the priority of sandboxed threads for improved performance.
+  // Warning: Don't use this for a main thread because that will change the
+  // whole thread group's (i.e. process) priority.
+  static void SetThreadPriority(PlatformThreadId thread_id,
+                                ThreadPriority priority);
+#endif
+
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(PlatformThread);
+};
+
+}  // namespace base
+
+#endif  // BASE_THREADING_PLATFORM_THREAD_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/platform_thread_internal_posix.h b/native/zucchini/vendor/libchrome/base/threading/platform_thread_internal_posix.h
new file mode 100644
index 0000000..5f4a215
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/threading/platform_thread_internal_posix.h
@@ -0,0 +1,48 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_THREADING_PLATFORM_THREAD_INTERNAL_POSIX_H_
+#define BASE_THREADING_PLATFORM_THREAD_INTERNAL_POSIX_H_
+
+#include "base/base_export.h"
+#include "base/threading/platform_thread.h"
+
+namespace base {
+
+namespace internal {
+
+struct ThreadPriorityToNiceValuePair {
+  ThreadPriority priority;
+  int nice_value;
+};
+// The elements must be listed in the order of increasing priority (lowest
+// priority first), that is, in the order of decreasing nice values (highest
+// nice value first).
+BASE_EXPORT extern
+const ThreadPriorityToNiceValuePair kThreadPriorityToNiceValueMap[4];
+
+// Returns the nice value matching |priority| based on the platform-specific
+// implementation of kThreadPriorityToNiceValueMap.
+int ThreadPriorityToNiceValue(ThreadPriority priority);
+
+// Returns the ThreadPrioirty matching |nice_value| based on the platform-
+// specific implementation of kThreadPriorityToNiceValueMap.
+BASE_EXPORT ThreadPriority NiceValueToThreadPriority(int nice_value);
+
+// Allows platform specific tweaks to the generic POSIX solution for
+// SetCurrentThreadPriority. Returns true if the platform-specific
+// implementation handled this |priority| change, false if the generic
+// implementation should instead proceed.
+bool SetCurrentThreadPriorityForPlatform(ThreadPriority priority);
+
+// Returns true if there is a platform-specific ThreadPriority set on the
+// current thread (and returns the actual ThreadPriority via |priority|).
+// Returns false otherwise, leaving |priority| untouched.
+bool GetCurrentThreadPriorityForPlatform(ThreadPriority* priority);
+
+}  // namespace internal
+
+}  // namespace base
+
+#endif  // BASE_THREADING_PLATFORM_THREAD_INTERNAL_POSIX_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/platform_thread_posix.cc b/native/zucchini/vendor/libchrome/base/threading/platform_thread_posix.cc
new file mode 100644
index 0000000..2466b78
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/threading/platform_thread_posix.cc
@@ -0,0 +1,305 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/threading/platform_thread.h"
+
+#include <errno.h>
+#include <pthread.h>
+#include <sched.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <memory>
+
+#include "base/debug/activity_tracker.h"
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/threading/platform_thread_internal_posix.h"
+#include "base/threading/thread_id_name_manager.h"
+#include "base/threading/thread_restrictions.h"
+#include "build/build_config.h"
+
+#if defined(OS_LINUX)
+#include <sys/syscall.h>
+#endif
+
+#if defined(OS_FUCHSIA)
+#include <zircon/process.h>
+#else
+#include <sys/resource.h>
+#endif
+
+namespace base {
+
+void InitThreading();
+void TerminateOnThread();
+size_t GetDefaultThreadStackSize(const pthread_attr_t& attributes);
+
+namespace {
+
+struct ThreadParams {
+  ThreadParams()
+      : delegate(nullptr), joinable(false), priority(ThreadPriority::NORMAL) {}
+
+  PlatformThread::Delegate* delegate;
+  bool joinable;
+  ThreadPriority priority;
+};
+
+void* ThreadFunc(void* params) {
+  PlatformThread::Delegate* delegate = nullptr;
+
+  {
+    std::unique_ptr<ThreadParams> thread_params(
+        static_cast<ThreadParams*>(params));
+
+    delegate = thread_params->delegate;
+    if (!thread_params->joinable)
+      base::ThreadRestrictions::SetSingletonAllowed(false);
+
+#if !defined(OS_NACL)
+    // Threads on linux/android may inherit their priority from the thread
+    // where they were created. This explicitly sets the priority of all new
+    // threads.
+    PlatformThread::SetCurrentThreadPriority(thread_params->priority);
+#endif
+  }
+
+  ThreadIdNameManager::GetInstance()->RegisterThread(
+      PlatformThread::CurrentHandle().platform_handle(),
+      PlatformThread::CurrentId());
+
+  delegate->ThreadMain();
+
+  ThreadIdNameManager::GetInstance()->RemoveName(
+      PlatformThread::CurrentHandle().platform_handle(),
+      PlatformThread::CurrentId());
+
+  base::TerminateOnThread();
+  return nullptr;
+}
+
+bool CreateThread(size_t stack_size,
+                  bool joinable,
+                  PlatformThread::Delegate* delegate,
+                  PlatformThreadHandle* thread_handle,
+                  ThreadPriority priority) {
+  DCHECK(thread_handle);
+  base::InitThreading();
+
+  pthread_attr_t attributes;
+  pthread_attr_init(&attributes);
+
+  // Pthreads are joinable by default, so only specify the detached
+  // attribute if the thread should be non-joinable.
+  if (!joinable)
+    pthread_attr_setdetachstate(&attributes, PTHREAD_CREATE_DETACHED);
+
+  // Get a better default if available.
+  if (stack_size == 0)
+    stack_size = base::GetDefaultThreadStackSize(attributes);
+
+  if (stack_size > 0)
+    pthread_attr_setstacksize(&attributes, stack_size);
+
+  std::unique_ptr<ThreadParams> params(new ThreadParams);
+  params->delegate = delegate;
+  params->joinable = joinable;
+  params->priority = priority;
+
+  pthread_t handle;
+  int err = pthread_create(&handle, &attributes, ThreadFunc, params.get());
+  bool success = !err;
+  if (success) {
+    // ThreadParams should be deleted on the created thread after used.
+    ignore_result(params.release());
+  } else {
+    // Value of |handle| is undefined if pthread_create fails.
+    handle = 0;
+    errno = err;
+    PLOG(ERROR) << "pthread_create";
+  }
+  *thread_handle = PlatformThreadHandle(handle);
+
+  pthread_attr_destroy(&attributes);
+
+  return success;
+}
+
+}  // namespace
+
+// static
+PlatformThreadId PlatformThread::CurrentId() {
+  // Pthreads doesn't have the concept of a thread ID, so we have to reach down
+  // into the kernel.
+#if defined(OS_MACOSX)
+  return pthread_mach_thread_np(pthread_self());
+#elif defined(OS_LINUX)
+  return syscall(__NR_gettid);
+#elif defined(OS_ANDROID)
+  return gettid();
+#elif defined(OS_FUCHSIA)
+  return zx_thread_self();
+#elif defined(OS_SOLARIS) || defined(OS_QNX)
+  return pthread_self();
+#elif defined(OS_NACL) && defined(__GLIBC__)
+  return pthread_self();
+#elif defined(OS_NACL) && !defined(__GLIBC__)
+  // Pointers are 32-bits in NaCl.
+  return reinterpret_cast<int32_t>(pthread_self());
+#elif defined(OS_POSIX) && defined(OS_AIX)
+  return pthread_self();
+#elif defined(OS_POSIX) && !defined(OS_AIX)
+  return reinterpret_cast<int64_t>(pthread_self());
+#endif
+}
+
+// static
+PlatformThreadRef PlatformThread::CurrentRef() {
+  return PlatformThreadRef(pthread_self());
+}
+
+// static
+PlatformThreadHandle PlatformThread::CurrentHandle() {
+  return PlatformThreadHandle(pthread_self());
+}
+
+// static
+void PlatformThread::YieldCurrentThread() {
+  sched_yield();
+}
+
+// static
+void PlatformThread::Sleep(TimeDelta duration) {
+  struct timespec sleep_time, remaining;
+
+  // Break the duration into seconds and nanoseconds.
+  // NOTE: TimeDelta's microseconds are int64s while timespec's
+  // nanoseconds are longs, so this unpacking must prevent overflow.
+  sleep_time.tv_sec = duration.InSeconds();
+  duration -= TimeDelta::FromSeconds(sleep_time.tv_sec);
+  sleep_time.tv_nsec = duration.InMicroseconds() * 1000;  // nanoseconds
+
+  while (nanosleep(&sleep_time, &remaining) == -1 && errno == EINTR)
+    sleep_time = remaining;
+}
+
+// static
+const char* PlatformThread::GetName() {
+  return ThreadIdNameManager::GetInstance()->GetName(CurrentId());
+}
+
+// static
+bool PlatformThread::CreateWithPriority(size_t stack_size, Delegate* delegate,
+                                        PlatformThreadHandle* thread_handle,
+                                        ThreadPriority priority) {
+  return CreateThread(stack_size, true /* joinable thread */, delegate,
+                      thread_handle, priority);
+}
+
+// static
+bool PlatformThread::CreateNonJoinable(size_t stack_size, Delegate* delegate) {
+  return CreateNonJoinableWithPriority(stack_size, delegate,
+                                       ThreadPriority::NORMAL);
+}
+
+// static
+bool PlatformThread::CreateNonJoinableWithPriority(size_t stack_size,
+                                                   Delegate* delegate,
+                                                   ThreadPriority priority) {
+  PlatformThreadHandle unused;
+
+  bool result = CreateThread(stack_size, false /* non-joinable thread */,
+                             delegate, &unused, priority);
+  return result;
+}
+
+// static
+void PlatformThread::Join(PlatformThreadHandle thread_handle) {
+  // Record the event that this thread is blocking upon (for hang diagnosis).
+  base::debug::ScopedThreadJoinActivity thread_activity(&thread_handle);
+
+  // Joining another thread may block the current thread for a long time, since
+  // the thread referred to by |thread_handle| may still be running long-lived /
+  // blocking tasks.
+  AssertBlockingAllowed();
+  CHECK_EQ(0, pthread_join(thread_handle.platform_handle(), nullptr));
+}
+
+// static
+void PlatformThread::Detach(PlatformThreadHandle thread_handle) {
+  CHECK_EQ(0, pthread_detach(thread_handle.platform_handle()));
+}
+
+// Mac and Fuchsia have their own Set/GetCurrentThreadPriority()
+// implementations.
+#if !defined(OS_MACOSX) && !defined(OS_FUCHSIA)
+
+// static
+bool PlatformThread::CanIncreaseCurrentThreadPriority() {
+#if defined(OS_NACL)
+  return false;
+#else
+  // Only root can raise thread priority on POSIX environment. On Linux, users
+  // who have CAP_SYS_NICE permission also can raise the thread priority, but
+  // libcap.so would be needed to check the capability.
+  return geteuid() == 0;
+#endif  // defined(OS_NACL)
+}
+
+// static
+void PlatformThread::SetCurrentThreadPriority(ThreadPriority priority) {
+#if defined(OS_NACL)
+  NOTIMPLEMENTED();
+#else
+  if (internal::SetCurrentThreadPriorityForPlatform(priority))
+    return;
+
+  // setpriority(2) should change the whole thread group's (i.e. process)
+  // priority. However, as stated in the bugs section of
+  // http://man7.org/linux/man-pages/man2/getpriority.2.html: "under the current
+  // Linux/NPTL implementation of POSIX threads, the nice value is a per-thread
+  // attribute". Also, 0 is prefered to the current thread id since it is
+  // equivalent but makes sandboxing easier (https://crbug.com/399473).
+  const int nice_setting = internal::ThreadPriorityToNiceValue(priority);
+  if (setpriority(PRIO_PROCESS, 0, nice_setting)) {
+    DVPLOG(1) << "Failed to set nice value of thread ("
+              << PlatformThread::CurrentId() << ") to " << nice_setting;
+  }
+#endif  // defined(OS_NACL)
+}
+
+// static
+ThreadPriority PlatformThread::GetCurrentThreadPriority() {
+#if defined(OS_NACL)
+  NOTIMPLEMENTED();
+  return ThreadPriority::NORMAL;
+#else
+  // Mirrors SetCurrentThreadPriority()'s implementation.
+  ThreadPriority platform_specific_priority;
+  if (internal::GetCurrentThreadPriorityForPlatform(
+          &platform_specific_priority)) {
+    return platform_specific_priority;
+  }
+
+  // Need to clear errno before calling getpriority():
+  // http://man7.org/linux/man-pages/man2/getpriority.2.html
+  errno = 0;
+  int nice_value = getpriority(PRIO_PROCESS, 0);
+  if (errno != 0) {
+    DVPLOG(1) << "Failed to get nice value of thread ("
+              << PlatformThread::CurrentId() << ")";
+    return ThreadPriority::NORMAL;
+  }
+
+  return internal::NiceValueToThreadPriority(nice_value);
+#endif  // !defined(OS_NACL)
+}
+
+#endif  // !defined(OS_MACOSX) && !defined(OS_FUCHSIA)
+
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/threading/sequenced_task_runner_handle.h b/native/zucchini/vendor/libchrome/base/threading/sequenced_task_runner_handle.h
new file mode 100644
index 0000000..f55cee5
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/threading/sequenced_task_runner_handle.h
@@ -0,0 +1,43 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_THREADING_SEQUENCED_TASK_RUNNER_HANDLE_H_
+#define BASE_THREADING_SEQUENCED_TASK_RUNNER_HANDLE_H_
+
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/sequenced_task_runner.h"
+
+namespace base {
+
+class BASE_EXPORT SequencedTaskRunnerHandle {
+ public:
+  // Returns a SequencedTaskRunner which guarantees that posted tasks will only
+  // run after the current task is finished and will satisfy a SequenceChecker.
+  // It should only be called if IsSet() returns true (see the comment there for
+  // the requirements).
+  static scoped_refptr<SequencedTaskRunner> Get();
+
+  // Returns true if one of the following conditions is fulfilled:
+  // a) A SequencedTaskRunner has been assigned to the current thread by
+  //    instantiating a SequencedTaskRunnerHandle.
+  // b) The current thread has a ThreadTaskRunnerHandle (which includes any
+  //    thread that has a MessageLoop associated with it).
+  static bool IsSet();
+
+  // Binds |task_runner| to the current thread.
+  explicit SequencedTaskRunnerHandle(
+      scoped_refptr<SequencedTaskRunner> task_runner);
+  ~SequencedTaskRunnerHandle();
+
+ private:
+  scoped_refptr<SequencedTaskRunner> task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(SequencedTaskRunnerHandle);
+};
+
+}  // namespace base
+
+#endif  // BASE_THREADING_SEQUENCED_TASK_RUNNER_HANDLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_collision_warner.h b/native/zucchini/vendor/libchrome/base/threading/thread_collision_warner.h
new file mode 100644
index 0000000..b6993f6
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/threading/thread_collision_warner.h
@@ -0,0 +1,245 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_THREADING_THREAD_COLLISION_WARNER_H_
+#define BASE_THREADING_THREAD_COLLISION_WARNER_H_
+
+#include <memory>
+
+#include "base/atomicops.h"
+#include "base/base_export.h"
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+
+// A helper class alongside macros to be used to verify assumptions about thread
+// safety of a class.
+//
+// Example: Queue implementation non thread-safe but still usable if clients
+//          are synchronized somehow.
+//
+//          In this case the macro DFAKE_SCOPED_LOCK has to be
+//          used, it checks that if a thread is inside the push/pop then
+//          noone else is still inside the pop/push
+//
+// class NonThreadSafeQueue {
+//  public:
+//   ...
+//   void push(int) { DFAKE_SCOPED_LOCK(push_pop_); ... }
+//   int pop() { DFAKE_SCOPED_LOCK(push_pop_); ... }
+//   ...
+//  private:
+//   DFAKE_MUTEX(push_pop_);
+// };
+//
+//
+// Example: Queue implementation non thread-safe but still usable if clients
+//          are synchronized somehow, it calls a method to "protect" from
+//          a "protected" method
+//
+//          In this case the macro DFAKE_SCOPED_RECURSIVE_LOCK
+//          has to be used, it checks that if a thread is inside the push/pop
+//          then noone else is still inside the pop/push
+//
+// class NonThreadSafeQueue {
+//  public:
+//   void push(int) {
+//     DFAKE_SCOPED_LOCK(push_pop_);
+//     ...
+//   }
+//   int pop() {
+//     DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_);
+//     bar();
+//     ...
+//   }
+//   void bar() { DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_); ... }
+//   ...
+//  private:
+//   DFAKE_MUTEX(push_pop_);
+// };
+//
+//
+// Example: Queue implementation not usable even if clients are synchronized,
+//          so only one thread in the class life cycle can use the two members
+//          push/pop.
+//
+//          In this case the macro DFAKE_SCOPED_LOCK_THREAD_LOCKED pins the
+//          specified
+//          critical section the first time a thread enters push or pop, from
+//          that time on only that thread is allowed to execute push or pop.
+//
+// class NonThreadSafeQueue {
+//  public:
+//   ...
+//   void push(int) { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
+//   int pop() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
+//   ...
+//  private:
+//   DFAKE_MUTEX(push_pop_);
+// };
+//
+//
+// Example: Class that has to be contructed/destroyed on same thread, it has
+//          a "shareable" method (with external synchronization) and a not
+//          shareable method (even with external synchronization).
+//
+//          In this case 3 Critical sections have to be defined
+//
+// class ExoticClass {
+//  public:
+//   ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
+//   ~ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
+//
+//   void Shareable() { DFAKE_SCOPED_LOCK(shareable_section_); ... }
+//   void NotShareable() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
+//   ...
+//  private:
+//   DFAKE_MUTEX(ctor_dtor_);
+//   DFAKE_MUTEX(shareable_section_);
+// };
+
+
+#if !defined(NDEBUG)
+
+// Defines a class member that acts like a mutex. It is used only as a
+// verification tool.
+#define DFAKE_MUTEX(obj) \
+     mutable base::ThreadCollisionWarner obj
+// Asserts the call is never called simultaneously in two threads. Used at
+// member function scope.
+#define DFAKE_SCOPED_LOCK(obj) \
+     base::ThreadCollisionWarner::ScopedCheck s_check_##obj(&obj)
+// Asserts the call is never called simultaneously in two threads. Used at
+// member function scope. Same as DFAKE_SCOPED_LOCK but allows recursive locks.
+#define DFAKE_SCOPED_RECURSIVE_LOCK(obj) \
+     base::ThreadCollisionWarner::ScopedRecursiveCheck sr_check_##obj(&obj)
+// Asserts the code is always executed in the same thread.
+#define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) \
+     base::ThreadCollisionWarner::Check check_##obj(&obj)
+
+#else
+
+#define DFAKE_MUTEX(obj) typedef void InternalFakeMutexType##obj
+#define DFAKE_SCOPED_LOCK(obj) ((void)0)
+#define DFAKE_SCOPED_RECURSIVE_LOCK(obj) ((void)0)
+#define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) ((void)0)
+
+#endif
+
+namespace base {
+
+// The class ThreadCollisionWarner uses an Asserter to notify the collision
+// AsserterBase is the interfaces and DCheckAsserter is the default asserter
+// used. During the unit tests is used another class that doesn't "DCHECK"
+// in case of collision (check thread_collision_warner_unittests.cc)
+struct BASE_EXPORT AsserterBase {
+  virtual ~AsserterBase() = default;
+  virtual void warn() = 0;
+};
+
+struct BASE_EXPORT DCheckAsserter : public AsserterBase {
+  ~DCheckAsserter() override = default;
+  void warn() override;
+};
+
+class BASE_EXPORT ThreadCollisionWarner {
+ public:
+  // The parameter asserter is there only for test purpose
+  explicit ThreadCollisionWarner(AsserterBase* asserter = new DCheckAsserter())
+      : valid_thread_id_(0),
+        counter_(0),
+        asserter_(asserter) {}
+
+  ~ThreadCollisionWarner() {
+    delete asserter_;
+  }
+
+  // This class is meant to be used through the macro
+  // DFAKE_SCOPED_LOCK_THREAD_LOCKED
+  // it doesn't leave the critical section, as opposed to ScopedCheck,
+  // because the critical section being pinned is allowed to be used only
+  // from one thread
+  class BASE_EXPORT Check {
+   public:
+    explicit Check(ThreadCollisionWarner* warner)
+        : warner_(warner) {
+      warner_->EnterSelf();
+    }
+
+    ~Check() = default;
+
+   private:
+    ThreadCollisionWarner* warner_;
+
+    DISALLOW_COPY_AND_ASSIGN(Check);
+  };
+
+  // This class is meant to be used through the macro
+  // DFAKE_SCOPED_LOCK
+  class BASE_EXPORT ScopedCheck {
+   public:
+    explicit ScopedCheck(ThreadCollisionWarner* warner)
+        : warner_(warner) {
+      warner_->Enter();
+    }
+
+    ~ScopedCheck() {
+      warner_->Leave();
+    }
+
+   private:
+    ThreadCollisionWarner* warner_;
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedCheck);
+  };
+
+  // This class is meant to be used through the macro
+  // DFAKE_SCOPED_RECURSIVE_LOCK
+  class BASE_EXPORT ScopedRecursiveCheck {
+   public:
+    explicit ScopedRecursiveCheck(ThreadCollisionWarner* warner)
+        : warner_(warner) {
+      warner_->EnterSelf();
+    }
+
+    ~ScopedRecursiveCheck() {
+      warner_->Leave();
+    }
+
+   private:
+    ThreadCollisionWarner* warner_;
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedRecursiveCheck);
+  };
+
+ private:
+  // This method stores the current thread identifier and does a DCHECK
+  // if a another thread has already done it, it is safe if same thread
+  // calls this multiple time (recursion allowed).
+  void EnterSelf();
+
+  // Same as EnterSelf but recursion is not allowed.
+  void Enter();
+
+  // Removes the thread_id stored in order to allow other threads to
+  // call EnterSelf or Enter.
+  void Leave();
+
+  // This stores the thread id that is inside the critical section, if the
+  // value is 0 then no thread is inside.
+  volatile subtle::Atomic32 valid_thread_id_;
+
+  // Counter to trace how many time a critical section was "pinned"
+  // (when allowed) in order to unpin it when counter_ reaches 0.
+  volatile subtle::Atomic32 counter_;
+
+  // Here only for class unit tests purpose, during the test I need to not
+  // DCHECK but notify the collision with something else.
+  AsserterBase* asserter_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadCollisionWarner);
+};
+
+}  // namespace base
+
+#endif  // BASE_THREADING_THREAD_COLLISION_WARNER_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_id_name_manager.h b/native/zucchini/vendor/libchrome/base/threading/thread_id_name_manager.h
new file mode 100644
index 0000000..f17dc1a
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/threading/thread_id_name_manager.h
@@ -0,0 +1,80 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_THREADING_THREAD_ID_NAME_MANAGER_H_
+#define BASE_THREADING_THREAD_ID_NAME_MANAGER_H_
+
+#include <map>
+#include <string>
+
+#include "base/base_export.h"
+#include "base/callback.h"
+#include "base/macros.h"
+#include "base/synchronization/lock.h"
+#include "base/threading/platform_thread.h"
+
+namespace base {
+
+template <typename T>
+struct DefaultSingletonTraits;
+
+class BASE_EXPORT ThreadIdNameManager {
+ public:
+  static ThreadIdNameManager* GetInstance();
+
+  static const char* GetDefaultInternedString();
+
+  // Register the mapping between a thread |id| and |handle|.
+  void RegisterThread(PlatformThreadHandle::Handle handle, PlatformThreadId id);
+
+  // The callback is called on the thread, immediately after the name is set.
+  // |name| is a pointer to a C string that is guaranteed to remain valid for
+  // the duration of the process.
+  using SetNameCallback = base::RepeatingCallback<void(const char* name)>;
+  void InstallSetNameCallback(SetNameCallback callback);
+
+  // Set the name for the current thread.
+  void SetName(const std::string& name);
+
+  // Get the name for the given id.
+  const char* GetName(PlatformThreadId id);
+
+  // Unlike |GetName|, this method using TLS and avoids touching |lock_|.
+  const char* GetNameForCurrentThread();
+
+  // Remove the name for the given id.
+  void RemoveName(PlatformThreadHandle::Handle handle, PlatformThreadId id);
+
+ private:
+  friend struct DefaultSingletonTraits<ThreadIdNameManager>;
+
+  typedef std::map<PlatformThreadId, PlatformThreadHandle::Handle>
+      ThreadIdToHandleMap;
+  typedef std::map<PlatformThreadHandle::Handle, std::string*>
+      ThreadHandleToInternedNameMap;
+  typedef std::map<std::string, std::string*> NameToInternedNameMap;
+
+  ThreadIdNameManager();
+  ~ThreadIdNameManager();
+
+  // lock_ protects the name_to_interned_name_, thread_id_to_handle_ and
+  // thread_handle_to_interned_name_ maps.
+  Lock lock_;
+
+  NameToInternedNameMap name_to_interned_name_;
+  ThreadIdToHandleMap thread_id_to_handle_;
+  ThreadHandleToInternedNameMap thread_handle_to_interned_name_;
+
+  // Treat the main process specially as there is no PlatformThreadHandle.
+  std::string* main_process_name_;
+  PlatformThreadId main_process_id_;
+
+  SetNameCallback set_name_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadIdNameManager);
+};
+
+}  // namespace base
+
+#endif  // BASE_THREADING_THREAD_ID_NAME_MANAGER_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_local.h b/native/zucchini/vendor/libchrome/base/threading/thread_local.h
new file mode 100644
index 0000000..cad9add
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/threading/thread_local.h
@@ -0,0 +1,99 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// WARNING: Thread local storage is a bit tricky to get right. Please make sure
+// that this is really the proper solution for what you're trying to achieve.
+// Don't prematurely optimize, most likely you can just use a Lock.
+//
+// These classes implement a wrapper around ThreadLocalStorage::Slot. On
+// construction, they will allocate a TLS slot, and free the TLS slot on
+// destruction. No memory management (creation or destruction) is handled. This
+// means for uses of ThreadLocalPointer, you must correctly manage the memory
+// yourself, these classes will not destroy the pointer for you. There are no
+// at-thread-exit actions taken by these classes.
+//
+// ThreadLocalPointer<Type> wraps a Type*. It performs no creation or
+// destruction, so memory management must be handled elsewhere. The first call
+// to Get() on a thread will return NULL. You can update the pointer with a call
+// to Set().
+//
+// ThreadLocalBoolean wraps a bool. It will default to false if it has never
+// been set otherwise with Set().
+//
+// Thread Safety: An instance of ThreadLocalStorage is completely thread safe
+// once it has been created. If you want to dynamically create an instance, you
+// must of course properly deal with safety and race conditions. This means a
+// function-level static initializer is generally inappropiate.
+//
+// In Android, the system TLS is limited.
+//
+// Example usage:
+//   // My class is logically attached to a single thread. We cache a pointer
+//   // on the thread it was created on, so we can implement current().
+//   MyClass::MyClass() {
+//     DCHECK(Singleton<ThreadLocalPointer<MyClass> >::get()->Get() == NULL);
+//     Singleton<ThreadLocalPointer<MyClass> >::get()->Set(this);
+//   }
+//
+//   MyClass::~MyClass() {
+//     DCHECK(Singleton<ThreadLocalPointer<MyClass> >::get()->Get() != NULL);
+//     Singleton<ThreadLocalPointer<MyClass> >::get()->Set(NULL);
+//   }
+//
+//   // Return the current MyClass associated with the calling thread, can be
+//   // NULL if there isn't a MyClass associated.
+//   MyClass* MyClass::current() {
+//     return Singleton<ThreadLocalPointer<MyClass> >::get()->Get();
+//   }
+
+#ifndef BASE_THREADING_THREAD_LOCAL_H_
+#define BASE_THREADING_THREAD_LOCAL_H_
+
+#include "base/macros.h"
+#include "base/threading/thread_local_storage.h"
+
+namespace base {
+
+template <typename Type>
+class ThreadLocalPointer {
+ public:
+  ThreadLocalPointer() = default;
+  ~ThreadLocalPointer() = default;
+
+  Type* Get() {
+    return static_cast<Type*>(slot_.Get());
+  }
+
+  void Set(Type* ptr) {
+    slot_.Set(const_cast<void*>(static_cast<const void*>(ptr)));
+  }
+
+ private:
+  ThreadLocalStorage::Slot slot_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadLocalPointer<Type>);
+};
+
+class ThreadLocalBoolean {
+ public:
+  ThreadLocalBoolean() = default;
+  ~ThreadLocalBoolean() = default;
+
+  bool Get() {
+    return tlp_.Get() != nullptr;
+  }
+
+  void Set(bool val) {
+    tlp_.Set(val ? this : nullptr);
+  }
+
+ private:
+  ThreadLocalPointer<void> tlp_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadLocalBoolean);
+};
+
+}  // namespace base
+
+#endif  // BASE_THREADING_THREAD_LOCAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_local_storage.cc b/native/zucchini/vendor/libchrome/base/threading/thread_local_storage.cc
new file mode 100644
index 0000000..c9f8c62
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/threading/thread_local_storage.cc
@@ -0,0 +1,408 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/threading/thread_local_storage.h"
+
+#include "base/atomicops.h"
+#include "base/logging.h"
+#include "base/synchronization/lock.h"
+#include "build/build_config.h"
+
+using base::internal::PlatformThreadLocalStorage;
+
+// Chrome Thread Local Storage (TLS)
+//
+// This TLS system allows Chrome to use a single OS level TLS slot process-wide,
+// and allows us to control the slot limits instead of being at the mercy of the
+// platform. To do this, Chrome TLS replicates an array commonly found in the OS
+// thread metadata.
+//
+// Overview:
+//
+// OS TLS Slots       Per-Thread                 Per-Process Global
+//     ...
+//     []             Chrome TLS Array           Chrome TLS Metadata
+//     [] ----------> [][][][][ ][][][][]        [][][][][ ][][][][]
+//     []                      |                          |
+//     ...                     V                          V
+//                      Metadata Version           Slot Information
+//                         Your Data!
+//
+// Using a single OS TLS slot, Chrome TLS allocates an array on demand for the
+// lifetime of each thread that requests Chrome TLS data. Each per-thread TLS
+// array matches the length of the per-process global metadata array.
+//
+// A per-process global TLS metadata array tracks information about each item in
+// the per-thread array:
+//   * Status: Tracks if the slot is allocated or free to assign.
+//   * Destructor: An optional destructor to call on thread destruction for that
+//                 specific slot.
+//   * Version: Tracks the current version of the TLS slot. Each TLS slot
+//              allocation is associated with a unique version number.
+//
+//              Most OS TLS APIs guarantee that a newly allocated TLS slot is
+//              initialized to 0 for all threads. The Chrome TLS system provides
+//              this guarantee by tracking the version for each TLS slot here
+//              on each per-thread Chrome TLS array entry. Threads that access
+//              a slot with a mismatched version will receive 0 as their value.
+//              The metadata version is incremented when the client frees a
+//              slot. The per-thread metadata version is updated when a client
+//              writes to the slot. This scheme allows for constant time
+//              invalidation and avoids the need to iterate through each Chrome
+//              TLS array to mark the slot as zero.
+//
+// Just like an OS TLS API, clients of the Chrome TLS are responsible for
+// managing any necessary lifetime of the data in their slots. The only
+// convenience provided is automatic destruction when a thread ends. If a client
+// frees a slot, that client is responsible for destroying the data in the slot.
+
+namespace {
+// In order to make TLS destructors work, we need to keep around a function
+// pointer to the destructor for each slot. We keep this array of pointers in a
+// global (static) array.
+// We use the single OS-level TLS slot (giving us one pointer per thread) to
+// hold a pointer to a per-thread array (table) of slots that we allocate to
+// Chromium consumers.
+
+// g_native_tls_key is the one native TLS that we use. It stores our table.
+base::subtle::Atomic32 g_native_tls_key =
+    PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES;
+
+// The OS TLS slot has three states:
+//   * kUninitialized: Any call to Slot::Get()/Set() will create the base
+//     per-thread TLS state. On POSIX, kUninitialized must be 0.
+//   * [Memory Address]: Raw pointer to the base per-thread TLS state.
+//   * kDestroyed: The base per-thread TLS state has been freed.
+//
+// Final States:
+//   * Windows: kDestroyed. Windows does not iterate through the OS TLS to clean
+//     up the values.
+//   * POSIX: kUninitialized. POSIX iterates through TLS until all slots contain
+//     nullptr.
+//
+// More details on this design:
+//   We need some type of thread-local state to indicate that the TLS system has
+//   been destroyed. To do so, we leverage the multi-pass nature of destruction
+//   of pthread_key.
+//
+//    a) After destruction of TLS system, we set the pthread_key to a sentinel
+//       kDestroyed.
+//    b) All calls to Slot::Get() DCHECK that the state is not kDestroyed, and
+//       any system which might potentially invoke Slot::Get() after destruction
+//       of TLS must check ThreadLocalStorage::ThreadIsBeingDestroyed().
+//    c) After a full pass of the pthread_keys, on the next invocation of
+//       ConstructTlsVector(), we'll then set the key to nullptr.
+//    d) At this stage, the TLS system is back in its uninitialized state.
+//    e) If in the second pass of destruction of pthread_keys something were to
+//       re-initialize TLS [this should never happen! Since the only code which
+//       uses Chrome TLS is Chrome controlled, we should really be striving for
+//       single-pass destruction], then TLS will be re-initialized and then go
+//       through the 2-pass destruction system again. Everything should just
+//       work (TM).
+
+// The consumers of kUninitialized and kDestroyed expect void*, since that's
+// what the API exposes on both POSIX and Windows.
+void* const kUninitialized = nullptr;
+
+// A sentinel value to indicate that the TLS system has been destroyed.
+void* const kDestroyed = reinterpret_cast<void*>(1);
+
+// The maximum number of slots in our thread local storage stack.
+constexpr int kThreadLocalStorageSize = 256;
+
+enum TlsStatus {
+  FREE,
+  IN_USE,
+};
+
+struct TlsMetadata {
+  TlsStatus status;
+  base::ThreadLocalStorage::TLSDestructorFunc destructor;
+  uint32_t version;
+};
+
+struct TlsVectorEntry {
+  void* data;
+  uint32_t version;
+};
+
+// This lock isn't needed until after we've constructed the per-thread TLS
+// vector, so it's safe to use.
+base::Lock* GetTLSMetadataLock() {
+  static auto* lock = new base::Lock();
+  return lock;
+}
+TlsMetadata g_tls_metadata[kThreadLocalStorageSize];
+size_t g_last_assigned_slot = 0;
+
+// The maximum number of times to try to clear slots by calling destructors.
+// Use pthread naming convention for clarity.
+constexpr int kMaxDestructorIterations = kThreadLocalStorageSize;
+
+// This function is called to initialize our entire Chromium TLS system.
+// It may be called very early, and we need to complete most all of the setup
+// (initialization) before calling *any* memory allocator functions, which may
+// recursively depend on this initialization.
+// As a result, we use Atomics, and avoid anything (like a singleton) that might
+// require memory allocations.
+TlsVectorEntry* ConstructTlsVector() {
+  PlatformThreadLocalStorage::TLSKey key =
+      base::subtle::NoBarrier_Load(&g_native_tls_key);
+  if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES) {
+    CHECK(PlatformThreadLocalStorage::AllocTLS(&key));
+
+    // The TLS_KEY_OUT_OF_INDEXES is used to find out whether the key is set or
+    // not in NoBarrier_CompareAndSwap, but Posix doesn't have invalid key, we
+    // define an almost impossible value be it.
+    // If we really get TLS_KEY_OUT_OF_INDEXES as value of key, just alloc
+    // another TLS slot.
+    if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES) {
+      PlatformThreadLocalStorage::TLSKey tmp = key;
+      CHECK(PlatformThreadLocalStorage::AllocTLS(&key) &&
+            key != PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES);
+      PlatformThreadLocalStorage::FreeTLS(tmp);
+    }
+    // Atomically test-and-set the tls_key. If the key is
+    // TLS_KEY_OUT_OF_INDEXES, go ahead and set it. Otherwise, do nothing, as
+    // another thread already did our dirty work.
+    if (PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES !=
+        static_cast<PlatformThreadLocalStorage::TLSKey>(
+            base::subtle::NoBarrier_CompareAndSwap(
+                &g_native_tls_key,
+                PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES, key))) {
+      // We've been shortcut. Another thread replaced g_native_tls_key first so
+      // we need to destroy our index and use the one the other thread got
+      // first.
+      PlatformThreadLocalStorage::FreeTLS(key);
+      key = base::subtle::NoBarrier_Load(&g_native_tls_key);
+    }
+  }
+  CHECK_EQ(PlatformThreadLocalStorage::GetTLSValue(key), kUninitialized);
+
+  // Some allocators, such as TCMalloc, make use of thread local storage. As a
+  // result, any attempt to call new (or malloc) will lazily cause such a system
+  // to initialize, which will include registering for a TLS key. If we are not
+  // careful here, then that request to create a key will call new back, and
+  // we'll have an infinite loop. We avoid that as follows: Use a stack
+  // allocated vector, so that we don't have dependence on our allocator until
+  // our service is in place. (i.e., don't even call new until after we're
+  // setup)
+  TlsVectorEntry stack_allocated_tls_data[kThreadLocalStorageSize];
+  memset(stack_allocated_tls_data, 0, sizeof(stack_allocated_tls_data));
+  // Ensure that any rentrant calls change the temp version.
+  PlatformThreadLocalStorage::SetTLSValue(key, stack_allocated_tls_data);
+
+  // Allocate an array to store our data.
+  TlsVectorEntry* tls_data = new TlsVectorEntry[kThreadLocalStorageSize];
+  memcpy(tls_data, stack_allocated_tls_data, sizeof(stack_allocated_tls_data));
+  PlatformThreadLocalStorage::SetTLSValue(key, tls_data);
+  return tls_data;
+}
+
+void OnThreadExitInternal(TlsVectorEntry* tls_data) {
+  // This branch is for POSIX, where this function is called twice. The first
+  // pass calls dtors and sets state to kDestroyed. The second pass sets
+  // kDestroyed to kUninitialized.
+  if (tls_data == kDestroyed) {
+    PlatformThreadLocalStorage::TLSKey key =
+        base::subtle::NoBarrier_Load(&g_native_tls_key);
+    PlatformThreadLocalStorage::SetTLSValue(key, kUninitialized);
+    return;
+  }
+
+  DCHECK(tls_data);
+  // Some allocators, such as TCMalloc, use TLS. As a result, when a thread
+  // terminates, one of the destructor calls we make may be to shut down an
+  // allocator. We have to be careful that after we've shutdown all of the known
+  // destructors (perchance including an allocator), that we don't call the
+  // allocator and cause it to resurrect itself (with no possibly destructor
+  // call to follow). We handle this problem as follows: Switch to using a stack
+  // allocated vector, so that we don't have dependence on our allocator after
+  // we have called all g_tls_metadata destructors. (i.e., don't even call
+  // delete[] after we're done with destructors.)
+  TlsVectorEntry stack_allocated_tls_data[kThreadLocalStorageSize];
+  memcpy(stack_allocated_tls_data, tls_data, sizeof(stack_allocated_tls_data));
+  // Ensure that any re-entrant calls change the temp version.
+  PlatformThreadLocalStorage::TLSKey key =
+      base::subtle::NoBarrier_Load(&g_native_tls_key);
+  PlatformThreadLocalStorage::SetTLSValue(key, stack_allocated_tls_data);
+  delete[] tls_data;  // Our last dependence on an allocator.
+
+  // Snapshot the TLS Metadata so we don't have to lock on every access.
+  TlsMetadata tls_metadata[kThreadLocalStorageSize];
+  {
+    base::AutoLock auto_lock(*GetTLSMetadataLock());
+    memcpy(tls_metadata, g_tls_metadata, sizeof(g_tls_metadata));
+  }
+
+  int remaining_attempts = kMaxDestructorIterations;
+  bool need_to_scan_destructors = true;
+  while (need_to_scan_destructors) {
+    need_to_scan_destructors = false;
+    // Try to destroy the first-created-slot (which is slot 1) in our last
+    // destructor call. That user was able to function, and define a slot with
+    // no other services running, so perhaps it is a basic service (like an
+    // allocator) and should also be destroyed last. If we get the order wrong,
+    // then we'll iterate several more times, so it is really not that critical
+    // (but it might help).
+    for (int slot = 0; slot < kThreadLocalStorageSize ; ++slot) {
+      void* tls_value = stack_allocated_tls_data[slot].data;
+      if (!tls_value || tls_metadata[slot].status == TlsStatus::FREE ||
+          stack_allocated_tls_data[slot].version != tls_metadata[slot].version)
+        continue;
+
+      base::ThreadLocalStorage::TLSDestructorFunc destructor =
+          tls_metadata[slot].destructor;
+      if (!destructor)
+        continue;
+      stack_allocated_tls_data[slot].data = nullptr;  // pre-clear the slot.
+      destructor(tls_value);
+      // Any destructor might have called a different service, which then set a
+      // different slot to a non-null value. Hence we need to check the whole
+      // vector again. This is a pthread standard.
+      need_to_scan_destructors = true;
+    }
+    if (--remaining_attempts <= 0) {
+      NOTREACHED();  // Destructors might not have been called.
+      break;
+    }
+  }
+
+  // Remove our stack allocated vector.
+  PlatformThreadLocalStorage::SetTLSValue(key, kDestroyed);
+}
+
+}  // namespace
+
+namespace base {
+
+namespace internal {
+
+#if defined(OS_WIN)
+void PlatformThreadLocalStorage::OnThreadExit() {
+  PlatformThreadLocalStorage::TLSKey key =
+      base::subtle::NoBarrier_Load(&g_native_tls_key);
+  if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES)
+    return;
+  void *tls_data = GetTLSValue(key);
+
+  // On Windows, thread destruction callbacks are only invoked once per module,
+  // so there should be no way that this could be invoked twice.
+  DCHECK_NE(tls_data, kDestroyed);
+
+  // Maybe we have never initialized TLS for this thread.
+  if (tls_data == kUninitialized)
+    return;
+  OnThreadExitInternal(static_cast<TlsVectorEntry*>(tls_data));
+}
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+void PlatformThreadLocalStorage::OnThreadExit(void* value) {
+  OnThreadExitInternal(static_cast<TlsVectorEntry*>(value));
+}
+
+// static
+void PlatformThreadLocalStorage::ForceFreeTLS() {
+  PlatformThreadLocalStorage::TLSKey key =
+      base::subtle::NoBarrier_AtomicExchange(
+          &g_native_tls_key,
+          PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES);
+  if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES)
+    return;
+  PlatformThreadLocalStorage::FreeTLS(key);
+}
+#endif  // defined(OS_WIN)
+
+}  // namespace internal
+
+bool ThreadLocalStorage::HasBeenDestroyed() {
+  PlatformThreadLocalStorage::TLSKey key =
+      base::subtle::NoBarrier_Load(&g_native_tls_key);
+  if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES)
+    return false;
+  return PlatformThreadLocalStorage::GetTLSValue(key) == kDestroyed;
+}
+
+void ThreadLocalStorage::Slot::Initialize(TLSDestructorFunc destructor) {
+  PlatformThreadLocalStorage::TLSKey key =
+      base::subtle::NoBarrier_Load(&g_native_tls_key);
+  if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES ||
+      PlatformThreadLocalStorage::GetTLSValue(key) == kUninitialized) {
+    ConstructTlsVector();
+  }
+
+  // Grab a new slot.
+  {
+    base::AutoLock auto_lock(*GetTLSMetadataLock());
+    for (int i = 0; i < kThreadLocalStorageSize; ++i) {
+      // Tracking the last assigned slot is an attempt to find the next
+      // available slot within one iteration. Under normal usage, slots remain
+      // in use for the lifetime of the process (otherwise before we reclaimed
+      // slots, we would have run out of slots). This makes it highly likely the
+      // next slot is going to be a free slot.
+      size_t slot_candidate =
+          (g_last_assigned_slot + 1 + i) % kThreadLocalStorageSize;
+      if (g_tls_metadata[slot_candidate].status == TlsStatus::FREE) {
+        g_tls_metadata[slot_candidate].status = TlsStatus::IN_USE;
+        g_tls_metadata[slot_candidate].destructor = destructor;
+        g_last_assigned_slot = slot_candidate;
+        DCHECK_EQ(kInvalidSlotValue, slot_);
+        slot_ = slot_candidate;
+        version_ = g_tls_metadata[slot_candidate].version;
+        break;
+      }
+    }
+  }
+  CHECK_NE(slot_, kInvalidSlotValue);
+  CHECK_LT(slot_, kThreadLocalStorageSize);
+}
+
+void ThreadLocalStorage::Slot::Free() {
+  DCHECK_NE(slot_, kInvalidSlotValue);
+  DCHECK_LT(slot_, kThreadLocalStorageSize);
+  {
+    base::AutoLock auto_lock(*GetTLSMetadataLock());
+    g_tls_metadata[slot_].status = TlsStatus::FREE;
+    g_tls_metadata[slot_].destructor = nullptr;
+    ++(g_tls_metadata[slot_].version);
+  }
+  slot_ = kInvalidSlotValue;
+}
+
+void* ThreadLocalStorage::Slot::Get() const {
+  TlsVectorEntry* tls_data = static_cast<TlsVectorEntry*>(
+      PlatformThreadLocalStorage::GetTLSValue(
+          base::subtle::NoBarrier_Load(&g_native_tls_key)));
+  DCHECK_NE(tls_data, kDestroyed);
+  if (!tls_data)
+    return nullptr;
+  DCHECK_NE(slot_, kInvalidSlotValue);
+  DCHECK_LT(slot_, kThreadLocalStorageSize);
+  // Version mismatches means this slot was previously freed.
+  if (tls_data[slot_].version != version_)
+    return nullptr;
+  return tls_data[slot_].data;
+}
+
+void ThreadLocalStorage::Slot::Set(void* value) {
+  TlsVectorEntry* tls_data = static_cast<TlsVectorEntry*>(
+      PlatformThreadLocalStorage::GetTLSValue(
+          base::subtle::NoBarrier_Load(&g_native_tls_key)));
+  DCHECK_NE(tls_data, kDestroyed);
+  if (!tls_data)
+    tls_data = ConstructTlsVector();
+  DCHECK_NE(slot_, kInvalidSlotValue);
+  DCHECK_LT(slot_, kThreadLocalStorageSize);
+  tls_data[slot_].data = value;
+  tls_data[slot_].version = version_;
+}
+
+ThreadLocalStorage::Slot::Slot(TLSDestructorFunc destructor) {
+  Initialize(destructor);
+}
+
+ThreadLocalStorage::Slot::~Slot() {
+  Free();
+}
+
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_local_storage.h b/native/zucchini/vendor/libchrome/base/threading/thread_local_storage.h
new file mode 100644
index 0000000..d6b62c1
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/threading/thread_local_storage.h
@@ -0,0 +1,184 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_THREADING_THREAD_LOCAL_STORAGE_H_
+#define BASE_THREADING_THREAD_LOCAL_STORAGE_H_
+
+#include <stdint.h>
+
+#include "base/atomicops.h"
+#include "base/base_export.h"
+#include "base/macros.h"
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
+#include "base/win/windows_types.h"
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+#include <pthread.h>
+#endif
+
+namespace heap_profiling {
+class ScopedAllowAlloc;
+}  // namespace heap_profiling
+
+namespace ui {
+class TLSDestructionCheckerForX11;
+}
+
+namespace base {
+
+class SamplingHeapProfiler;
+
+namespace debug {
+class GlobalActivityTracker;
+}  // namespace debug
+
+namespace trace_event {
+class MallocDumpProvider;
+}  // namespace trace_event
+
+namespace internal {
+
+class ThreadLocalStorageTestInternal;
+
+// WARNING: You should *NOT* use this class directly.
+// PlatformThreadLocalStorage is a low-level abstraction of the OS's TLS
+// interface. Instead, you should use one of the following:
+// * ThreadLocalBoolean (from thread_local.h) for booleans.
+// * ThreadLocalPointer (from thread_local.h) for pointers.
+// * ThreadLocalStorage::StaticSlot/Slot for more direct control of the slot.
+class BASE_EXPORT PlatformThreadLocalStorage {
+ public:
+
+#if defined(OS_WIN)
+  typedef unsigned long TLSKey;
+  enum : unsigned { TLS_KEY_OUT_OF_INDEXES = TLS_OUT_OF_INDEXES };
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  typedef pthread_key_t TLSKey;
+  // The following is a "reserved key" which is used in our generic Chromium
+  // ThreadLocalStorage implementation.  We expect that an OS will not return
+  // such a key, but if it is returned (i.e., the OS tries to allocate it) we
+  // will just request another key.
+  enum { TLS_KEY_OUT_OF_INDEXES = 0x7FFFFFFF };
+#endif
+
+  // The following methods need to be supported on each OS platform, so that
+  // the Chromium ThreadLocalStore functionality can be constructed.
+  // Chromium will use these methods to acquire a single OS slot, and then use
+  // that to support a much larger number of Chromium slots (independent of the
+  // OS restrictions).
+  // The following returns true if it successfully is able to return an OS
+  // key in |key|.
+  static bool AllocTLS(TLSKey* key);
+  // Note: FreeTLS() doesn't have to be called, it is fine with this leak, OS
+  // might not reuse released slot, you might just reset the TLS value with
+  // SetTLSValue().
+  static void FreeTLS(TLSKey key);
+  static void SetTLSValue(TLSKey key, void* value);
+  static void* GetTLSValue(TLSKey key) {
+#if defined(OS_WIN)
+    return TlsGetValue(key);
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+    return pthread_getspecific(key);
+#endif
+  }
+
+  // Each platform (OS implementation) is required to call this method on each
+  // terminating thread when the thread is about to terminate.  This method
+  // will then call all registered destructors for slots in Chromium
+  // ThreadLocalStorage, until there are no slot values remaining as having
+  // been set on this thread.
+  // Destructors may end up being called multiple times on a terminating
+  // thread, as other destructors may re-set slots that were previously
+  // destroyed.
+#if defined(OS_WIN)
+  // Since Windows which doesn't support TLS destructor, the implementation
+  // should use GetTLSValue() to retrieve the value of TLS slot.
+  static void OnThreadExit();
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  // |Value| is the data stored in TLS slot, The implementation can't use
+  // GetTLSValue() to retrieve the value of slot as it has already been reset
+  // in Posix.
+  static void OnThreadExit(void* value);
+  // Normally, Chrome runs as a process, so freeing the TLS is not needed since
+  // the OS will perform that while it's reclaiming the process' memory upon
+  // termination. If, however, this code is used inside a library that is
+  // dynamically loaded and unloaded, the consumer is responsible for calling
+  // this after all Chrome threads have stopped and prior to unloading the
+  // library.
+  static void ForceFreeTLS();
+#endif
+};
+
+}  // namespace internal
+
+// Wrapper for thread local storage.  This class doesn't do much except provide
+// an API for portability.
+class BASE_EXPORT ThreadLocalStorage {
+ public:
+  // Prototype for the TLS destructor function, which can be optionally used to
+  // cleanup thread local storage on thread exit.  'value' is the data that is
+  // stored in thread local storage.
+  typedef void (*TLSDestructorFunc)(void* value);
+
+  // A key representing one value stored in TLS. Use as a class member or a
+  // local variable. If you need a static storage duration variable, use the
+  // following pattern with a NoDestructor<Slot>:
+  // void MyDestructorFunc(void* value);
+  // ThreadLocalStorage::Slot& ImportantContentTLS() {
+  //   static NoDestructor<ThreadLocalStorage::Slot> important_content_tls(
+  //       &MyDestructorFunc);
+  //   return *important_content_tls;
+  // }
+  class BASE_EXPORT Slot final {
+   public:
+    // |destructor| is a pointer to a function to perform per-thread cleanup of
+    // this object.  If set to nullptr, no cleanup is done for this TLS slot.
+    explicit Slot(TLSDestructorFunc destructor = nullptr);
+    // If a destructor was set for this slot, removes the destructor so that
+    // remaining threads exiting will not free data.
+    ~Slot();
+
+    // Get the thread-local value stored in slot 'slot'.
+    // Values are guaranteed to initially be zero.
+    void* Get() const;
+
+    // Set the thread-local value stored in slot 'slot' to
+    // value 'value'.
+    void Set(void* value);
+
+   private:
+    void Initialize(TLSDestructorFunc destructor);
+    void Free();
+
+    static constexpr int kInvalidSlotValue = -1;
+    int slot_ = kInvalidSlotValue;
+    uint32_t version_ = 0;
+
+    DISALLOW_COPY_AND_ASSIGN(Slot);
+  };
+
+ private:
+  // In most cases, most callers should not need access to HasBeenDestroyed().
+  // If you are working in code that runs during thread destruction, contact the
+  // base OWNERs for advice and then make a friend request.
+  //
+  // Returns |true| if Chrome's implementation of TLS has been destroyed during
+  // thread destruction. Attempting to call Slot::Get() during destruction is
+  // disallowed and will hit a DCHECK. Any code that relies on TLS during thread
+  // destruction must first check this method before calling Slot::Get().
+  friend class base::SamplingHeapProfiler;
+  friend class base::internal::ThreadLocalStorageTestInternal;
+  friend class base::trace_event::MallocDumpProvider;
+  friend class debug::GlobalActivityTracker;
+  friend class heap_profiling::ScopedAllowAlloc;
+  friend class ui::TLSDestructionCheckerForX11;
+  static bool HasBeenDestroyed();
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadLocalStorage);
+};
+
+}  // namespace base
+
+#endif  // BASE_THREADING_THREAD_LOCAL_STORAGE_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_restrictions.h b/native/zucchini/vendor/libchrome/base/threading/thread_restrictions.h
new file mode 100644
index 0000000..705ba4d
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/threading/thread_restrictions.h
@@ -0,0 +1,536 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_THREADING_THREAD_RESTRICTIONS_H_
+#define BASE_THREADING_THREAD_RESTRICTIONS_H_
+
+#include "base/base_export.h"
+#include "base/gtest_prod_util.h"
+#include "base/logging.h"
+#include "base/macros.h"
+
+class BrowserProcessImpl;
+class HistogramSynchronizer;
+class NativeBackendKWallet;
+class KeyStorageLinux;
+
+namespace android_webview {
+class AwFormDatabaseService;
+class CookieManager;
+class ScopedAllowInitGLBindings;
+}
+
+namespace cc {
+class CompletionEvent;
+class SingleThreadTaskGraphRunner;
+}
+namespace chromeos {
+class BlockingMethodCaller;
+namespace system {
+class StatisticsProviderImpl;
+}
+}
+namespace chrome_browser_net {
+class Predictor;
+}
+namespace content {
+class BrowserGpuChannelHostFactory;
+class BrowserGpuMemoryBufferManager;
+class BrowserMainLoop;
+class BrowserProcessSubThread;
+class BrowserShutdownProfileDumper;
+class BrowserTestBase;
+class CategorizedWorkerPool;
+class GpuProcessTransportFactory;
+class NestedMessagePumpAndroid;
+class ScopedAllowWaitForAndroidLayoutTests;
+class ScopedAllowWaitForDebugURL;
+class SessionStorageDatabase;
+class SoftwareOutputDeviceMus;
+class ServiceWorkerSubresourceLoader;
+class SynchronousCompositor;
+class SynchronousCompositorHost;
+class SynchronousCompositorSyncCallBridge;
+class TextInputClientMac;
+}  // namespace content
+namespace cronet {
+class CronetPrefsManager;
+class CronetURLRequestContext;
+}  // namespace cronet
+namespace dbus {
+class Bus;
+}
+namespace disk_cache {
+class BackendImpl;
+class InFlightIO;
+}
+namespace functions {
+class ExecScriptScopedAllowBaseSyncPrimitives;
+}
+namespace gpu {
+class GpuChannelHost;
+}
+namespace leveldb {
+class LevelDBMojoProxy;
+}
+namespace media {
+class AudioInputDevice;
+class BlockingUrlProtocol;
+}
+namespace midi {
+class TaskService;  // https://crbug.com/796830
+}
+namespace mojo {
+class CoreLibraryInitializer;
+class SyncCallRestrictions;
+namespace core {
+class ScopedIPCSupport;
+}
+}
+namespace rlz_lib {
+class FinancialPing;
+}
+namespace ui {
+class CommandBufferClientImpl;
+class CommandBufferLocal;
+class GpuState;
+class MaterialDesignController;
+}
+namespace net {
+class MultiThreadedCertVerifierScopedAllowBaseSyncPrimitives;
+class NetworkChangeNotifierMac;
+namespace internal {
+class AddressTrackerLinux;
+}
+}
+
+namespace remoting {
+class AutoThread;
+}
+
+namespace resource_coordinator {
+class TabManagerDelegate;
+}
+
+namespace service_manager {
+class ServiceProcessLauncher;
+}
+
+namespace shell_integration {
+class LaunchXdgUtilityScopedAllowBaseSyncPrimitives;
+}
+
+namespace ui {
+class WindowResizeHelperMac;
+}
+
+namespace views {
+class ScreenMus;
+}
+
+namespace viz {
+class HostGpuMemoryBufferManager;
+}
+
+namespace webrtc {
+class DesktopConfigurationMonitor;
+}
+
+namespace base {
+
+namespace android {
+class JavaHandlerThread;
+}
+
+namespace internal {
+class TaskTracker;
+}
+
+class GetAppOutputScopedAllowBaseSyncPrimitives;
+class SimpleThread;
+class StackSamplingProfiler;
+class Thread;
+class ThreadTestHelper;
+
+#if DCHECK_IS_ON()
+#define INLINE_IF_DCHECK_IS_OFF BASE_EXPORT
+#define EMPTY_BODY_IF_DCHECK_IS_OFF
+#else
+#define INLINE_IF_DCHECK_IS_OFF inline
+#define EMPTY_BODY_IF_DCHECK_IS_OFF \
+  {}
+#endif
+
+// A "blocking call" refers to any call that causes the calling thread to wait
+// off-CPU. It includes but is not limited to calls that wait on synchronous
+// file I/O operations: read or write a file from disk, interact with a pipe or
+// a socket, rename or delete a file, enumerate files in a directory, etc.
+// Acquiring a low contention lock is not considered a blocking call.
+
+// Asserts that blocking calls are allowed in the current scope.
+//
+// Style tip: It's best if you put AssertBlockingAllowed() checks as close to
+// the blocking call as possible. For example:
+//
+// void ReadFile() {
+//   PreWork();
+//
+//   base::AssertBlockingAllowed();
+//   fopen(...);
+//
+//   PostWork();
+// }
+//
+// void Bar() {
+//   ReadFile();
+// }
+//
+// void Foo() {
+//   Bar();
+// }
+INLINE_IF_DCHECK_IS_OFF void AssertBlockingAllowed()
+    EMPTY_BODY_IF_DCHECK_IS_OFF;
+
+// Disallows blocking on the current thread.
+INLINE_IF_DCHECK_IS_OFF void DisallowBlocking() EMPTY_BODY_IF_DCHECK_IS_OFF;
+
+// Disallows blocking calls within its scope.
+class BASE_EXPORT ScopedDisallowBlocking {
+ public:
+  ScopedDisallowBlocking() EMPTY_BODY_IF_DCHECK_IS_OFF;
+  ~ScopedDisallowBlocking() EMPTY_BODY_IF_DCHECK_IS_OFF;
+
+ private:
+#if DCHECK_IS_ON()
+  const bool was_disallowed_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedDisallowBlocking);
+};
+
+// ScopedAllowBlocking(ForTesting) allow blocking calls within a scope where
+// they are normally disallowed.
+//
+// Avoid using this. Prefer making blocking calls from tasks posted to
+// base::TaskScheduler with base::MayBlock().
+//
+// Where unavoidable, put ScopedAllow* instances in the narrowest scope possible
+// in the caller making the blocking call but no further down. That is: if a
+// Cleanup() method needs to do a blocking call, document Cleanup() as blocking
+// and add a ScopedAllowBlocking instance in callers that can't avoid making
+// this call from a context where blocking is banned, as such:
+//   void Client::MyMethod() {
+//     (...)
+//     {
+//       // Blocking is okay here because XYZ.
+//       ScopedAllowBlocking allow_blocking;
+//       my_foo_->Cleanup();
+//     }
+//     (...)
+//   }
+//
+//   // This method can block.
+//   void Foo::Cleanup() {
+//     // Do NOT add the ScopedAllowBlocking in Cleanup() directly as that hides
+//     // its blocking nature from unknowing callers and defeats the purpose of
+//     // these checks.
+//     FlushStateToDisk();
+//   }
+//
+// Note: In rare situations where the blocking call is an implementation detail
+// (i.e. the impl makes a call that invokes AssertBlockingAllowed() but it
+// somehow knows that in practice this will not block), it might be okay to hide
+// the ScopedAllowBlocking instance in the impl with a comment explaining why
+// that's okay.
+class BASE_EXPORT ScopedAllowBlocking {
+ private:
+  // This can only be instantiated by friends. Use ScopedAllowBlockingForTesting
+  // in unit tests to avoid the friend requirement.
+  FRIEND_TEST_ALL_PREFIXES(ThreadRestrictionsTest, ScopedAllowBlocking);
+  friend class android_webview::ScopedAllowInitGLBindings;
+  friend class content::BrowserProcessSubThread;
+  friend class content::GpuProcessTransportFactory;
+  friend class cronet::CronetPrefsManager;
+  friend class cronet::CronetURLRequestContext;
+  friend class media::AudioInputDevice;
+  friend class mojo::CoreLibraryInitializer;
+  friend class resource_coordinator::TabManagerDelegate;  // crbug.com/778703
+  friend class ui::MaterialDesignController;
+  friend class ScopedAllowBlockingForTesting;
+  friend class StackSamplingProfiler;
+
+  ScopedAllowBlocking() EMPTY_BODY_IF_DCHECK_IS_OFF;
+  ~ScopedAllowBlocking() EMPTY_BODY_IF_DCHECK_IS_OFF;
+
+#if DCHECK_IS_ON()
+  const bool was_disallowed_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedAllowBlocking);
+};
+
+class ScopedAllowBlockingForTesting {
+ public:
+  ScopedAllowBlockingForTesting() {}
+  ~ScopedAllowBlockingForTesting() {}
+
+ private:
+#if DCHECK_IS_ON()
+  ScopedAllowBlocking scoped_allow_blocking_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedAllowBlockingForTesting);
+};
+
+// "Waiting on a //base sync primitive" refers to calling one of these methods:
+// - base::WaitableEvent::*Wait*
+// - base::ConditionVariable::*Wait*
+// - base::Process::WaitForExit*
+
+// Disallows waiting on a //base sync primitive on the current thread.
+INLINE_IF_DCHECK_IS_OFF void DisallowBaseSyncPrimitives()
+    EMPTY_BODY_IF_DCHECK_IS_OFF;
+
+// ScopedAllowBaseSyncPrimitives(ForTesting)(OutsideBlockingScope) allow waiting
+// on a //base sync primitive within a scope where this is normally disallowed.
+//
+// Avoid using this.
+//
+// Instead of waiting on a WaitableEvent or a ConditionVariable, put the work
+// that should happen after the wait in a callback and post that callback from
+// where the WaitableEvent or ConditionVariable would have been signaled. If
+// something needs to be scheduled after many tasks have executed, use
+// base::BarrierClosure.
+//
+// On Windows, join processes asynchronously using base::win::ObjectWatcher.
+
+// This can only be used in a scope where blocking is allowed.
+class BASE_EXPORT ScopedAllowBaseSyncPrimitives {
+ private:
+  // This can only be instantiated by friends. Use
+  // ScopedAllowBaseSyncPrimitivesForTesting in unit tests to avoid the friend
+  // requirement.
+  FRIEND_TEST_ALL_PREFIXES(ThreadRestrictionsTest,
+                           ScopedAllowBaseSyncPrimitives);
+  FRIEND_TEST_ALL_PREFIXES(ThreadRestrictionsTest,
+                           ScopedAllowBaseSyncPrimitivesResetsState);
+  FRIEND_TEST_ALL_PREFIXES(ThreadRestrictionsTest,
+                           ScopedAllowBaseSyncPrimitivesWithBlockingDisallowed);
+  friend class base::GetAppOutputScopedAllowBaseSyncPrimitives;
+  friend class content::BrowserProcessSubThread;
+  friend class content::SessionStorageDatabase;
+  friend class functions::ExecScriptScopedAllowBaseSyncPrimitives;
+  friend class leveldb::LevelDBMojoProxy;
+  friend class media::BlockingUrlProtocol;
+  friend class mojo::core::ScopedIPCSupport;
+  friend class net::MultiThreadedCertVerifierScopedAllowBaseSyncPrimitives;
+  friend class rlz_lib::FinancialPing;
+  friend class shell_integration::LaunchXdgUtilityScopedAllowBaseSyncPrimitives;
+  friend class webrtc::DesktopConfigurationMonitor;
+  friend class content::ServiceWorkerSubresourceLoader;
+  friend class viz::HostGpuMemoryBufferManager;
+
+  ScopedAllowBaseSyncPrimitives() EMPTY_BODY_IF_DCHECK_IS_OFF;
+  ~ScopedAllowBaseSyncPrimitives() EMPTY_BODY_IF_DCHECK_IS_OFF;
+
+#if DCHECK_IS_ON()
+  const bool was_disallowed_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedAllowBaseSyncPrimitives);
+};
+
+// This can be used in a scope where blocking is disallowed.
+class BASE_EXPORT ScopedAllowBaseSyncPrimitivesOutsideBlockingScope {
+ private:
+  // This can only be instantiated by friends. Use
+  // ScopedAllowBaseSyncPrimitivesForTesting in unit tests to avoid the friend
+  // requirement.
+  FRIEND_TEST_ALL_PREFIXES(ThreadRestrictionsTest,
+                           ScopedAllowBaseSyncPrimitivesOutsideBlockingScope);
+  FRIEND_TEST_ALL_PREFIXES(
+      ThreadRestrictionsTest,
+      ScopedAllowBaseSyncPrimitivesOutsideBlockingScopeResetsState);
+  friend class ::KeyStorageLinux;
+  friend class content::SynchronousCompositor;
+  friend class content::SynchronousCompositorHost;
+  friend class content::SynchronousCompositorSyncCallBridge;
+  friend class midi::TaskService;  // https://crbug.com/796830
+  // Not used in production yet, https://crbug.com/844078.
+  friend class service_manager::ServiceProcessLauncher;
+
+  ScopedAllowBaseSyncPrimitivesOutsideBlockingScope()
+      EMPTY_BODY_IF_DCHECK_IS_OFF;
+  ~ScopedAllowBaseSyncPrimitivesOutsideBlockingScope()
+      EMPTY_BODY_IF_DCHECK_IS_OFF;
+
+#if DCHECK_IS_ON()
+  const bool was_disallowed_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedAllowBaseSyncPrimitivesOutsideBlockingScope);
+};
+
+// This can be used in tests without being a friend of
+// ScopedAllowBaseSyncPrimitives(OutsideBlockingScope).
+class BASE_EXPORT ScopedAllowBaseSyncPrimitivesForTesting {
+ public:
+  ScopedAllowBaseSyncPrimitivesForTesting() EMPTY_BODY_IF_DCHECK_IS_OFF;
+  ~ScopedAllowBaseSyncPrimitivesForTesting() EMPTY_BODY_IF_DCHECK_IS_OFF;
+
+ private:
+#if DCHECK_IS_ON()
+  const bool was_disallowed_;
+#endif
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedAllowBaseSyncPrimitivesForTesting);
+};
+
+namespace internal {
+
+// Asserts that waiting on a //base sync primitive is allowed in the current
+// scope.
+INLINE_IF_DCHECK_IS_OFF void AssertBaseSyncPrimitivesAllowed()
+    EMPTY_BODY_IF_DCHECK_IS_OFF;
+
+// Resets all thread restrictions on the current thread.
+INLINE_IF_DCHECK_IS_OFF void ResetThreadRestrictionsForTesting()
+    EMPTY_BODY_IF_DCHECK_IS_OFF;
+
+}  // namespace internal
+
+class BASE_EXPORT ThreadRestrictions {
+ public:
+  // Constructing a ScopedAllowIO temporarily allows IO for the current
+  // thread.  Doing this is almost certainly always incorrect.
+  //
+  // DEPRECATED. Use ScopedAllowBlocking(ForTesting).
+  class BASE_EXPORT ScopedAllowIO {
+   public:
+    ScopedAllowIO() EMPTY_BODY_IF_DCHECK_IS_OFF;
+    ~ScopedAllowIO() EMPTY_BODY_IF_DCHECK_IS_OFF;
+
+   private:
+#if DCHECK_IS_ON()
+    const bool was_allowed_;
+#endif
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedAllowIO);
+  };
+
+#if DCHECK_IS_ON()
+  // Set whether the current thread to make IO calls.
+  // Threads start out in the *allowed* state.
+  // Returns the previous value.
+  //
+  // DEPRECATED. Use ScopedAllowBlocking(ForTesting) or ScopedDisallowBlocking.
+  static bool SetIOAllowed(bool allowed);
+
+  // Set whether the current thread can use singletons.  Returns the previous
+  // value.
+  static bool SetSingletonAllowed(bool allowed);
+
+  // Check whether the current thread is allowed to use singletons (Singleton /
+  // LazyInstance).  DCHECKs if not.
+  static void AssertSingletonAllowed();
+
+  // Disable waiting on the current thread. Threads start out in the *allowed*
+  // state. Returns the previous value.
+  //
+  // DEPRECATED. Use DisallowBaseSyncPrimitives.
+  static void DisallowWaiting();
+#else
+  // Inline the empty definitions of these functions so that they can be
+  // compiled out.
+  static bool SetIOAllowed(bool allowed) { return true; }
+  static bool SetSingletonAllowed(bool allowed) { return true; }
+  static void AssertSingletonAllowed() {}
+  static void DisallowWaiting() {}
+#endif
+
+ private:
+  // DO NOT ADD ANY OTHER FRIEND STATEMENTS.
+  // BEGIN ALLOWED USAGE.
+  friend class android_webview::AwFormDatabaseService;
+  friend class android_webview::CookieManager;
+  friend class base::StackSamplingProfiler;
+  friend class content::BrowserMainLoop;
+  friend class content::BrowserShutdownProfileDumper;
+  friend class content::BrowserTestBase;
+  friend class content::NestedMessagePumpAndroid;
+  friend class content::ScopedAllowWaitForAndroidLayoutTests;
+  friend class content::ScopedAllowWaitForDebugURL;
+  friend class ::HistogramSynchronizer;
+  friend class internal::TaskTracker;
+  friend class cc::CompletionEvent;
+  friend class cc::SingleThreadTaskGraphRunner;
+  friend class content::CategorizedWorkerPool;
+  friend class remoting::AutoThread;
+  friend class ui::WindowResizeHelperMac;
+  friend class MessagePumpDefault;
+  friend class SimpleThread;
+  friend class Thread;
+  friend class ThreadTestHelper;
+  friend class PlatformThread;
+  friend class android::JavaHandlerThread;
+  friend class mojo::SyncCallRestrictions;
+  friend class ui::CommandBufferClientImpl;
+  friend class ui::CommandBufferLocal;
+  friend class ui::GpuState;
+
+  // END ALLOWED USAGE.
+  // BEGIN USAGE THAT NEEDS TO BE FIXED.
+  friend class ::chromeos::BlockingMethodCaller;  // http://crbug.com/125360
+  friend class ::chromeos::system::StatisticsProviderImpl;  // http://crbug.com/125385
+  friend class chrome_browser_net::Predictor;     // http://crbug.com/78451
+  friend class
+      content::BrowserGpuChannelHostFactory;      // http://crbug.com/125248
+  friend class
+      content::BrowserGpuMemoryBufferManager;     // http://crbug.com/420368
+  friend class content::TextInputClientMac;       // http://crbug.com/121917
+  friend class dbus::Bus;                         // http://crbug.com/125222
+  friend class disk_cache::BackendImpl;           // http://crbug.com/74623
+  friend class disk_cache::InFlightIO;            // http://crbug.com/74623
+  friend class gpu::GpuChannelHost;               // http://crbug.com/125264
+  friend class net::internal::AddressTrackerLinux;  // http://crbug.com/125097
+  friend class net::NetworkChangeNotifierMac;     // http://crbug.com/125097
+  friend class ::BrowserProcessImpl;              // http://crbug.com/125207
+  friend class ::NativeBackendKWallet;            // http://crbug.com/125331
+#if !defined(OFFICIAL_BUILD)
+  friend class content::SoftwareOutputDeviceMus;  // Interim non-production code
+#endif
+  friend class views::ScreenMus;
+// END USAGE THAT NEEDS TO BE FIXED.
+
+#if DCHECK_IS_ON()
+  // DEPRECATED. Use ScopedAllowBaseSyncPrimitives.
+  static bool SetWaitAllowed(bool allowed);
+#else
+  static bool SetWaitAllowed(bool allowed) { return true; }
+#endif
+
+  // Constructing a ScopedAllowWait temporarily allows waiting on the current
+  // thread.  Doing this is almost always incorrect, which is why we limit who
+  // can use this through friend.
+  //
+  // DEPRECATED. Use ScopedAllowBaseSyncPrimitives.
+  class BASE_EXPORT ScopedAllowWait {
+   public:
+    ScopedAllowWait() EMPTY_BODY_IF_DCHECK_IS_OFF;
+    ~ScopedAllowWait() EMPTY_BODY_IF_DCHECK_IS_OFF;
+
+   private:
+#if DCHECK_IS_ON()
+    const bool was_allowed_;
+#endif
+
+    DISALLOW_COPY_AND_ASSIGN(ScopedAllowWait);
+  };
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ThreadRestrictions);
+};
+
+}  // namespace base
+
+#endif  // BASE_THREADING_THREAD_RESTRICTIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_task_runner_handle.h b/native/zucchini/vendor/libchrome/base/threading/thread_task_runner_handle.h
new file mode 100644
index 0000000..f6b71d7
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/threading/thread_task_runner_handle.h
@@ -0,0 +1,57 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_THREADING_THREAD_TASK_RUNNER_HANDLE_H_
+#define BASE_THREADING_THREAD_TASK_RUNNER_HANDLE_H_
+
+#include "base/base_export.h"
+#include "base/callback_helpers.h"
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/single_thread_task_runner.h"
+
+namespace base {
+
+// ThreadTaskRunnerHandle stores a reference to a thread's TaskRunner
+// in thread-local storage.  Callers can then retrieve the TaskRunner
+// for the current thread by calling ThreadTaskRunnerHandle::Get().
+// At most one TaskRunner may be bound to each thread at a time.
+// Prefer SequencedTaskRunnerHandle to this unless thread affinity is required.
+class BASE_EXPORT ThreadTaskRunnerHandle {
+ public:
+  // Gets the SingleThreadTaskRunner for the current thread.
+  static scoped_refptr<SingleThreadTaskRunner> Get();
+
+  // Returns true if the SingleThreadTaskRunner is already created for
+  // the current thread.
+  static bool IsSet();
+
+  // Overrides ThreadTaskRunnerHandle::Get()'s |task_runner_| to point at
+  // |overriding_task_runner| until the returned ScopedClosureRunner goes out of
+  // scope (instantiates a ThreadTaskRunnerHandle for that scope if |!IsSet()|).
+  // Nested overrides are allowed but callers must ensure the
+  // ScopedClosureRunners expire in LIFO (stack) order. Note: nesting
+  // ThreadTaskRunnerHandles isn't generally desired but it's useful in unit
+  // tests where multiple task runners can share the main thread for simplicity
+  // and determinism.
+  static ScopedClosureRunner OverrideForTesting(
+      scoped_refptr<SingleThreadTaskRunner> overriding_task_runner)
+      WARN_UNUSED_RESULT;
+
+  // Binds |task_runner| to the current thread. |task_runner| must belong
+  // to the current thread for this to succeed.
+  explicit ThreadTaskRunnerHandle(
+      scoped_refptr<SingleThreadTaskRunner> task_runner);
+  ~ThreadTaskRunnerHandle();
+
+ private:
+  scoped_refptr<SingleThreadTaskRunner> task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadTaskRunnerHandle);
+};
+
+}  // namespace base
+
+#endif  // BASE_THREADING_THREAD_TASK_RUNNER_HANDLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/time/time.cc b/native/zucchini/vendor/libchrome/base/time/time.cc
new file mode 100644
index 0000000..8529bb0
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/time/time.cc
@@ -0,0 +1,420 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/time/time.h"
+
+#include <cmath>
+#include <ios>
+#include <limits>
+#include <ostream>
+#include <sstream>
+
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/no_destructor.h"
+#include "base/strings/stringprintf.h"
+#include "base/third_party/nspr/prtime.h"
+#include "base/time/time_override.h"
+#include "build/build_config.h"
+
+namespace base {
+
+namespace internal {
+
+TimeNowFunction g_time_now_function = &subtle::TimeNowIgnoringOverride;
+
+TimeNowFunction g_time_now_from_system_time_function =
+    &subtle::TimeNowFromSystemTimeIgnoringOverride;
+
+TimeTicksNowFunction g_time_ticks_now_function =
+    &subtle::TimeTicksNowIgnoringOverride;
+
+ThreadTicksNowFunction g_thread_ticks_now_function =
+    &subtle::ThreadTicksNowIgnoringOverride;
+
+}  // namespace internal
+
+// TimeDelta ------------------------------------------------------------------
+
+int TimeDelta::InDays() const {
+  if (is_max()) {
+    // Preserve max to prevent overflow.
+    return std::numeric_limits<int>::max();
+  }
+  return static_cast<int>(delta_ / Time::kMicrosecondsPerDay);
+}
+
+int TimeDelta::InDaysFloored() const {
+  if (is_max()) {
+    // Preserve max to prevent overflow.
+    return std::numeric_limits<int>::max();
+  }
+  int result = delta_ / Time::kMicrosecondsPerDay;
+  int64_t remainder = delta_ - (result * Time::kMicrosecondsPerDay);
+  if (remainder < 0) {
+    --result;  // Use floor(), not trunc() rounding behavior.
+  }
+  return result;
+}
+
+int TimeDelta::InHours() const {
+  if (is_max()) {
+    // Preserve max to prevent overflow.
+    return std::numeric_limits<int>::max();
+  }
+  return static_cast<int>(delta_ / Time::kMicrosecondsPerHour);
+}
+
+int TimeDelta::InMinutes() const {
+  if (is_max()) {
+    // Preserve max to prevent overflow.
+    return std::numeric_limits<int>::max();
+  }
+  return static_cast<int>(delta_ / Time::kMicrosecondsPerMinute);
+}
+
+double TimeDelta::InSecondsF() const {
+  if (is_max()) {
+    // Preserve max to prevent overflow.
+    return std::numeric_limits<double>::infinity();
+  }
+  return static_cast<double>(delta_) / Time::kMicrosecondsPerSecond;
+}
+
+int64_t TimeDelta::InSeconds() const {
+  if (is_max()) {
+    // Preserve max to prevent overflow.
+    return std::numeric_limits<int64_t>::max();
+  }
+  return delta_ / Time::kMicrosecondsPerSecond;
+}
+
+double TimeDelta::InMillisecondsF() const {
+  if (is_max()) {
+    // Preserve max to prevent overflow.
+    return std::numeric_limits<double>::infinity();
+  }
+  return static_cast<double>(delta_) / Time::kMicrosecondsPerMillisecond;
+}
+
+int64_t TimeDelta::InMilliseconds() const {
+  if (is_max()) {
+    // Preserve max to prevent overflow.
+    return std::numeric_limits<int64_t>::max();
+  }
+  return delta_ / Time::kMicrosecondsPerMillisecond;
+}
+
+int64_t TimeDelta::InMillisecondsRoundedUp() const {
+  if (is_max()) {
+    // Preserve max to prevent overflow.
+    return std::numeric_limits<int64_t>::max();
+  }
+  int64_t result = delta_ / Time::kMicrosecondsPerMillisecond;
+  int64_t remainder = delta_ - (result * Time::kMicrosecondsPerMillisecond);
+  if (remainder > 0) {
+    ++result;  // Use ceil(), not trunc() rounding behavior.
+  }
+  return result;
+}
+
+int64_t TimeDelta::InMicroseconds() const {
+  if (is_max()) {
+    // Preserve max to prevent overflow.
+    return std::numeric_limits<int64_t>::max();
+  }
+  return delta_;
+}
+
+double TimeDelta::InMicrosecondsF() const {
+  if (is_max()) {
+    // Preserve max to prevent overflow.
+    return std::numeric_limits<double>::infinity();
+  }
+  return static_cast<double>(delta_);
+}
+
+int64_t TimeDelta::InNanoseconds() const {
+  if (is_max()) {
+    // Preserve max to prevent overflow.
+    return std::numeric_limits<int64_t>::max();
+  }
+  return delta_ * Time::kNanosecondsPerMicrosecond;
+}
+
+namespace time_internal {
+
+int64_t SaturatedAdd(TimeDelta delta, int64_t value) {
+  CheckedNumeric<int64_t> rv(delta.delta_);
+  rv += value;
+  if (rv.IsValid())
+    return rv.ValueOrDie();
+  // Positive RHS overflows. Negative RHS underflows.
+  if (value < 0)
+    return std::numeric_limits<int64_t>::min();
+  return std::numeric_limits<int64_t>::max();
+}
+
+int64_t SaturatedSub(TimeDelta delta, int64_t value) {
+  CheckedNumeric<int64_t> rv(delta.delta_);
+  rv -= value;
+  if (rv.IsValid())
+    return rv.ValueOrDie();
+  // Negative RHS overflows. Positive RHS underflows.
+  if (value < 0)
+    return std::numeric_limits<int64_t>::max();
+  return std::numeric_limits<int64_t>::min();
+}
+
+}  // namespace time_internal
+
+std::ostream& operator<<(std::ostream& os, TimeDelta time_delta) {
+  return os << time_delta.InSecondsF() << " s";
+}
+
+// Time -----------------------------------------------------------------------
+
+// static
+Time Time::Now() {
+  return internal::g_time_now_function();
+}
+
+// static
+Time Time::NowFromSystemTime() {
+  // Just use g_time_now_function because it returns the system time.
+  return internal::g_time_now_from_system_time_function();
+}
+
+// static
+Time Time::FromDeltaSinceWindowsEpoch(TimeDelta delta) {
+  return Time(delta.InMicroseconds());
+}
+
+TimeDelta Time::ToDeltaSinceWindowsEpoch() const {
+  return TimeDelta::FromMicroseconds(us_);
+}
+
+// static
+Time Time::FromTimeT(time_t tt) {
+  if (tt == 0)
+    return Time();  // Preserve 0 so we can tell it doesn't exist.
+  if (tt == std::numeric_limits<time_t>::max())
+    return Max();
+  return Time(kTimeTToMicrosecondsOffset) + TimeDelta::FromSeconds(tt);
+}
+
+time_t Time::ToTimeT() const {
+  if (is_null())
+    return 0;  // Preserve 0 so we can tell it doesn't exist.
+  if (is_max()) {
+    // Preserve max without offset to prevent overflow.
+    return std::numeric_limits<time_t>::max();
+  }
+  if (std::numeric_limits<int64_t>::max() - kTimeTToMicrosecondsOffset <= us_) {
+    DLOG(WARNING) << "Overflow when converting base::Time with internal " <<
+                     "value " << us_ << " to time_t.";
+    return std::numeric_limits<time_t>::max();
+  }
+  return (us_ - kTimeTToMicrosecondsOffset) / kMicrosecondsPerSecond;
+}
+
+// static
+Time Time::FromDoubleT(double dt) {
+  if (dt == 0 || std::isnan(dt))
+    return Time();  // Preserve 0 so we can tell it doesn't exist.
+  return Time(kTimeTToMicrosecondsOffset) + TimeDelta::FromSecondsD(dt);
+}
+
+double Time::ToDoubleT() const {
+  if (is_null())
+    return 0;  // Preserve 0 so we can tell it doesn't exist.
+  if (is_max()) {
+    // Preserve max without offset to prevent overflow.
+    return std::numeric_limits<double>::infinity();
+  }
+  return (static_cast<double>(us_ - kTimeTToMicrosecondsOffset) /
+          static_cast<double>(kMicrosecondsPerSecond));
+}
+
+#if defined(OS_POSIX)
+// static
+Time Time::FromTimeSpec(const timespec& ts) {
+  return FromDoubleT(ts.tv_sec +
+                     static_cast<double>(ts.tv_nsec) /
+                         base::Time::kNanosecondsPerSecond);
+}
+#endif
+
+// static
+Time Time::FromJsTime(double ms_since_epoch) {
+  // The epoch is a valid time, so this constructor doesn't interpret
+  // 0 as the null time.
+  return Time(kTimeTToMicrosecondsOffset) +
+         TimeDelta::FromMillisecondsD(ms_since_epoch);
+}
+
+double Time::ToJsTime() const {
+  if (is_null()) {
+    // Preserve 0 so the invalid result doesn't depend on the platform.
+    return 0;
+  }
+  if (is_max()) {
+    // Preserve max without offset to prevent overflow.
+    return std::numeric_limits<double>::infinity();
+  }
+  return (static_cast<double>(us_ - kTimeTToMicrosecondsOffset) /
+          kMicrosecondsPerMillisecond);
+}
+
+Time Time::FromJavaTime(int64_t ms_since_epoch) {
+  return base::Time::UnixEpoch() +
+         base::TimeDelta::FromMilliseconds(ms_since_epoch);
+}
+
+int64_t Time::ToJavaTime() const {
+  if (is_null()) {
+    // Preserve 0 so the invalid result doesn't depend on the platform.
+    return 0;
+  }
+  if (is_max()) {
+    // Preserve max without offset to prevent overflow.
+    return std::numeric_limits<int64_t>::max();
+  }
+  return ((us_ - kTimeTToMicrosecondsOffset) /
+          kMicrosecondsPerMillisecond);
+}
+
+// static
+Time Time::UnixEpoch() {
+  Time time;
+  time.us_ = kTimeTToMicrosecondsOffset;
+  return time;
+}
+
+Time Time::LocalMidnight() const {
+  Exploded exploded;
+  LocalExplode(&exploded);
+  exploded.hour = 0;
+  exploded.minute = 0;
+  exploded.second = 0;
+  exploded.millisecond = 0;
+  Time out_time;
+  if (FromLocalExploded(exploded, &out_time))
+    return out_time;
+  // This function must not fail.
+  NOTREACHED();
+  return Time();
+}
+
+// static
+bool Time::FromStringInternal(const char* time_string,
+                              bool is_local,
+                              Time* parsed_time) {
+  DCHECK((time_string != nullptr) && (parsed_time != nullptr));
+
+  if (time_string[0] == '\0')
+    return false;
+
+  PRTime result_time = 0;
+  PRStatus result = PR_ParseTimeString(time_string,
+                                       is_local ? PR_FALSE : PR_TRUE,
+                                       &result_time);
+  if (PR_SUCCESS != result)
+    return false;
+
+  result_time += kTimeTToMicrosecondsOffset;
+  *parsed_time = Time(result_time);
+  return true;
+}
+
+// static
+bool Time::ExplodedMostlyEquals(const Exploded& lhs, const Exploded& rhs) {
+  return lhs.year == rhs.year && lhs.month == rhs.month &&
+         lhs.day_of_month == rhs.day_of_month && lhs.hour == rhs.hour &&
+         lhs.minute == rhs.minute && lhs.second == rhs.second &&
+         lhs.millisecond == rhs.millisecond;
+}
+
+std::ostream& operator<<(std::ostream& os, Time time) {
+  Time::Exploded exploded;
+  time.UTCExplode(&exploded);
+  // Use StringPrintf because iostreams formatting is painful.
+  return os << StringPrintf("%04d-%02d-%02d %02d:%02d:%02d.%03d UTC",
+                            exploded.year,
+                            exploded.month,
+                            exploded.day_of_month,
+                            exploded.hour,
+                            exploded.minute,
+                            exploded.second,
+                            exploded.millisecond);
+}
+
+// TimeTicks ------------------------------------------------------------------
+
+// static
+TimeTicks TimeTicks::Now() {
+  return internal::g_time_ticks_now_function();
+}
+
+// static
+TimeTicks TimeTicks::UnixEpoch() {
+  static const base::NoDestructor<base::TimeTicks> epoch([]() {
+    return subtle::TimeTicksNowIgnoringOverride() -
+           (subtle::TimeNowIgnoringOverride() - Time::UnixEpoch());
+  }());
+  return *epoch;
+}
+
+TimeTicks TimeTicks::SnappedToNextTick(TimeTicks tick_phase,
+                                       TimeDelta tick_interval) const {
+  // |interval_offset| is the offset from |this| to the next multiple of
+  // |tick_interval| after |tick_phase|, possibly negative if in the past.
+  TimeDelta interval_offset = (tick_phase - *this) % tick_interval;
+  // If |this| is exactly on the interval (i.e. offset==0), don't adjust.
+  // Otherwise, if |tick_phase| was in the past, adjust forward to the next
+  // tick after |this|.
+  if (!interval_offset.is_zero() && tick_phase < *this)
+    interval_offset += tick_interval;
+  return *this + interval_offset;
+}
+
+std::ostream& operator<<(std::ostream& os, TimeTicks time_ticks) {
+  // This function formats a TimeTicks object as "bogo-microseconds".
+  // The origin and granularity of the count are platform-specific, and may very
+  // from run to run. Although bogo-microseconds usually roughly correspond to
+  // real microseconds, the only real guarantee is that the number never goes
+  // down during a single run.
+  const TimeDelta as_time_delta = time_ticks - TimeTicks();
+  return os << as_time_delta.InMicroseconds() << " bogo-microseconds";
+}
+
+// ThreadTicks ----------------------------------------------------------------
+
+// static
+ThreadTicks ThreadTicks::Now() {
+  return internal::g_thread_ticks_now_function();
+}
+
+std::ostream& operator<<(std::ostream& os, ThreadTicks thread_ticks) {
+  const TimeDelta as_time_delta = thread_ticks - ThreadTicks();
+  return os << as_time_delta.InMicroseconds() << " bogo-thread-microseconds";
+}
+
+// Time::Exploded -------------------------------------------------------------
+
+inline bool is_in_range(int value, int lo, int hi) {
+  return lo <= value && value <= hi;
+}
+
+bool Time::Exploded::HasValidValues() const {
+  return is_in_range(month, 1, 12) &&
+         is_in_range(day_of_week, 0, 6) &&
+         is_in_range(day_of_month, 1, 31) &&
+         is_in_range(hour, 0, 23) &&
+         is_in_range(minute, 0, 59) &&
+         is_in_range(second, 0, 60) &&
+         is_in_range(millisecond, 0, 999);
+}
+
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/time/time.h b/native/zucchini/vendor/libchrome/base/time/time.h
new file mode 100644
index 0000000..c7e8123
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/time/time.h
@@ -0,0 +1,993 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Time represents an absolute point in coordinated universal time (UTC),
+// internally represented as microseconds (s/1,000,000) since the Windows epoch
+// (1601-01-01 00:00:00 UTC). System-dependent clock interface routines are
+// defined in time_PLATFORM.cc. Note that values for Time may skew and jump
+// around as the operating system makes adjustments to synchronize (e.g., with
+// NTP servers). Thus, client code that uses the Time class must account for
+// this.
+//
+// TimeDelta represents a duration of time, internally represented in
+// microseconds.
+//
+// TimeTicks and ThreadTicks represent an abstract time that is most of the time
+// incrementing, for use in measuring time durations. Internally, they are
+// represented in microseconds. They cannot be converted to a human-readable
+// time, but are guaranteed not to decrease (unlike the Time class). Note that
+// TimeTicks may "stand still" (e.g., if the computer is suspended), and
+// ThreadTicks will "stand still" whenever the thread has been de-scheduled by
+// the operating system.
+//
+// All time classes are copyable, assignable, and occupy 64-bits per instance.
+// As a result, prefer passing them by value:
+//   void MyFunction(TimeDelta arg);
+// If circumstances require, you may also pass by const reference:
+//   void MyFunction(const TimeDelta& arg);  // Not preferred.
+//
+// Definitions of operator<< are provided to make these types work with
+// DCHECK_EQ() and other log macros. For human-readable formatting, see
+// "base/i18n/time_formatting.h".
+//
+// So many choices!  Which time class should you use?  Examples:
+//
+//   Time:        Interpreting the wall-clock time provided by a remote system.
+//                Detecting whether cached resources have expired. Providing the
+//                user with a display of the current date and time. Determining
+//                the amount of time between events across re-boots of the
+//                machine.
+//
+//   TimeTicks:   Tracking the amount of time a task runs. Executing delayed
+//                tasks at the right time. Computing presentation timestamps.
+//                Synchronizing audio and video using TimeTicks as a common
+//                reference clock (lip-sync). Measuring network round-trip
+//                latency.
+//
+//   ThreadTicks: Benchmarking how long the current thread has been doing actual
+//                work.
+
+#ifndef BASE_TIME_TIME_H_
+#define BASE_TIME_TIME_H_
+
+#include <stdint.h>
+#include <time.h>
+
+#include <iosfwd>
+#include <limits>
+
+#include "base/base_export.h"
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/numerics/safe_math.h"
+#include "build/build_config.h"
+
+#if defined(OS_FUCHSIA)
+#include <zircon/types.h>
+#endif
+
+#if defined(OS_MACOSX)
+#include <CoreFoundation/CoreFoundation.h>
+// Avoid Mac system header macro leak.
+#undef TYPE_BOOL
+#endif
+
+#if defined(OS_ANDROID)
+#include <jni.h>
+#endif
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+#include <unistd.h>
+#include <sys/time.h>
+#endif
+
+#if defined(OS_WIN)
+#include "base/gtest_prod_util.h"
+#include "base/win/windows_types.h"
+#endif
+
+namespace base {
+
+class PlatformThreadHandle;
+class TimeDelta;
+
+// The functions in the time_internal namespace are meant to be used only by the
+// time classes and functions.  Please use the math operators defined in the
+// time classes instead.
+namespace time_internal {
+
+// Add or subtract |value| from a TimeDelta. The int64_t argument and return
+// value are in terms of a microsecond timebase.
+BASE_EXPORT int64_t SaturatedAdd(TimeDelta delta, int64_t value);
+BASE_EXPORT int64_t SaturatedSub(TimeDelta delta, int64_t value);
+
+}  // namespace time_internal
+
+// TimeDelta ------------------------------------------------------------------
+
+class BASE_EXPORT TimeDelta {
+ public:
+  constexpr TimeDelta() : delta_(0) {}
+
+  // Converts units of time to TimeDeltas.
+  static constexpr TimeDelta FromDays(int days);
+  static constexpr TimeDelta FromHours(int hours);
+  static constexpr TimeDelta FromMinutes(int minutes);
+  static constexpr TimeDelta FromSeconds(int64_t secs);
+  static constexpr TimeDelta FromMilliseconds(int64_t ms);
+  static constexpr TimeDelta FromMicroseconds(int64_t us);
+  static constexpr TimeDelta FromNanoseconds(int64_t ns);
+  static constexpr TimeDelta FromSecondsD(double secs);
+  static constexpr TimeDelta FromMillisecondsD(double ms);
+  static constexpr TimeDelta FromMicrosecondsD(double us);
+  static constexpr TimeDelta FromNanosecondsD(double ns);
+#if defined(OS_WIN)
+  static TimeDelta FromQPCValue(LONGLONG qpc_value);
+  static TimeDelta FromFileTime(FILETIME ft);
+#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
+  static TimeDelta FromTimeSpec(const timespec& ts);
+#endif
+
+  // Converts an integer value representing TimeDelta to a class. This is used
+  // when deserializing a |TimeDelta| structure, using a value known to be
+  // compatible. It is not provided as a constructor because the integer type
+  // may be unclear from the perspective of a caller.
+  //
+  // DEPRECATED - Do not use in new code. http://crbug.com/634507
+  static constexpr TimeDelta FromInternalValue(int64_t delta) {
+    return TimeDelta(delta);
+  }
+
+  // Returns the maximum time delta, which should be greater than any reasonable
+  // time delta we might compare it to. Adding or subtracting the maximum time
+  // delta to a time or another time delta has an undefined result.
+  static constexpr TimeDelta Max();
+
+  // Returns the minimum time delta, which should be less than than any
+  // reasonable time delta we might compare it to. Adding or subtracting the
+  // minimum time delta to a time or another time delta has an undefined result.
+  static constexpr TimeDelta Min();
+
+  // Returns the internal numeric value of the TimeDelta object. Please don't
+  // use this and do arithmetic on it, as it is more error prone than using the
+  // provided operators.
+  // For serializing, use FromInternalValue to reconstitute.
+  //
+  // DEPRECATED - Do not use in new code. http://crbug.com/634507
+  constexpr int64_t ToInternalValue() const { return delta_; }
+
+  // Returns the magnitude (absolute value) of this TimeDelta.
+  constexpr TimeDelta magnitude() const {
+    // Some toolchains provide an incomplete C++11 implementation and lack an
+    // int64_t overload for std::abs().  The following is a simple branchless
+    // implementation:
+    const int64_t mask = delta_ >> (sizeof(delta_) * 8 - 1);
+    return TimeDelta((delta_ + mask) ^ mask);
+  }
+
+  // Returns true if the time delta is zero.
+  constexpr bool is_zero() const { return delta_ == 0; }
+
+  // Returns true if the time delta is the maximum/minimum time delta.
+  constexpr bool is_max() const {
+    return delta_ == std::numeric_limits<int64_t>::max();
+  }
+  constexpr bool is_min() const {
+    return delta_ == std::numeric_limits<int64_t>::min();
+  }
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+  struct timespec ToTimeSpec() const;
+#endif
+
+  // Returns the time delta in some unit. The InXYZF versions return a floating
+  // point value. The InXYZ versions return a truncated value (aka rounded
+  // towards zero, std::trunc() behavior). The InXYZFloored() versions round to
+  // lesser integers (std::floor() behavior). The XYZRoundedUp() versions round
+  // up to greater integers (std::ceil() behavior).
+  int InDays() const;
+  int InDaysFloored() const;
+  int InHours() const;
+  int InMinutes() const;
+  double InSecondsF() const;
+  int64_t InSeconds() const;
+  double InMillisecondsF() const;
+  int64_t InMilliseconds() const;
+  int64_t InMillisecondsRoundedUp() const;
+  int64_t InMicroseconds() const;
+  double InMicrosecondsF() const;
+  int64_t InNanoseconds() const;
+
+  constexpr TimeDelta& operator=(const TimeDelta&) = default;
+  constexpr TimeDelta(const TimeDelta&) = default;
+
+  // Computations with other deltas. Can easily be made constexpr with C++17 but
+  // hard to do until then per limitations around
+  // __builtin_(add|sub)_overflow in safe_math_clang_gcc_impl.h :
+  // https://chromium-review.googlesource.com/c/chromium/src/+/873352#message-59594ab70827795a67e0780404adf37b4b6c2f14
+  TimeDelta operator+(TimeDelta other) const {
+    return TimeDelta(time_internal::SaturatedAdd(*this, other.delta_));
+  }
+  TimeDelta operator-(TimeDelta other) const {
+    return TimeDelta(time_internal::SaturatedSub(*this, other.delta_));
+  }
+
+  TimeDelta& operator+=(TimeDelta other) {
+    return *this = (*this + other);
+  }
+  TimeDelta& operator-=(TimeDelta other) {
+    return *this = (*this - other);
+  }
+  constexpr TimeDelta operator-() const { return TimeDelta(-delta_); }
+
+  // Computations with numeric types. operator*() isn't constexpr because of a
+  // limitation around __builtin_mul_overflow (but operator/(1.0/a) works for
+  // |a|'s of "reasonable" size -- i.e. that don't risk overflow).
+  template <typename T>
+  TimeDelta operator*(T a) const {
+    CheckedNumeric<int64_t> rv(delta_);
+    rv *= a;
+    if (rv.IsValid())
+      return TimeDelta(rv.ValueOrDie());
+    // Matched sign overflows. Mismatched sign underflows.
+    if ((delta_ < 0) ^ (a < 0))
+      return TimeDelta(std::numeric_limits<int64_t>::min());
+    return TimeDelta(std::numeric_limits<int64_t>::max());
+  }
+  template <typename T>
+  constexpr TimeDelta operator/(T a) const {
+    CheckedNumeric<int64_t> rv(delta_);
+    rv /= a;
+    if (rv.IsValid())
+      return TimeDelta(rv.ValueOrDie());
+    // Matched sign overflows. Mismatched sign underflows.
+    // Special case to catch divide by zero.
+    if ((delta_ < 0) ^ (a <= 0))
+      return TimeDelta(std::numeric_limits<int64_t>::min());
+    return TimeDelta(std::numeric_limits<int64_t>::max());
+  }
+  template <typename T>
+  TimeDelta& operator*=(T a) {
+    return *this = (*this * a);
+  }
+  template <typename T>
+  constexpr TimeDelta& operator/=(T a) {
+    return *this = (*this / a);
+  }
+
+  constexpr int64_t operator/(TimeDelta a) const { return delta_ / a.delta_; }
+  constexpr TimeDelta operator%(TimeDelta a) const {
+    return TimeDelta(delta_ % a.delta_);
+  }
+
+  // Comparison operators.
+  constexpr bool operator==(TimeDelta other) const {
+    return delta_ == other.delta_;
+  }
+  constexpr bool operator!=(TimeDelta other) const {
+    return delta_ != other.delta_;
+  }
+  constexpr bool operator<(TimeDelta other) const {
+    return delta_ < other.delta_;
+  }
+  constexpr bool operator<=(TimeDelta other) const {
+    return delta_ <= other.delta_;
+  }
+  constexpr bool operator>(TimeDelta other) const {
+    return delta_ > other.delta_;
+  }
+  constexpr bool operator>=(TimeDelta other) const {
+    return delta_ >= other.delta_;
+  }
+
+#if defined(OS_WIN)
+  // This works around crbug.com/635974
+  constexpr TimeDelta(const TimeDelta& other) : delta_(other.delta_) {}
+#endif
+
+ private:
+  friend int64_t time_internal::SaturatedAdd(TimeDelta delta, int64_t value);
+  friend int64_t time_internal::SaturatedSub(TimeDelta delta, int64_t value);
+
+  // Constructs a delta given the duration in microseconds. This is private
+  // to avoid confusion by callers with an integer constructor. Use
+  // FromSeconds, FromMilliseconds, etc. instead.
+  constexpr explicit TimeDelta(int64_t delta_us) : delta_(delta_us) {}
+
+  // Private method to build a delta from a double.
+  static constexpr TimeDelta FromDouble(double value);
+
+  // Private method to build a delta from the product of a user-provided value
+  // and a known-positive value.
+  static constexpr TimeDelta FromProduct(int64_t value, int64_t positive_value);
+
+  // Delta in microseconds.
+  int64_t delta_;
+};
+
+template <typename T>
+TimeDelta operator*(T a, TimeDelta td) {
+  return td * a;
+}
+
+// For logging use only.
+BASE_EXPORT std::ostream& operator<<(std::ostream& os, TimeDelta time_delta);
+
+// Do not reference the time_internal::TimeBase template class directly.  Please
+// use one of the time subclasses instead, and only reference the public
+// TimeBase members via those classes.
+namespace time_internal {
+
+// TimeBase--------------------------------------------------------------------
+
+// Provides value storage and comparison/math operations common to all time
+// classes. Each subclass provides for strong type-checking to ensure
+// semantically meaningful comparison/math of time values from the same clock
+// source or timeline.
+template<class TimeClass>
+class TimeBase {
+ public:
+  static const int64_t kHoursPerDay = 24;
+  static const int64_t kMillisecondsPerSecond = 1000;
+  static const int64_t kMillisecondsPerDay =
+      kMillisecondsPerSecond * 60 * 60 * kHoursPerDay;
+  static const int64_t kMicrosecondsPerMillisecond = 1000;
+  static const int64_t kMicrosecondsPerSecond =
+      kMicrosecondsPerMillisecond * kMillisecondsPerSecond;
+  static const int64_t kMicrosecondsPerMinute = kMicrosecondsPerSecond * 60;
+  static const int64_t kMicrosecondsPerHour = kMicrosecondsPerMinute * 60;
+  static const int64_t kMicrosecondsPerDay =
+      kMicrosecondsPerHour * kHoursPerDay;
+  static const int64_t kMicrosecondsPerWeek = kMicrosecondsPerDay * 7;
+  static const int64_t kNanosecondsPerMicrosecond = 1000;
+  static const int64_t kNanosecondsPerSecond =
+      kNanosecondsPerMicrosecond * kMicrosecondsPerSecond;
+
+  // Returns true if this object has not been initialized.
+  //
+  // Warning: Be careful when writing code that performs math on time values,
+  // since it's possible to produce a valid "zero" result that should not be
+  // interpreted as a "null" value.
+  bool is_null() const {
+    return us_ == 0;
+  }
+
+  // Returns true if this object represents the maximum/minimum time.
+  bool is_max() const { return us_ == std::numeric_limits<int64_t>::max(); }
+  bool is_min() const { return us_ == std::numeric_limits<int64_t>::min(); }
+
+  // Returns the maximum/minimum times, which should be greater/less than than
+  // any reasonable time with which we might compare it.
+  static TimeClass Max() {
+    return TimeClass(std::numeric_limits<int64_t>::max());
+  }
+
+  static TimeClass Min() {
+    return TimeClass(std::numeric_limits<int64_t>::min());
+  }
+
+  // For serializing only. Use FromInternalValue() to reconstitute. Please don't
+  // use this and do arithmetic on it, as it is more error prone than using the
+  // provided operators.
+  //
+  // DEPRECATED - Do not use in new code. For serializing Time values, prefer
+  // Time::ToDeltaSinceWindowsEpoch().InMicroseconds(). http://crbug.com/634507
+  int64_t ToInternalValue() const { return us_; }
+
+  // The amount of time since the origin (or "zero") point. This is a syntactic
+  // convenience to aid in code readability, mainly for debugging/testing use
+  // cases.
+  //
+  // Warning: While the Time subclass has a fixed origin point, the origin for
+  // the other subclasses can vary each time the application is restarted.
+  TimeDelta since_origin() const { return TimeDelta::FromMicroseconds(us_); }
+
+  TimeClass& operator=(TimeClass other) {
+    us_ = other.us_;
+    return *(static_cast<TimeClass*>(this));
+  }
+
+  // Compute the difference between two times.
+  TimeDelta operator-(TimeClass other) const {
+    return TimeDelta::FromMicroseconds(us_ - other.us_);
+  }
+
+  // Return a new time modified by some delta.
+  TimeClass operator+(TimeDelta delta) const {
+    return TimeClass(time_internal::SaturatedAdd(delta, us_));
+  }
+  TimeClass operator-(TimeDelta delta) const {
+    return TimeClass(-time_internal::SaturatedSub(delta, us_));
+  }
+
+  // Modify by some time delta.
+  TimeClass& operator+=(TimeDelta delta) {
+    return static_cast<TimeClass&>(*this = (*this + delta));
+  }
+  TimeClass& operator-=(TimeDelta delta) {
+    return static_cast<TimeClass&>(*this = (*this - delta));
+  }
+
+  // Comparison operators
+  bool operator==(TimeClass other) const {
+    return us_ == other.us_;
+  }
+  bool operator!=(TimeClass other) const {
+    return us_ != other.us_;
+  }
+  bool operator<(TimeClass other) const {
+    return us_ < other.us_;
+  }
+  bool operator<=(TimeClass other) const {
+    return us_ <= other.us_;
+  }
+  bool operator>(TimeClass other) const {
+    return us_ > other.us_;
+  }
+  bool operator>=(TimeClass other) const {
+    return us_ >= other.us_;
+  }
+
+ protected:
+  constexpr explicit TimeBase(int64_t us) : us_(us) {}
+
+  // Time value in a microsecond timebase.
+  int64_t us_;
+};
+
+}  // namespace time_internal
+
+template<class TimeClass>
+inline TimeClass operator+(TimeDelta delta, TimeClass t) {
+  return t + delta;
+}
+
+// Time -----------------------------------------------------------------------
+
+// Represents a wall clock time in UTC. Values are not guaranteed to be
+// monotonically non-decreasing and are subject to large amounts of skew.
+class BASE_EXPORT Time : public time_internal::TimeBase<Time> {
+ public:
+  // Offset of UNIX epoch (1970-01-01 00:00:00 UTC) from Windows FILETIME epoch
+  // (1601-01-01 00:00:00 UTC), in microseconds. This value is derived from the
+  // following: ((1970-1601)*365+89)*24*60*60*1000*1000, where 89 is the number
+  // of leap year days between 1601 and 1970: (1970-1601)/4 excluding 1700,
+  // 1800, and 1900.
+  static constexpr int64_t kTimeTToMicrosecondsOffset =
+      INT64_C(11644473600000000);
+
+#if defined(OS_WIN)
+  // To avoid overflow in QPC to Microseconds calculations, since we multiply
+  // by kMicrosecondsPerSecond, then the QPC value should not exceed
+  // (2^63 - 1) / 1E6. If it exceeds that threshold, we divide then multiply.
+  static constexpr int64_t kQPCOverflowThreshold = INT64_C(0x8637BD05AF7);
+#endif
+
+// kExplodedMinYear and kExplodedMaxYear define the platform-specific limits
+// for values passed to FromUTCExploded() and FromLocalExploded(). Those
+// functions will return false if passed values outside these limits. The limits
+// are inclusive, meaning that the API should support all dates within a given
+// limit year.
+#if defined(OS_WIN)
+  static constexpr int kExplodedMinYear = 1601;
+  static constexpr int kExplodedMaxYear = 30827;
+#elif defined(OS_IOS)
+  static constexpr int kExplodedMinYear = std::numeric_limits<int>::min();
+  static constexpr int kExplodedMaxYear = std::numeric_limits<int>::max();
+#elif defined(OS_MACOSX)
+  static constexpr int kExplodedMinYear = 1902;
+  static constexpr int kExplodedMaxYear = std::numeric_limits<int>::max();
+#elif defined(OS_ANDROID)
+  // Though we use 64-bit time APIs on both 32 and 64 bit Android, some OS
+  // versions like KitKat (ARM but not x86 emulator) can't handle some early
+  // dates (e.g. before 1170). So we set min conservatively here.
+  static constexpr int kExplodedMinYear = 1902;
+  static constexpr int kExplodedMaxYear = std::numeric_limits<int>::max();
+#else
+  static constexpr int kExplodedMinYear =
+      (sizeof(time_t) == 4 ? 1902 : std::numeric_limits<int>::min());
+  static constexpr int kExplodedMaxYear =
+      (sizeof(time_t) == 4 ? 2037 : std::numeric_limits<int>::max());
+#endif
+
+  // Represents an exploded time that can be formatted nicely. This is kind of
+  // like the Win32 SYSTEMTIME structure or the Unix "struct tm" with a few
+  // additions and changes to prevent errors.
+  struct BASE_EXPORT Exploded {
+    int year;          // Four digit year "2007"
+    int month;         // 1-based month (values 1 = January, etc.)
+    int day_of_week;   // 0-based day of week (0 = Sunday, etc.)
+    int day_of_month;  // 1-based day of month (1-31)
+    int hour;          // Hour within the current day (0-23)
+    int minute;        // Minute within the current hour (0-59)
+    int second;        // Second within the current minute (0-59 plus leap
+                       //   seconds which may take it up to 60).
+    int millisecond;   // Milliseconds within the current second (0-999)
+
+    // A cursory test for whether the data members are within their
+    // respective ranges. A 'true' return value does not guarantee the
+    // Exploded value can be successfully converted to a Time value.
+    bool HasValidValues() const;
+  };
+
+  // Contains the NULL time. Use Time::Now() to get the current time.
+  constexpr Time() : TimeBase(0) {}
+
+  // Returns the time for epoch in Unix-like system (Jan 1, 1970).
+  static Time UnixEpoch();
+
+  // Returns the current time. Watch out, the system might adjust its clock
+  // in which case time will actually go backwards. We don't guarantee that
+  // times are increasing, or that two calls to Now() won't be the same.
+  static Time Now();
+
+  // Returns the current time. Same as Now() except that this function always
+  // uses system time so that there are no discrepancies between the returned
+  // time and system time even on virtual environments including our test bot.
+  // For timing sensitive unittests, this function should be used.
+  static Time NowFromSystemTime();
+
+  // Converts to/from TimeDeltas relative to the Windows epoch (1601-01-01
+  // 00:00:00 UTC). Prefer these methods for opaque serialization and
+  // deserialization of time values, e.g.
+  //
+  //   // Serialization:
+  //   base::Time last_updated = ...;
+  //   SaveToDatabase(last_updated.ToDeltaSinceWindowsEpoch().InMicroseconds());
+  //
+  //   // Deserialization:
+  //   base::Time last_updated = base::Time::FromDeltaSinceWindowsEpoch(
+  //       base::TimeDelta::FromMicroseconds(LoadFromDatabase()));
+  static Time FromDeltaSinceWindowsEpoch(TimeDelta delta);
+  TimeDelta ToDeltaSinceWindowsEpoch() const;
+
+  // Converts to/from time_t in UTC and a Time class.
+  static Time FromTimeT(time_t tt);
+  time_t ToTimeT() const;
+
+  // Converts time to/from a double which is the number of seconds since epoch
+  // (Jan 1, 1970).  Webkit uses this format to represent time.
+  // Because WebKit initializes double time value to 0 to indicate "not
+  // initialized", we map it to empty Time object that also means "not
+  // initialized".
+  static Time FromDoubleT(double dt);
+  double ToDoubleT() const;
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+  // Converts the timespec structure to time. MacOS X 10.8.3 (and tentatively,
+  // earlier versions) will have the |ts|'s tv_nsec component zeroed out,
+  // having a 1 second resolution, which agrees with
+  // https://developer.apple.com/legacy/library/#technotes/tn/tn1150.html#HFSPlusDates.
+  static Time FromTimeSpec(const timespec& ts);
+#endif
+
+  // Converts to/from the Javascript convention for times, a number of
+  // milliseconds since the epoch:
+  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Date/getTime.
+  static Time FromJsTime(double ms_since_epoch);
+  double ToJsTime() const;
+
+  // Converts to/from Java convention for times, a number of milliseconds since
+  // the epoch. Because the Java format has less resolution, converting to Java
+  // time is a lossy operation.
+  static Time FromJavaTime(int64_t ms_since_epoch);
+  int64_t ToJavaTime() const;
+
+#if defined(OS_POSIX) || defined(OS_FUCHSIA)
+  static Time FromTimeVal(struct timeval t);
+  struct timeval ToTimeVal() const;
+#endif
+
+#if defined(OS_MACOSX)
+  static Time FromCFAbsoluteTime(CFAbsoluteTime t);
+  CFAbsoluteTime ToCFAbsoluteTime() const;
+#endif
+
+#if defined(OS_WIN)
+  static Time FromFileTime(FILETIME ft);
+  FILETIME ToFileTime() const;
+
+  // The minimum time of a low resolution timer.  This is basically a windows
+  // constant of ~15.6ms.  While it does vary on some older OS versions, we'll
+  // treat it as static across all windows versions.
+  static const int kMinLowResolutionThresholdMs = 16;
+
+  // Enable or disable Windows high resolution timer.
+  static void EnableHighResolutionTimer(bool enable);
+
+  // Activates or deactivates the high resolution timer based on the |activate|
+  // flag.  If the HighResolutionTimer is not Enabled (see
+  // EnableHighResolutionTimer), this function will return false.  Otherwise
+  // returns true.  Each successful activate call must be paired with a
+  // subsequent deactivate call.
+  // All callers to activate the high resolution timer must eventually call
+  // this function to deactivate the high resolution timer.
+  static bool ActivateHighResolutionTimer(bool activate);
+
+  // Returns true if the high resolution timer is both enabled and activated.
+  // This is provided for testing only, and is not tracked in a thread-safe
+  // way.
+  static bool IsHighResolutionTimerInUse();
+
+  // The following two functions are used to report the fraction of elapsed time
+  // that the high resolution timer is activated.
+  // ResetHighResolutionTimerUsage() resets the cumulative usage and starts the
+  // measurement interval and GetHighResolutionTimerUsage() returns the
+  // percentage of time since the reset that the high resolution timer was
+  // activated.
+  // ResetHighResolutionTimerUsage() must be called at least once before calling
+  // GetHighResolutionTimerUsage(); otherwise the usage result would be
+  // undefined.
+  static void ResetHighResolutionTimerUsage();
+  static double GetHighResolutionTimerUsage();
+#endif  // defined(OS_WIN)
+
+  // Converts an exploded structure representing either the local time or UTC
+  // into a Time class. Returns false on a failure when, for example, a day of
+  // month is set to 31 on a 28-30 day month. Returns Time(0) on overflow.
+  static bool FromUTCExploded(const Exploded& exploded,
+                              Time* time) WARN_UNUSED_RESULT {
+    return FromExploded(false, exploded, time);
+  }
+  static bool FromLocalExploded(const Exploded& exploded,
+                                Time* time) WARN_UNUSED_RESULT {
+    return FromExploded(true, exploded, time);
+  }
+
+  // Converts a string representation of time to a Time object.
+  // An example of a time string which is converted is as below:-
+  // "Tue, 15 Nov 1994 12:45:26 GMT". If the timezone is not specified
+  // in the input string, FromString assumes local time and FromUTCString
+  // assumes UTC. A timezone that cannot be parsed (e.g. "UTC" which is not
+  // specified in RFC822) is treated as if the timezone is not specified.
+  // TODO(iyengar) Move the FromString/FromTimeT/ToTimeT/FromFileTime to
+  // a new time converter class.
+  static bool FromString(const char* time_string,
+                         Time* parsed_time) WARN_UNUSED_RESULT {
+    return FromStringInternal(time_string, true, parsed_time);
+  }
+  static bool FromUTCString(const char* time_string,
+                            Time* parsed_time) WARN_UNUSED_RESULT {
+    return FromStringInternal(time_string, false, parsed_time);
+  }
+
+  // Fills the given exploded structure with either the local time or UTC from
+  // this time structure (containing UTC).
+  void UTCExplode(Exploded* exploded) const {
+    return Explode(false, exploded);
+  }
+  void LocalExplode(Exploded* exploded) const {
+    return Explode(true, exploded);
+  }
+
+  // Rounds this time down to the nearest day in local time. It will represent
+  // midnight on that day.
+  Time LocalMidnight() const;
+
+  // Converts an integer value representing Time to a class. This may be used
+  // when deserializing a |Time| structure, using a value known to be
+  // compatible. It is not provided as a constructor because the integer type
+  // may be unclear from the perspective of a caller.
+  //
+  // DEPRECATED - Do not use in new code. For deserializing Time values, prefer
+  // Time::FromDeltaSinceWindowsEpoch(). http://crbug.com/634507
+  static constexpr Time FromInternalValue(int64_t us) { return Time(us); }
+
+ private:
+  friend class time_internal::TimeBase<Time>;
+
+  constexpr explicit Time(int64_t us) : TimeBase(us) {}
+
+  // Explodes the given time to either local time |is_local = true| or UTC
+  // |is_local = false|.
+  void Explode(bool is_local, Exploded* exploded) const;
+
+  // Unexplodes a given time assuming the source is either local time
+  // |is_local = true| or UTC |is_local = false|. Function returns false on
+  // failure and sets |time| to Time(0). Otherwise returns true and sets |time|
+  // to non-exploded time.
+  static bool FromExploded(bool is_local,
+                           const Exploded& exploded,
+                           Time* time) WARN_UNUSED_RESULT;
+
+  // Converts a string representation of time to a Time object.
+  // An example of a time string which is converted is as below:-
+  // "Tue, 15 Nov 1994 12:45:26 GMT". If the timezone is not specified
+  // in the input string, local time |is_local = true| or
+  // UTC |is_local = false| is assumed. A timezone that cannot be parsed
+  // (e.g. "UTC" which is not specified in RFC822) is treated as if the
+  // timezone is not specified.
+  static bool FromStringInternal(const char* time_string,
+                                 bool is_local,
+                                 Time* parsed_time) WARN_UNUSED_RESULT;
+
+  // Comparison does not consider |day_of_week| when doing the operation.
+  static bool ExplodedMostlyEquals(const Exploded& lhs,
+                                   const Exploded& rhs) WARN_UNUSED_RESULT;
+};
+
+// static
+constexpr TimeDelta TimeDelta::FromDays(int days) {
+  return days == std::numeric_limits<int>::max()
+             ? Max()
+             : TimeDelta(days * Time::kMicrosecondsPerDay);
+}
+
+// static
+constexpr TimeDelta TimeDelta::FromHours(int hours) {
+  return hours == std::numeric_limits<int>::max()
+             ? Max()
+             : TimeDelta(hours * Time::kMicrosecondsPerHour);
+}
+
+// static
+constexpr TimeDelta TimeDelta::FromMinutes(int minutes) {
+  return minutes == std::numeric_limits<int>::max()
+             ? Max()
+             : TimeDelta(minutes * Time::kMicrosecondsPerMinute);
+}
+
+// static
+constexpr TimeDelta TimeDelta::FromSeconds(int64_t secs) {
+  return FromProduct(secs, Time::kMicrosecondsPerSecond);
+}
+
+// static
+constexpr TimeDelta TimeDelta::FromMilliseconds(int64_t ms) {
+  return FromProduct(ms, Time::kMicrosecondsPerMillisecond);
+}
+
+// static
+constexpr TimeDelta TimeDelta::FromMicroseconds(int64_t us) {
+  return TimeDelta(us);
+}
+
+// static
+constexpr TimeDelta TimeDelta::FromNanoseconds(int64_t ns) {
+  return TimeDelta(ns / Time::kNanosecondsPerMicrosecond);
+}
+
+// static
+constexpr TimeDelta TimeDelta::FromSecondsD(double secs) {
+  return FromDouble(secs * Time::kMicrosecondsPerSecond);
+}
+
+// static
+constexpr TimeDelta TimeDelta::FromMillisecondsD(double ms) {
+  return FromDouble(ms * Time::kMicrosecondsPerMillisecond);
+}
+
+// static
+constexpr TimeDelta TimeDelta::FromMicrosecondsD(double us) {
+  return FromDouble(us);
+}
+
+// static
+constexpr TimeDelta TimeDelta::FromNanosecondsD(double ns) {
+  return FromDouble(ns / Time::kNanosecondsPerMicrosecond);
+}
+
+// static
+constexpr TimeDelta TimeDelta::Max() {
+  return TimeDelta(std::numeric_limits<int64_t>::max());
+}
+
+// static
+constexpr TimeDelta TimeDelta::Min() {
+  return TimeDelta(std::numeric_limits<int64_t>::min());
+}
+
+// static
+constexpr TimeDelta TimeDelta::FromDouble(double value) {
+  return TimeDelta(saturated_cast<int64_t>(value));
+}
+
+// static
+constexpr TimeDelta TimeDelta::FromProduct(int64_t value,
+                                           int64_t positive_value) {
+  DCHECK(positive_value > 0);
+  return value > std::numeric_limits<int64_t>::max() / positive_value
+             ? Max()
+             : value < std::numeric_limits<int64_t>::min() / positive_value
+                   ? Min()
+                   : TimeDelta(value * positive_value);
+}
+
+// For logging use only.
+BASE_EXPORT std::ostream& operator<<(std::ostream& os, Time time);
+
+// TimeTicks ------------------------------------------------------------------
+
+// Represents monotonically non-decreasing clock time.
+class BASE_EXPORT TimeTicks : public time_internal::TimeBase<TimeTicks> {
+ public:
+  // The underlying clock used to generate new TimeTicks.
+  enum class Clock {
+    FUCHSIA_ZX_CLOCK_MONOTONIC,
+    LINUX_CLOCK_MONOTONIC,
+    IOS_CF_ABSOLUTE_TIME_MINUS_KERN_BOOTTIME,
+    MAC_MACH_ABSOLUTE_TIME,
+    WIN_QPC,
+    WIN_ROLLOVER_PROTECTED_TIME_GET_TIME
+  };
+
+  constexpr TimeTicks() : TimeBase(0) {}
+
+  // Platform-dependent tick count representing "right now." When
+  // IsHighResolution() returns false, the resolution of the clock could be
+  // as coarse as ~15.6ms. Otherwise, the resolution should be no worse than one
+  // microsecond.
+  static TimeTicks Now();
+
+  // Returns true if the high resolution clock is working on this system and
+  // Now() will return high resolution values. Note that, on systems where the
+  // high resolution clock works but is deemed inefficient, the low resolution
+  // clock will be used instead.
+  static bool IsHighResolution() WARN_UNUSED_RESULT;
+
+  // Returns true if TimeTicks is consistent across processes, meaning that
+  // timestamps taken on different processes can be safely compared with one
+  // another. (Note that, even on platforms where this returns true, time values
+  // from different threads that are within one tick of each other must be
+  // considered to have an ambiguous ordering.)
+  static bool IsConsistentAcrossProcesses() WARN_UNUSED_RESULT;
+
+#if defined(OS_FUCHSIA)
+  // Converts between TimeTicks and an ZX_CLOCK_MONOTONIC zx_time_t value.
+  static TimeTicks FromZxTime(zx_time_t nanos_since_boot);
+  zx_time_t ToZxTime() const;
+#endif
+
+#if defined(OS_WIN)
+  // Translates an absolute QPC timestamp into a TimeTicks value. The returned
+  // value has the same origin as Now(). Do NOT attempt to use this if
+  // IsHighResolution() returns false.
+  static TimeTicks FromQPCValue(LONGLONG qpc_value);
+#endif
+
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  static TimeTicks FromMachAbsoluteTime(uint64_t mach_absolute_time);
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+
+#if defined(OS_ANDROID)
+  // Converts to TimeTicks the value obtained from SystemClock.uptimeMillis().
+  // Note: this convertion may be non-monotonic in relation to previously
+  // obtained TimeTicks::Now() values because of the truncation (to
+  // milliseconds) performed by uptimeMillis().
+  static TimeTicks FromUptimeMillis(jlong uptime_millis_value);
+#endif
+
+  // Get an estimate of the TimeTick value at the time of the UnixEpoch. Because
+  // Time and TimeTicks respond differently to user-set time and NTP
+  // adjustments, this number is only an estimate. Nevertheless, this can be
+  // useful when you need to relate the value of TimeTicks to a real time and
+  // date. Note: Upon first invocation, this function takes a snapshot of the
+  // realtime clock to establish a reference point.  This function will return
+  // the same value for the duration of the application, but will be different
+  // in future application runs.
+  static TimeTicks UnixEpoch();
+
+  // Returns |this| snapped to the next tick, given a |tick_phase| and
+  // repeating |tick_interval| in both directions. |this| may be before,
+  // after, or equal to the |tick_phase|.
+  TimeTicks SnappedToNextTick(TimeTicks tick_phase,
+                              TimeDelta tick_interval) const;
+
+  // Returns an enum indicating the underlying clock being used to generate
+  // TimeTicks timestamps. This function should only be used for debugging and
+  // logging purposes.
+  static Clock GetClock();
+
+  // Converts an integer value representing TimeTicks to a class. This may be
+  // used when deserializing a |TimeTicks| structure, using a value known to be
+  // compatible. It is not provided as a constructor because the integer type
+  // may be unclear from the perspective of a caller.
+  //
+  // DEPRECATED - Do not use in new code. For deserializing TimeTicks values,
+  // prefer TimeTicks + TimeDelta(). http://crbug.com/634507
+  static constexpr TimeTicks FromInternalValue(int64_t us) {
+    return TimeTicks(us);
+  }
+
+#if defined(OS_WIN)
+ protected:
+  typedef DWORD (*TickFunctionType)(void);
+  static TickFunctionType SetMockTickFunction(TickFunctionType ticker);
+#endif
+
+ private:
+  friend class time_internal::TimeBase<TimeTicks>;
+
+  // Please use Now() to create a new object. This is for internal use
+  // and testing.
+  constexpr explicit TimeTicks(int64_t us) : TimeBase(us) {}
+};
+
+// For logging use only.
+BASE_EXPORT std::ostream& operator<<(std::ostream& os, TimeTicks time_ticks);
+
+// ThreadTicks ----------------------------------------------------------------
+
+// Represents a clock, specific to a particular thread, than runs only while the
+// thread is running.
+class BASE_EXPORT ThreadTicks : public time_internal::TimeBase<ThreadTicks> {
+ public:
+  ThreadTicks() : TimeBase(0) {
+  }
+
+  // Returns true if ThreadTicks::Now() is supported on this system.
+  static bool IsSupported() WARN_UNUSED_RESULT {
+#if (defined(_POSIX_THREAD_CPUTIME) && (_POSIX_THREAD_CPUTIME >= 0)) || \
+    (defined(OS_MACOSX) && !defined(OS_IOS)) || defined(OS_ANDROID) ||  \
+    defined(OS_FUCHSIA)
+    return true;
+#elif defined(OS_WIN)
+    return IsSupportedWin();
+#else
+    return false;
+#endif
+  }
+
+  // Waits until the initialization is completed. Needs to be guarded with a
+  // call to IsSupported().
+  static void WaitUntilInitialized() {
+#if defined(OS_WIN)
+    WaitUntilInitializedWin();
+#endif
+  }
+
+  // Returns thread-specific CPU-time on systems that support this feature.
+  // Needs to be guarded with a call to IsSupported(). Use this timer
+  // to (approximately) measure how much time the calling thread spent doing
+  // actual work vs. being de-scheduled. May return bogus results if the thread
+  // migrates to another CPU between two calls. Returns an empty ThreadTicks
+  // object until the initialization is completed. If a clock reading is
+  // absolutely needed, call WaitUntilInitialized() before this method.
+  static ThreadTicks Now();
+
+#if defined(OS_WIN)
+  // Similar to Now() above except this returns thread-specific CPU time for an
+  // arbitrary thread. All comments for Now() method above apply apply to this
+  // method as well.
+  static ThreadTicks GetForThread(const PlatformThreadHandle& thread_handle);
+#endif
+
+  // Converts an integer value representing ThreadTicks to a class. This may be
+  // used when deserializing a |ThreadTicks| structure, using a value known to
+  // be compatible. It is not provided as a constructor because the integer type
+  // may be unclear from the perspective of a caller.
+  //
+  // DEPRECATED - Do not use in new code. For deserializing ThreadTicks values,
+  // prefer ThreadTicks + TimeDelta(). http://crbug.com/634507
+  static constexpr ThreadTicks FromInternalValue(int64_t us) {
+    return ThreadTicks(us);
+  }
+
+ private:
+  friend class time_internal::TimeBase<ThreadTicks>;
+
+  // Please use Now() or GetForThread() to create a new object. This is for
+  // internal use and testing.
+  constexpr explicit ThreadTicks(int64_t us) : TimeBase(us) {}
+
+#if defined(OS_WIN)
+  FRIEND_TEST_ALL_PREFIXES(TimeTicks, TSCTicksPerSecond);
+
+  // Returns the frequency of the TSC in ticks per second, or 0 if it hasn't
+  // been measured yet. Needs to be guarded with a call to IsSupported().
+  // This method is declared here rather than in the anonymous namespace to
+  // allow testing.
+  static double TSCTicksPerSecond();
+
+  static bool IsSupportedWin() WARN_UNUSED_RESULT;
+  static void WaitUntilInitializedWin();
+#endif
+};
+
+// For logging use only.
+BASE_EXPORT std::ostream& operator<<(std::ostream& os, ThreadTicks time_ticks);
+
+}  // namespace base
+
+#endif  // BASE_TIME_TIME_H_
diff --git a/native/zucchini/vendor/libchrome/base/time/time_now_posix.cc b/native/zucchini/vendor/libchrome/base/time/time_now_posix.cc
new file mode 100644
index 0000000..5427836
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/time/time_now_posix.cc
@@ -0,0 +1,123 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/time/time.h"
+
+#include <stdint.h>
+#include <sys/time.h>
+#include <time.h>
+#if defined(OS_ANDROID) && !defined(__LP64__)
+#include <time64.h>
+#endif
+#include <unistd.h>
+
+#include "base/logging.h"
+#include "base/numerics/safe_math.h"
+#include "base/time/time_override.h"
+#include "build/build_config.h"
+
+// Ensure the Fuchsia and Mac builds do not include this module. Instead,
+// non-POSIX implementation is used for sampling the system clocks.
+#if defined(OS_FUCHSIA) || defined(OS_MACOSX)
+#error "This implementation is for POSIX platforms other than Fuchsia or Mac."
+#endif
+
+namespace {
+
+int64_t ConvertTimespecToMicros(const struct timespec& ts) {
+  // On 32-bit systems, the calculation cannot overflow int64_t.
+  // 2**32 * 1000000 + 2**64 / 1000 < 2**63
+  if (sizeof(ts.tv_sec) <= 4 && sizeof(ts.tv_nsec) <= 8) {
+    int64_t result = ts.tv_sec;
+    result *= base::Time::kMicrosecondsPerSecond;
+    result += (ts.tv_nsec / base::Time::kNanosecondsPerMicrosecond);
+    return result;
+  } else {
+    base::CheckedNumeric<int64_t> result(ts.tv_sec);
+    result *= base::Time::kMicrosecondsPerSecond;
+    result += (ts.tv_nsec / base::Time::kNanosecondsPerMicrosecond);
+    return result.ValueOrDie();
+  }
+}
+
+// Helper function to get results from clock_gettime() and convert to a
+// microsecond timebase. Minimum requirement is MONOTONIC_CLOCK to be supported
+// on the system. FreeBSD 6 has CLOCK_MONOTONIC but defines
+// _POSIX_MONOTONIC_CLOCK to -1.
+#if (defined(OS_POSIX) && defined(_POSIX_MONOTONIC_CLOCK) && \
+     _POSIX_MONOTONIC_CLOCK >= 0) ||                         \
+    defined(OS_BSD) || defined(OS_ANDROID)
+int64_t ClockNow(clockid_t clk_id) {
+  struct timespec ts;
+  CHECK(clock_gettime(clk_id, &ts) == 0);
+  return ConvertTimespecToMicros(ts);
+}
+#else  // _POSIX_MONOTONIC_CLOCK
+#error No usable tick clock function on this platform.
+#endif  // _POSIX_MONOTONIC_CLOCK
+
+}  // namespace
+
+namespace base {
+
+// Time -----------------------------------------------------------------------
+
+namespace subtle {
+Time TimeNowIgnoringOverride() {
+  struct timeval tv;
+  struct timezone tz = {0, 0};  // UTC
+  CHECK(gettimeofday(&tv, &tz) == 0);
+  // Combine seconds and microseconds in a 64-bit field containing microseconds
+  // since the epoch.  That's enough for nearly 600 centuries.  Adjust from
+  // Unix (1970) to Windows (1601) epoch.
+  return Time() + TimeDelta::FromMicroseconds(
+                      (tv.tv_sec * Time::kMicrosecondsPerSecond + tv.tv_usec) +
+                      Time::kTimeTToMicrosecondsOffset);
+}
+
+Time TimeNowFromSystemTimeIgnoringOverride() {
+  // Just use TimeNowIgnoringOverride() because it returns the system time.
+  return TimeNowIgnoringOverride();
+}
+}  // namespace subtle
+
+// TimeTicks ------------------------------------------------------------------
+
+namespace subtle {
+TimeTicks TimeTicksNowIgnoringOverride() {
+  return TimeTicks() + TimeDelta::FromMicroseconds(ClockNow(CLOCK_MONOTONIC));
+}
+}  // namespace subtle
+
+// static
+TimeTicks::Clock TimeTicks::GetClock() {
+  return Clock::LINUX_CLOCK_MONOTONIC;
+}
+
+// static
+bool TimeTicks::IsHighResolution() {
+  return true;
+}
+
+// static
+bool TimeTicks::IsConsistentAcrossProcesses() {
+  return true;
+}
+
+// ThreadTicks ----------------------------------------------------------------
+
+namespace subtle {
+ThreadTicks ThreadTicksNowIgnoringOverride() {
+#if (defined(_POSIX_THREAD_CPUTIME) && (_POSIX_THREAD_CPUTIME >= 0)) || \
+    defined(OS_ANDROID)
+  return ThreadTicks() +
+         TimeDelta::FromMicroseconds(ClockNow(CLOCK_THREAD_CPUTIME_ID));
+#else
+  NOTREACHED();
+  return ThreadTicks();
+#endif
+}
+}  // namespace subtle
+
+}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/time/time_override.h b/native/zucchini/vendor/libchrome/base/time/time_override.h
new file mode 100644
index 0000000..1586a87
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/time/time_override.h
@@ -0,0 +1,74 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_TIME_TIME_OVERRIDE_H_
+#define BASE_TIME_TIME_OVERRIDE_H_
+
+#include "base/base_export.h"
+#include "base/time/time.h"
+
+namespace base {
+
+using TimeNowFunction = decltype(&Time::Now);
+using TimeTicksNowFunction = decltype(&TimeTicks::Now);
+using ThreadTicksNowFunction = decltype(&ThreadTicks::Now);
+
+// Time overrides should be used with extreme caution. Discuss with //base/time
+// OWNERS before adding a new one.
+namespace subtle {
+
+// Override the return value of Time::Now and Time::NowFromSystemTime /
+// TimeTicks::Now / ThreadTicks::Now to emulate time, e.g. for tests or to
+// modify progression of time. Note that the override should be set while
+// single-threaded and before the first call to Now() to avoid threading issues
+// and inconsistencies in returned values. Nested overrides are not allowed.
+class BASE_EXPORT ScopedTimeClockOverrides {
+ public:
+  // Pass |nullptr| for any override if it shouldn't be overriden.
+  ScopedTimeClockOverrides(TimeNowFunction time_override,
+                           TimeTicksNowFunction time_ticks_override,
+                           ThreadTicksNowFunction thread_ticks_override);
+
+  // Restores the platform default Now() functions.
+  ~ScopedTimeClockOverrides();
+
+ private:
+#if DCHECK_IS_ON()
+  static bool overrides_active_;
+#endif
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedTimeClockOverrides);
+};
+
+// These methods return the platform default Time::Now / TimeTicks::Now /
+// ThreadTicks::Now values even while an override is in place. These methods
+// should only be used in places where emulated time should be disregarded. For
+// example, they can be used to implement test timeouts for tests that may
+// override time.
+BASE_EXPORT Time TimeNowIgnoringOverride();
+BASE_EXPORT Time TimeNowFromSystemTimeIgnoringOverride();
+BASE_EXPORT TimeTicks TimeTicksNowIgnoringOverride();
+BASE_EXPORT ThreadTicks ThreadTicksNowIgnoringOverride();
+
+}  // namespace subtle
+
+namespace internal {
+
+// These function pointers are used by platform-independent implementations of
+// the Now() methods and ScopedTimeClockOverrides. They are set to point to the
+// respective NowIgnoringOverride functions by default, but can also be set by
+// platform-specific code to select a default implementation at runtime, thereby
+// avoiding the indirection via the NowIgnoringOverride functions. Note that the
+// pointers can be overridden and later reset to the NowIgnoringOverride
+// functions by ScopedTimeClockOverrides.
+extern TimeNowFunction g_time_now_function;
+extern TimeNowFunction g_time_now_from_system_time_function;
+extern TimeTicksNowFunction g_time_ticks_now_function;
+extern ThreadTicksNowFunction g_thread_ticks_now_function;
+
+}  // namespace internal
+
+}  // namespace base
+
+#endif  // BASE_TIME_TIME_OVERRIDE_H_
diff --git a/native/zucchini/vendor/libchrome/base/token.h b/native/zucchini/vendor/libchrome/base/token.h
new file mode 100644
index 0000000..f12277e
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/token.h
@@ -0,0 +1,72 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_TOKEN_H_
+#define BASE_TOKEN_H_
+
+#include <stdint.h>
+
+#include <iosfwd>
+#include <tuple>
+
+#include "base/base_export.h"
+#include "base/hash.h"
+
+namespace base {
+
+// A Token is a randomly chosen 128-bit integer. This class supports generation
+// from a cryptographically strong random source, or constexpr construction over
+// fixed values (e.g. to store a pre-generated constant value). Tokens are
+// similar in spirit and purpose to UUIDs, without many of the constraints and
+// expectations (such as byte layout and string representation) clasically
+// associated with UUIDs.
+class BASE_EXPORT Token {
+ public:
+  // Constructs a zero Token.
+  constexpr Token() : high_(0), low_(0) {}
+
+  // Constructs a Token with |high| and |low| as its contents.
+  constexpr Token(uint64_t high, uint64_t low) : high_(high), low_(low) {}
+
+  // Constructs a new Token with random |high| and |low| values taken from a
+  // cryptographically strong random source.
+  static Token CreateRandom();
+
+  // The high and low 64 bits of this Token.
+  uint64_t high() const { return high_; }
+  uint64_t low() const { return low_; }
+
+  bool is_zero() const { return high_ == 0 && low_ == 0; }
+
+  bool operator==(const Token& other) const {
+    return high_ == other.high_ && low_ == other.low_;
+  }
+
+  bool operator!=(const Token& other) const { return !(*this == other); }
+
+  bool operator<(const Token& other) const {
+    return std::tie(high_, low_) < std::tie(other.high_, other.low_);
+  }
+
+  // Generates a string representation of this Token useful for e.g. logging.
+  std::string ToString() const;
+
+ private:
+  // Note: Two uint64_t are used instead of uint8_t[16] in order to have a
+  // simpler implementation, paricularly for |ToString()|, |is_zero()|, and
+  // constexpr value construction.
+  uint64_t high_;
+  uint64_t low_;
+};
+
+// For use in std::unordered_map.
+struct TokenHash {
+  size_t operator()(const base::Token& token) const {
+    return base::HashInts64(token.high(), token.low());
+  }
+};
+
+}  // namespace base
+
+#endif  // BASE_TOKEN_H_
\ No newline at end of file
diff --git a/native/zucchini/vendor/libchrome/base/unguessable_token.h b/native/zucchini/vendor/libchrome/base/unguessable_token.h
new file mode 100644
index 0000000..7f7b59a
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/unguessable_token.h
@@ -0,0 +1,116 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_UNGUESSABLE_TOKEN_H_
+#define BASE_UNGUESSABLE_TOKEN_H_
+
+#include <stdint.h>
+#include <string.h>
+#include <iosfwd>
+#include <tuple>
+
+#include "base/base_export.h"
+#include "base/hash.h"
+#include "base/logging.h"
+#include "base/token.h"
+
+namespace base {
+
+struct UnguessableTokenHash;
+
+// UnguessableToken is, like Token, a randomly chosen 128-bit value. Unlike
+// Token however, a new UnguessableToken must always be generated at runtime
+// from a cryptographically strong random source (or copied or serialized and
+// deserialized from another such UnguessableToken). It can be used as part of a
+// larger aggregate type, or as an ID in and of itself.
+//
+// UnguessableToken can be used to implement "Capability-Based Security".
+// In other words, UnguessableToken can be used when the resource associated
+// with the ID needs to be protected against manipulation by other untrusted
+// agents in the system, and there is no other convenient way to verify the
+// authority of the agent to do so (because the resource is part of a table
+// shared across processes, for instance). In such a scheme, knowledge of the
+// token value in and of itself is sufficient proof of authority to carry out
+// an operation against the associated resource.
+//
+// Use Create() for creating new UnguessableTokens.
+//
+// NOTE: It is illegal to send empty UnguessableTokens across processes, and
+// sending/receiving empty tokens should be treated as a security issue.
+// If there is a valid scenario for sending "no token" across processes,
+// base::Optional should be used instead of an empty token.
+class BASE_EXPORT UnguessableToken {
+ public:
+  // Create a unique UnguessableToken.
+  static UnguessableToken Create();
+
+  // Returns a reference to a global null UnguessableToken. This should only be
+  // used for functions that need to return a reference to an UnguessableToken,
+  // and should not be used as a general-purpose substitute for invoking the
+  // default constructor.
+  static const UnguessableToken& Null();
+
+  // Return a UnguessableToken built from the high/low bytes provided.
+  // It should only be used in deserialization scenarios.
+  //
+  // NOTE: If the deserialized token is empty, it means that it was never
+  // initialized via Create(). This is a security issue, and should be handled.
+  static UnguessableToken Deserialize(uint64_t high, uint64_t low);
+
+  // Creates an empty UnguessableToken.
+  // Assign to it with Create() before using it.
+  constexpr UnguessableToken() = default;
+
+  // NOTE: Serializing an empty UnguessableToken is an illegal operation.
+  uint64_t GetHighForSerialization() const {
+    DCHECK(!is_empty());
+    return token_.high();
+  }
+
+  // NOTE: Serializing an empty UnguessableToken is an illegal operation.
+  uint64_t GetLowForSerialization() const {
+    DCHECK(!is_empty());
+    return token_.low();
+  }
+
+  bool is_empty() const { return token_.is_zero(); }
+
+  // Hex representation of the unguessable token.
+  std::string ToString() const { return token_.ToString(); }
+
+  explicit operator bool() const { return !is_empty(); }
+
+  bool operator<(const UnguessableToken& other) const {
+    return token_ < other.token_;
+  }
+
+  bool operator==(const UnguessableToken& other) const {
+    return token_ == other.token_;
+  }
+
+  bool operator!=(const UnguessableToken& other) const {
+    return !(*this == other);
+  }
+
+ private:
+  friend struct UnguessableTokenHash;
+  explicit UnguessableToken(const Token& token);
+
+  base::Token token_;
+};
+
+BASE_EXPORT std::ostream& operator<<(std::ostream& out,
+                                     const UnguessableToken& token);
+
+// For use in std::unordered_map.
+struct UnguessableTokenHash {
+  size_t operator()(const base::UnguessableToken& token) const {
+    DCHECK(token);
+    return TokenHash()(token.token_);
+  }
+};
+
+}  // namespace base
+
+#endif  // BASE_UNGUESSABLE_TOKEN_H_
diff --git a/native/zucchini/vendor/libchrome/base/vlog.h b/native/zucchini/vendor/libchrome/base/vlog.h
new file mode 100644
index 0000000..2950904
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/base/vlog.h
@@ -0,0 +1,77 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_VLOG_H_
+#define BASE_VLOG_H_
+
+#include <string>
+#include <vector>
+
+#include "base/base_export.h"
+#include "base/macros.h"
+#include "base/strings/string_piece.h"
+
+namespace logging {
+
+// A helper class containing all the settings for vlogging.
+class BASE_EXPORT VlogInfo {
+ public:
+  static const int kDefaultVlogLevel;
+
+  // |v_switch| gives the default maximal active V-logging level; 0 is
+  // the default.  Normally positive values are used for V-logging
+  // levels.
+  //
+  // |vmodule_switch| gives the per-module maximal V-logging levels to
+  // override the value given by |v_switch|.
+  // E.g. "my_module=2,foo*=3" would change the logging level for all
+  // code in source files "my_module.*" and "foo*.*" ("-inl" suffixes
+  // are also disregarded for this matching).
+  //
+  // |log_severity| points to an int that stores the log level. If a valid
+  // |v_switch| is provided, it will set the log level, and the default
+  // vlog severity will be read from there..
+  //
+  // Any pattern containing a forward or backward slash will be tested
+  // against the whole pathname and not just the module.  E.g.,
+  // "*/foo/bar/*=2" would change the logging level for all code in
+  // source files under a "foo/bar" directory.
+  VlogInfo(const std::string& v_switch,
+           const std::string& vmodule_switch,
+           int* min_log_level);
+  ~VlogInfo();
+
+  // Returns the vlog level for a given file (usually taken from
+  // __FILE__).
+  int GetVlogLevel(const base::StringPiece& file) const;
+
+ private:
+  void SetMaxVlogLevel(int level);
+  int GetMaxVlogLevel() const;
+
+  // VmodulePattern holds all the information for each pattern parsed
+  // from |vmodule_switch|.
+  struct VmodulePattern;
+  std::vector<VmodulePattern> vmodule_levels_;
+  int* min_log_level_;
+
+  DISALLOW_COPY_AND_ASSIGN(VlogInfo);
+};
+
+// Returns true if the string passed in matches the vlog pattern.  The
+// vlog pattern string can contain wildcards like * and ?.  ? matches
+// exactly one character while * matches 0 or more characters.  Also,
+// as a special case, a / or \ character matches either / or \.
+//
+// Examples:
+//   "kh?n" matches "khan" but not "khn" or "khaan"
+//   "kh*n" matches "khn", "khan", or even "khaaaaan"
+//   "/foo\bar" matches "/foo/bar", "\foo\bar", or "/foo\bar"
+//     (disregarding C escaping rules)
+BASE_EXPORT bool MatchVlogPattern(const base::StringPiece& string,
+                                  const base::StringPiece& vlog_pattern);
+
+}  // namespace logging
+
+#endif  // BASE_VLOG_H_
diff --git a/native/zucchini/vendor/libchrome/build/build_config.h b/native/zucchini/vendor/libchrome/build/build_config.h
new file mode 100644
index 0000000..4dbc69d
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/build/build_config.h
@@ -0,0 +1,263 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file adds defines about the platform we're currently building on.
+//  Operating System:
+//    OS_WIN / OS_MACOSX / OS_LINUX / OS_POSIX (MACOSX or LINUX) /
+//    OS_NACL (NACL_SFI or NACL_NONSFI) / OS_NACL_SFI / OS_NACL_NONSFI
+//    OS_CHROMEOS is set by the build system
+//  Compiler:
+//    COMPILER_MSVC / COMPILER_GCC
+//  Processor:
+//    ARCH_CPU_ARM64 / ARCH_CPU_ARMEL / ARCH_CPU_LOONG32 / ARCH_CPU_LOONG64 /
+//    ARCH_CPU_MIPS / ARCH_CPU_MIPS64 / ARCH_CPU_MIPS64EL / ARCH_CPU_MIPSEL /
+//    ARCH_CPU_PPC64 / ARCH_CPU_S390 / ARCH_CPU_S390X / ARCH_CPU_X86 /
+//    ARCH_CPU_X86_64 / ARCH_CPU_RISCV64
+//  Processor family:
+//    ARCH_CPU_ARM_FAMILY: ARMEL or ARM64
+//    ARCH_CPU_LOONG_FAMILY: LOONG32 or LOONG64
+//    ARCH_CPU_MIPS_FAMILY: MIPS64EL or MIPSEL or MIPS64 or MIPS
+//    ARCH_CPU_PPC64_FAMILY: PPC64
+//    ARCH_CPU_S390_FAMILY: S390 or S390X
+//    ARCH_CPU_X86_FAMILY: X86 or X86_64
+//    ARCH_CPU_RISCV_FAMILY: Riscv64
+//  Processor features:
+//    ARCH_CPU_31_BITS / ARCH_CPU_32_BITS / ARCH_CPU_64_BITS
+//    ARCH_CPU_BIG_ENDIAN / ARCH_CPU_LITTLE_ENDIAN
+
+#ifndef BUILD_BUILD_CONFIG_H_
+#define BUILD_BUILD_CONFIG_H_
+
+// A brief primer on #defines:
+//
+// - __ANDROID__ is automatically defined by the Android toolchain (see
+//   https://goo.gl/v61lXa). It's not defined when building host code.
+// - __ANDROID_HOST__ is defined via -D by Android.mk when building host code
+//   within an Android checkout.
+// - ANDROID is defined via -D when building code for either Android targets or
+//   hosts. Use __ANDROID__ and __ANDROID_HOST__ instead.
+// - OS_ANDROID is a define used to build Chrome for Android within the NDK and
+//   to build Android targets.
+
+// Android targets and hosts don't use tcmalloc.
+#if defined(__ANDROID__) || defined(__ANDROID_HOST__)
+#define NO_TCMALLOC
+#endif  // defined(__ANDROID__) || defined(__ANDROID_HOST__)
+
+#if defined(__ANDROID__)  // Android targets
+
+#define OS_ANDROID 1
+
+#elif !defined(__ANDROID_HOST__)  // Chrome OS
+
+#define OS_CHROMEOS 1
+// TODO: Remove these once the GLib MessageLoopForUI isn't being used:
+// https://crbug.com/361635
+#define USE_GLIB 1
+#define USE_OZONE 1
+
+#endif  // defined(__ANDROID__)
+
+// A set of macros to use for platform detection.
+#if defined(__native_client__)
+// __native_client__ must be first, so that other OS_ defines are not set.
+#define OS_NACL 1
+// OS_NACL comes in two sandboxing technology flavors, SFI or Non-SFI.
+// PNaCl toolchain defines __native_client_nonsfi__ macro in Non-SFI build
+// mode, while it does not in SFI build mode.
+#if defined(__native_client_nonsfi__)
+#define OS_NACL_NONSFI
+#else
+#define OS_NACL_SFI
+#endif
+#elif defined(__APPLE__)
+// only include TargetConditions after testing ANDROID as some android builds
+// on mac don't have this header available and it's not needed unless the target
+// is really mac/ios.
+#include <TargetConditionals.h>
+#define OS_MACOSX 1
+#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
+#define OS_IOS 1
+#endif  // defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
+#elif defined(__linux__)
+#define OS_LINUX 1
+// include a system header to pull in features.h for glibc/uclibc macros.
+#include <unistd.h>
+#if defined(__GLIBC__) && !defined(__UCLIBC__)
+// we really are using glibc, not uClibc pretending to be glibc
+#define LIBC_GLIBC 1
+#endif
+#elif defined(_WIN32)
+#define OS_WIN 1
+#elif defined(__Fuchsia__)
+#define OS_FUCHSIA 1
+#elif defined(__FreeBSD__)
+#define OS_FREEBSD 1
+#elif defined(__NetBSD__)
+#define OS_NETBSD 1
+#elif defined(__OpenBSD__)
+#define OS_OPENBSD 1
+#elif defined(__sun)
+#define OS_SOLARIS 1
+#elif defined(__QNXNTO__)
+#define OS_QNX 1
+#elif defined(_AIX)
+#define OS_AIX 1
+#elif defined(__asmjs__)
+#define OS_ASMJS
+#else
+#error Please add support for your platform in build/build_config.h
+#endif
+// NOTE: Adding a new port? Please follow
+// https://chromium.googlesource.com/chromium/src/+/master/docs/new_port_policy.md
+
+// For access to standard BSD features, use OS_BSD instead of a
+// more specific macro.
+#if defined(OS_FREEBSD) || defined(OS_NETBSD) || defined(OS_OPENBSD)
+#define OS_BSD 1
+#endif
+
+// For access to standard POSIXish features, use OS_POSIX instead of a
+// more specific macro.
+#if defined(OS_AIX) || defined(OS_ANDROID) || defined(OS_ASMJS) ||    \
+    defined(OS_FREEBSD) || defined(OS_LINUX) || defined(OS_MACOSX) || \
+    defined(OS_NACL) || defined(OS_NETBSD) || defined(OS_OPENBSD) ||  \
+    defined(OS_QNX) || defined(OS_SOLARIS)
+#define OS_POSIX 1
+#endif
+
+// Use tcmalloc
+#if (defined(OS_WIN) || defined(OS_LINUX) || defined(OS_ANDROID)) && \
+    !defined(NO_TCMALLOC)
+#define USE_TCMALLOC 1
+#endif
+
+// Compiler detection.
+#if defined(__GNUC__)
+#define COMPILER_GCC 1
+#elif defined(_MSC_VER)
+#define COMPILER_MSVC 1
+#else
+#error Please add support for your compiler in build/build_config.h
+#endif
+
+// Processor architecture detection.  For more info on what's defined, see:
+//   http://msdn.microsoft.com/en-us/library/b0084kay.aspx
+//   http://www.agner.org/optimize/calling_conventions.pdf
+//   or with gcc, run: "echo | gcc -E -dM -"
+#if defined(_M_X64) || defined(__x86_64__)
+#define ARCH_CPU_X86_FAMILY 1
+#define ARCH_CPU_X86_64 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_LITTLE_ENDIAN 1
+#elif defined(_M_IX86) || defined(__i386__)
+#define ARCH_CPU_X86_FAMILY 1
+#define ARCH_CPU_X86 1
+#define ARCH_CPU_32_BITS 1
+#define ARCH_CPU_LITTLE_ENDIAN 1
+#elif defined(__s390x__)
+#define ARCH_CPU_S390_FAMILY 1
+#define ARCH_CPU_S390X 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_BIG_ENDIAN 1
+#elif defined(__s390__)
+#define ARCH_CPU_S390_FAMILY 1
+#define ARCH_CPU_S390 1
+#define ARCH_CPU_31_BITS 1
+#define ARCH_CPU_BIG_ENDIAN 1
+#elif (defined(__PPC64__) || defined(__PPC__)) && defined(__BIG_ENDIAN__)
+#define ARCH_CPU_PPC64_FAMILY 1
+#define ARCH_CPU_PPC64 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_BIG_ENDIAN 1
+#elif defined(__PPC64__)
+#define ARCH_CPU_PPC64_FAMILY 1
+#define ARCH_CPU_PPC64 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_LITTLE_ENDIAN 1
+#elif defined(__ARMEL__)
+#define ARCH_CPU_ARM_FAMILY 1
+#define ARCH_CPU_ARMEL 1
+#define ARCH_CPU_32_BITS 1
+#define ARCH_CPU_LITTLE_ENDIAN 1
+#elif defined(__aarch64__)
+#define ARCH_CPU_ARM_FAMILY 1
+#define ARCH_CPU_ARM64 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_LITTLE_ENDIAN 1
+#elif defined(__pnacl__) || defined(__asmjs__)
+#define ARCH_CPU_32_BITS 1
+#define ARCH_CPU_LITTLE_ENDIAN 1
+#elif defined(__MIPSEL__)
+#if defined(__LP64__)
+#define ARCH_CPU_MIPS_FAMILY 1
+#define ARCH_CPU_MIPS64EL 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_LITTLE_ENDIAN 1
+#else
+#define ARCH_CPU_MIPS_FAMILY 1
+#define ARCH_CPU_MIPSEL 1
+#define ARCH_CPU_32_BITS 1
+#define ARCH_CPU_LITTLE_ENDIAN 1
+#endif
+#elif defined(__MIPSEB__)
+#if defined(__LP64__)
+#define ARCH_CPU_MIPS_FAMILY 1
+#define ARCH_CPU_MIPS64 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_BIG_ENDIAN 1
+#else
+#define ARCH_CPU_MIPS_FAMILY 1
+#define ARCH_CPU_MIPS 1
+#define ARCH_CPU_32_BITS 1
+#define ARCH_CPU_BIG_ENDIAN 1
+#endif
+#elif defined(__loongarch32)
+#define ARCH_CPU_LOONG_FAMILY 1
+#define ARCH_CPU_LOONG32 1
+#define ARCH_CPU_32_BITS 1
+#define ARCH_CPU_LITTLE_ENDIAN 1
+#elif defined(__loongarch64)
+#define ARCH_CPU_LOONG_FAMILY 1
+#define ARCH_CPU_LOONG64 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_LITTLE_ENDIAN 1
+#elif defined(__riscv) && (__riscv_xlen == 64)
+#define ARCH_CPU_RISCV_FAMILY 1
+#define ARCH_CPU_RISCV64 1
+#define ARCH_CPU_64_BITS 1
+#define ARCH_CPU_LITTLE_ENDIAN 1
+#else
+#error Please add support for your architecture in build/build_config.h
+#endif
+
+// Type detection for wchar_t.
+#if defined(OS_WIN)
+#define WCHAR_T_IS_UTF16
+#elif defined(OS_FUCHSIA)
+#define WCHAR_T_IS_UTF32
+#elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
+    (__WCHAR_MAX__ == 0x7fffffff || __WCHAR_MAX__ == 0xffffffff)
+#define WCHAR_T_IS_UTF32
+#elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
+    (__WCHAR_MAX__ == 0x7fff || __WCHAR_MAX__ == 0xffff)
+// On Posix, we'll detect short wchar_t, but projects aren't guaranteed to
+// compile in this mode (in particular, Chrome doesn't). This is intended for
+// other projects using base who manage their own dependencies and make sure
+// short wchar works for them.
+#define WCHAR_T_IS_UTF16
+#else
+#error Please add support for your compiler in build/build_config.h
+#endif
+
+#if defined(OS_ANDROID)
+// The compiler thinks std::string::const_iterator and "const char*" are
+// equivalent types.
+#define STD_STRING_ITERATOR_IS_CHAR_POINTER
+// The compiler thinks base::string16::const_iterator and "char16*" are
+// equivalent types.
+#define BASE_STRING16_ITERATOR_IS_CHAR16_POINTER
+#endif
+
+#endif  // BUILD_BUILD_CONFIG_H_
diff --git a/native/zucchini/vendor/libchrome/testing/gtest/include/gtest/gtest_prod.h b/native/zucchini/vendor/libchrome/testing/gtest/include/gtest/gtest_prod.h
new file mode 100644
index 0000000..00174fc
--- /dev/null
+++ b/native/zucchini/vendor/libchrome/testing/gtest/include/gtest/gtest_prod.h
@@ -0,0 +1 @@
+#include <gtest/gtest_prod.h>
diff --git a/native/zucchini/vendor/zucchini/LICENSE b/native/zucchini/vendor/zucchini/LICENSE
new file mode 100644
index 0000000..a32e00c
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/LICENSE
@@ -0,0 +1,27 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/native/zucchini/vendor/zucchini/MODULE_LICENSE_CHROME b/native/zucchini/vendor/zucchini/MODULE_LICENSE_CHROME
new file mode 100644
index 0000000..e69de29
diff --git a/native/zucchini/vendor/zucchini/abs32_utils.cc b/native/zucchini/vendor/zucchini/abs32_utils.cc
new file mode 100644
index 0000000..27e7e11
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/abs32_utils.cc
@@ -0,0 +1,211 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/abs32_utils.h"
+
+#include <algorithm>
+#include <type_traits>
+#include <utility>
+
+#include "base/check_op.h"
+#include "components/zucchini/io_utils.h"
+
+namespace zucchini {
+
+namespace {
+
+// Templated helper for AbsoluteAddress::Read().
+template <typename T>
+bool ReadAbs(ConstBufferView image, offset_t offset, uint64_t* value) {
+  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned.");
+  if (!image.can_access<T>(offset))
+    return false;
+  *value = static_cast<uint64_t>(image.read<T>(offset));
+  return true;
+}
+
+// Templated helper for AbsoluteAddress::Write().
+template <typename T>
+bool WriteAbs(offset_t offset, T value, MutableBufferView* image) {
+  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned.");
+  if (!image->can_access<T>(offset))
+    return false;
+  image->write<T>(offset, value);
+  return true;
+}
+
+}  // namespace
+
+/******** AbsoluteAddress ********/
+
+AbsoluteAddress::AbsoluteAddress(Bitness bitness, uint64_t image_base)
+    : bitness_(bitness), image_base_(image_base), value_(image_base) {
+  CHECK(bitness_ == kBit64 || image_base_ < 0x100000000ULL);
+}
+
+AbsoluteAddress::AbsoluteAddress(AbsoluteAddress&&) = default;
+
+AbsoluteAddress::~AbsoluteAddress() = default;
+
+bool AbsoluteAddress::FromRva(rva_t rva) {
+  if (rva >= kRvaBound)
+    return false;
+  uint64_t value = image_base_ + rva;
+  // Check overflow, which manifests as |value| "wrapping around", resulting in
+  // |value| less than |image_base_| (preprocessing needed for 32-bit).
+  if (((bitness_ == kBit32) ? (value & 0xFFFFFFFFU) : value) < image_base_)
+    return false;
+  value_ = value;
+  return true;
+}
+
+rva_t AbsoluteAddress::ToRva() const {
+  if (value_ < image_base_)
+    return kInvalidRva;
+  uint64_t raw_rva = value_ - image_base_;
+  if (raw_rva >= kRvaBound)
+    return kInvalidRva;
+  return static_cast<rva_t>(raw_rva);
+}
+
+bool AbsoluteAddress::Read(offset_t offset, const ConstBufferView& image) {
+  // Read raw data; |value_| is not guaranteed to represent a valid RVA.
+  if (bitness_ == kBit32)
+    return ReadAbs<uint32_t>(image, offset, &value_);
+  DCHECK_EQ(kBit64, bitness_);
+  return ReadAbs<uint64_t>(image, offset, &value_);
+}
+
+bool AbsoluteAddress::Write(offset_t offset, MutableBufferView* image) {
+  if (bitness_ == kBit32)
+    return WriteAbs<uint32_t>(offset, static_cast<uint32_t>(value_), image);
+  DCHECK_EQ(kBit64, bitness_);
+  return WriteAbs<uint64_t>(offset, value_, image);
+}
+
+/******** Abs32RvaExtractorWin32 ********/
+
+Abs32RvaExtractorWin32::Abs32RvaExtractorWin32(
+    ConstBufferView image,
+    AbsoluteAddress&& addr,
+    const std::vector<offset_t>& abs32_locations,
+    offset_t lo,
+    offset_t hi)
+    : image_(image), addr_(std::move(addr)) {
+  CHECK_LE(lo, hi);
+  auto find_and_check = [this](const std::vector<offset_t>& locations,
+                               offset_t offset) {
+    auto it = std::lower_bound(locations.begin(), locations.end(), offset);
+    // Ensure that |offset| does not straddle a reference body.
+    CHECK(it == locations.begin() || offset - *(it - 1) >= addr_.width());
+    return it;
+  };
+  cur_abs32_ = find_and_check(abs32_locations, lo);
+  end_abs32_ = find_and_check(abs32_locations, hi);
+}
+
+Abs32RvaExtractorWin32::Abs32RvaExtractorWin32(Abs32RvaExtractorWin32&&) =
+    default;
+
+Abs32RvaExtractorWin32::~Abs32RvaExtractorWin32() = default;
+
+std::optional<Abs32RvaExtractorWin32::Unit> Abs32RvaExtractorWin32::GetNext() {
+  while (cur_abs32_ < end_abs32_) {
+    offset_t location = *(cur_abs32_++);
+    if (!addr_.Read(location, image_))
+      continue;
+    rva_t target_rva = addr_.ToRva();
+    if (target_rva == kInvalidRva)
+      continue;
+    return Unit{location, target_rva};
+  }
+  return std::nullopt;
+}
+
+/******** Abs32ReaderWin32 ********/
+
+Abs32ReaderWin32::Abs32ReaderWin32(Abs32RvaExtractorWin32&& abs32_rva_extractor,
+                                   const AddressTranslator& translator)
+    : abs32_rva_extractor_(std::move(abs32_rva_extractor)),
+      target_rva_to_offset_(translator) {}
+
+Abs32ReaderWin32::~Abs32ReaderWin32() = default;
+
+std::optional<Reference> Abs32ReaderWin32::GetNext() {
+  for (auto unit = abs32_rva_extractor_.GetNext(); unit.has_value();
+       unit = abs32_rva_extractor_.GetNext()) {
+    offset_t location = unit->location;
+    offset_t unsafe_target = target_rva_to_offset_.Convert(unit->target_rva);
+    if (unsafe_target != kInvalidOffset)
+      return Reference{location, unsafe_target};
+  }
+  return std::nullopt;
+}
+
+/******** Abs32WriterWin32 ********/
+
+Abs32WriterWin32::Abs32WriterWin32(MutableBufferView image,
+                                   AbsoluteAddress&& addr,
+                                   const AddressTranslator& translator)
+    : image_(image),
+      addr_(std::move(addr)),
+      target_offset_to_rva_(translator) {}
+
+Abs32WriterWin32::~Abs32WriterWin32() = default;
+
+void Abs32WriterWin32::PutNext(Reference ref) {
+  rva_t target_rva = target_offset_to_rva_.Convert(ref.target);
+  if (target_rva != kInvalidRva) {
+    addr_.FromRva(target_rva);
+    addr_.Write(ref.location, &image_);
+  }
+}
+
+/******** Exported Functions ********/
+
+size_t RemoveUntranslatableAbs32(ConstBufferView image,
+                                 AbsoluteAddress&& addr,
+                                 const AddressTranslator& translator,
+                                 std::vector<offset_t>* locations) {
+  AddressTranslator::RvaToOffsetCache target_rva_checker(translator);
+  Abs32RvaExtractorWin32 extractor(image, std::move(addr), *locations, 0,
+                                   image.size());
+  Abs32ReaderWin32 reader(std::move(extractor), translator);
+  std::vector<offset_t>::iterator write_it = locations->begin();
+  // |reader| reads |locations| while |write_it| modifies it. However, there's
+  // no conflict since read occurs before write, and can skip ahead.
+  for (auto ref = reader.GetNext(); ref.has_value(); ref = reader.GetNext())
+    *(write_it++) = ref->location;
+  DCHECK(write_it <= locations->end());
+  size_t num_removed = locations->end() - write_it;
+  locations->erase(write_it, locations->end());
+  return num_removed;
+}
+
+size_t RemoveOverlappingAbs32Locations(uint32_t width,
+                                       std::vector<offset_t>* locations) {
+  if (locations->size() <= 1)
+    return 0;
+
+  auto slow = locations->begin();
+  auto fast = locations->begin() + 1;
+  for (;;) {
+    // Find next good location.
+    while (fast != locations->end() && *fast - *slow < width)
+      ++fast;
+    // Advance |slow|. For the last iteration this becomes the new sentinel.
+    ++slow;
+    if (fast == locations->end())
+      break;
+    // Compactify good locations (potentially overwrite bad locations).
+    if (slow != fast)
+      *slow = *fast;
+    ++fast;
+  }
+  size_t num_removed = locations->end() - slow;
+  locations->erase(slow, locations->end());
+  return num_removed;
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/address_translator.cc b/native/zucchini/vendor/zucchini/address_translator.cc
new file mode 100644
index 0000000..d7d7201
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/address_translator.cc
@@ -0,0 +1,258 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/address_translator.h"
+
+#include <algorithm>
+#include <utility>
+
+#include "base/containers/cxx20_erase.h"
+
+namespace zucchini {
+
+/******** AddressTranslator::OffsetToRvaCache ********/
+
+AddressTranslator::OffsetToRvaCache::OffsetToRvaCache(
+    const AddressTranslator& translator)
+    : translator_(translator) {}
+
+rva_t AddressTranslator::OffsetToRvaCache::Convert(offset_t offset) const {
+  if (offset >= translator_.fake_offset_begin_) {
+    // Rely on |translator_| to handle this special case.
+    return translator_.OffsetToRva(offset);
+  }
+  if (cached_unit_ && cached_unit_->CoversOffset(offset))
+    return cached_unit_->OffsetToRvaUnsafe(offset);
+  const AddressTranslator::Unit* unit = translator_.OffsetToUnit(offset);
+  if (!unit)
+    return kInvalidRva;
+  cached_unit_ = unit;
+  return unit->OffsetToRvaUnsafe(offset);
+}
+
+/******** AddressTranslator::RvaToOffsetCache ********/
+
+AddressTranslator::RvaToOffsetCache::RvaToOffsetCache(
+    const AddressTranslator& translator)
+    : translator_(translator) {}
+
+bool AddressTranslator::RvaToOffsetCache::IsValid(rva_t rva) const {
+  if (rva == kInvalidRva)
+    return false;
+  if (!cached_unit_ || !cached_unit_->CoversRva(rva)) {
+    const AddressTranslator::Unit* unit = translator_.RvaToUnit(rva);
+    if (!unit)
+      return false;
+    cached_unit_ = unit;
+  }
+  return true;
+}
+
+offset_t AddressTranslator::RvaToOffsetCache::Convert(rva_t rva) const {
+  if (!cached_unit_ || !cached_unit_->CoversRva(rva)) {
+    const AddressTranslator::Unit* unit = translator_.RvaToUnit(rva);
+    if (!unit)
+      return kInvalidOffset;
+    cached_unit_ = unit;
+  }
+  return cached_unit_->RvaToOffsetUnsafe(rva, translator_.fake_offset_begin_);
+}
+
+/******** AddressTranslator ********/
+
+AddressTranslator::AddressTranslator() = default;
+
+AddressTranslator::AddressTranslator(AddressTranslator&&) = default;
+
+AddressTranslator::~AddressTranslator() = default;
+
+AddressTranslator::Status AddressTranslator::Initialize(
+    std::vector<Unit>&& units) {
+  for (Unit& unit : units) {
+    // Check for overflows and fail if found.
+    if (!RangeIsBounded<offset_t>(unit.offset_begin, unit.offset_size,
+                                  kOffsetBound) ||
+        !RangeIsBounded<rva_t>(unit.rva_begin, unit.rva_size, kRvaBound)) {
+      return kErrorOverflow;
+    }
+    // If |rva_size < offset_size|: Just shrink |offset_size| to accommodate.
+    unit.offset_size = std::min(unit.offset_size, unit.rva_size);
+    // Now |rva_size >= offset_size|. Note that |rva_size > offset_size| is
+    // allowed; these lead to dangling RVA.
+  }
+
+  // Remove all empty units.
+  base::EraseIf(units, [](const Unit& unit) { return unit.IsEmpty(); });
+
+  // Sort |units| by RVA, then uniquefy.
+  std::sort(units.begin(), units.end(), [](const Unit& a, const Unit& b) {
+    return std::tie(a.rva_begin, a.rva_size) <
+           std::tie(b.rva_begin, b.rva_size);
+  });
+  units.erase(std::unique(units.begin(), units.end()), units.end());
+
+  // Scan for RVA range overlaps, validate, and merge wherever possible.
+  if (units.size() > 1) {
+    // Traverse with two iterators: |slow| stays behind and modifies Units that
+    // absorb all overlapping (or tangent if suitable) Units; |fast| explores
+    // new Units as candidates for consistency checks and potential merge into
+    // |slow|.
+    auto slow = units.begin();
+
+    // All |it| with |slow| < |it| < |fast| contain garbage.
+    for (auto fast = slow + 1; fast != units.end(); ++fast) {
+      // Comment notation: S = slow offset, F = fast offset, O = overlap offset,
+      // s = slow RVA, f = fast RVA, o = overlap RVA.
+      DCHECK_GE(fast->rva_begin, slow->rva_begin);
+      if (slow->rva_end() < fast->rva_begin) {
+        // ..ssssss..ffffff..: Disjoint: Can advance |slow|.
+        *(++slow) = *fast;
+        continue;
+      }
+
+      // ..ssssffff..: Tangent: Merge is optional.
+      // ..sssooofff.. / ..sssooosss..: Overlap: Merge is required.
+      bool merge_is_optional = slow->rva_end() == fast->rva_begin;
+
+      // Check whether |fast| and |slow| have identical RVA -> offset shift.
+      // If not, then merge cannot be resolved. Examples:
+      // ..ssssffff.. -> ..SSSSFFFF..: Good, can merge.
+      // ..ssssffff.. -> ..SSSS..FFFF..: Non-fatal: don't merge.
+      // ..ssssffff.. -> ..FFFF..SSSS..: Non-fatal: don't merge.
+      // ..ssssffff.. -> ..SSOOFF..: Fatal: Ignore for now (handled later).
+      // ..sssooofff.. -> ..SSSOOOFFF..: Good, can merge.
+      // ..sssooofff.. -> ..SSSSSOFFFFF..: Fatal.
+      // ..sssooofff.. -> ..FFOOOOSS..: Fatal.
+      // ..sssooofff.. -> ..SSSOOOF..: Good, notice |fast| has dangling RVAs.
+      // ..oooooo.. -> ..OOOOOO..: Good, can merge.
+      if (fast->offset_begin < slow->offset_begin ||
+          fast->offset_begin - slow->offset_begin !=
+              fast->rva_begin - slow->rva_begin) {
+        if (merge_is_optional) {
+          *(++slow) = *fast;
+          continue;
+        }
+        return kErrorBadOverlap;
+      }
+
+      // Check whether dangling RVAs (if they exist) are consistent. Examples:
+      // ..sssooofff.. -> ..SSSOOOF..: Good, can merge.
+      // ..sssooosss.. -> ..SSSOOOS..: Good, can merge.
+      // ..sssooofff.. -> ..SSSOO..: Good, can merge.
+      // ..sssooofff.. -> ..SSSOFFF..: Fatal.
+      // ..sssooosss.. -> ..SSSOOFFFF..: Fatal.
+      // ..oooooo.. -> ..OOO..: Good, can merge.
+      // Idea of check: Suppose |fast| has dangling RVA, then
+      // |[fast->rva_start, fast->rva_start + fast->offset_start)| ->
+      // |[fast->offset_start, **fast->offset_end()**)|, with remaining RVA
+      // mapping to fake offsets. This means |fast->offset_end()| must be >=
+      // |slow->offset_end()|, and failure to do so resluts in error. The
+      // argument for |slow| havng dangling RVA is symmetric.
+      if ((fast->HasDanglingRva() && fast->offset_end() < slow->offset_end()) ||
+          (slow->HasDanglingRva() && slow->offset_end() < fast->offset_end())) {
+        if (merge_is_optional) {
+          *(++slow) = *fast;
+          continue;
+        }
+        return kErrorBadOverlapDanglingRva;
+      }
+
+      // Merge |fast| into |slow|.
+      slow->rva_size =
+          std::max(slow->rva_size, fast->rva_end() - slow->rva_begin);
+      slow->offset_size =
+          std::max(slow->offset_size, fast->offset_end() - slow->offset_begin);
+    }
+    ++slow;
+    units.erase(slow, units.end());
+  }
+
+  // After resolving RVA overlaps, any offset overlap would imply error.
+  std::sort(units.begin(), units.end(), [](const Unit& a, const Unit& b) {
+    return a.offset_begin < b.offset_begin;
+  });
+
+  if (units.size() > 1) {
+    auto previous = units.begin();
+    for (auto current = previous + 1; current != units.end(); ++current) {
+      if (previous->offset_end() > current->offset_begin)
+        return kErrorBadOverlap;
+      previous = current;
+    }
+  }
+
+  // For to fake offset heuristics: Compute exclusive upper bounds for offsets
+  // and RVAs.
+  offset_t offset_bound = 0;
+  rva_t rva_bound = 0;
+  for (const Unit& unit : units) {
+    offset_bound = std::max(offset_bound, unit.offset_end());
+    rva_bound = std::max(rva_bound, unit.rva_end());
+  }
+
+  // Compute pessimistic range and see if it still fits within space of valid
+  // offsets. This limits image size to one half of |kOffsetBound|, and is a
+  // main drawback for the current heuristic to convert dangling RVA to fake
+  // offsets.
+  if (!RangeIsBounded(offset_bound, rva_bound, kOffsetBound))
+    return kErrorFakeOffsetBeginTooLarge;
+
+  // Success. Store results. |units| is currently sorted by offset, so assign.
+  units_sorted_by_offset_.assign(units.begin(), units.end());
+
+  // Sort |units| by RVA, and just store it directly
+  std::sort(units.begin(), units.end(), [](const Unit& a, const Unit& b) {
+    return a.rva_begin < b.rva_begin;
+  });
+  units_sorted_by_rva_ = std::move(units);
+
+  fake_offset_begin_ = offset_bound;
+  return kSuccess;
+}
+
+rva_t AddressTranslator::OffsetToRva(offset_t offset) const {
+  if (offset >= fake_offset_begin_) {
+    // Handle dangling RVA: First shift it to regular RVA space.
+    rva_t rva = offset - fake_offset_begin_;
+    // If result is indeed a dangling RVA, return it; else return |kInvalidRva|.
+    const Unit* unit = RvaToUnit(rva);
+    return (unit && unit->HasDanglingRva() && unit->CoversDanglingRva(rva))
+               ? rva
+               : kInvalidRva;
+  }
+  const Unit* unit = OffsetToUnit(offset);
+  return unit ? unit->OffsetToRvaUnsafe(offset) : kInvalidRva;
+}
+
+offset_t AddressTranslator::RvaToOffset(rva_t rva) const {
+  const Unit* unit = RvaToUnit(rva);
+  // This also handles dangling RVA.
+  return unit ? unit->RvaToOffsetUnsafe(rva, fake_offset_begin_)
+              : kInvalidOffset;
+}
+
+const AddressTranslator::Unit* AddressTranslator::OffsetToUnit(
+    offset_t offset) const {
+  // Finds first Unit with |offset_begin| > |offset|, rewind by 1 to find the
+  // last Unit with |offset_begin| >= |offset| (if it exists).
+  auto it = std::upper_bound(
+      units_sorted_by_offset_.begin(), units_sorted_by_offset_.end(), offset,
+      [](offset_t a, const Unit& b) { return a < b.offset_begin; });
+  if (it == units_sorted_by_offset_.begin())
+    return nullptr;
+  --it;
+  return it->CoversOffset(offset) ? &(*it) : nullptr;
+}
+
+const AddressTranslator::Unit* AddressTranslator::RvaToUnit(rva_t rva) const {
+  auto it = std::upper_bound(
+      units_sorted_by_rva_.begin(), units_sorted_by_rva_.end(), rva,
+      [](rva_t a, const Unit& b) { return a < b.rva_begin; });
+  if (it == units_sorted_by_rva_.begin())
+    return nullptr;
+  --it;
+  return it->CoversRva(rva) ? &(*it) : nullptr;
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/aosp/include/base/check.h b/native/zucchini/vendor/zucchini/aosp/include/base/check.h
new file mode 100644
index 0000000..3ed2e04
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/base/check.h
@@ -0,0 +1,22 @@
+//
+// Copyright (C) 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef __ZUCCHINI_AOSP_BASE_CHECK_H
+#define __ZUCCHINI_AOSP_BASE_CHECK_H
+
+#include <base/logging.h>
+
+#endif /* __ZUCCHINI_AOSP_BASE_CHECK_H */
diff --git a/native/zucchini/vendor/zucchini/aosp/include/base/check_op.h b/native/zucchini/vendor/zucchini/aosp/include/base/check_op.h
new file mode 100644
index 0000000..47162e6
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/base/check_op.h
@@ -0,0 +1,24 @@
+//
+// Copyright (C) 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef __ZUCCHINI_AOSP_BASE_CHECK_OP_H
+#define __ZUCCHINI_AOSP_BASE_CHECK_OP_H
+
+#include <base/logging.h>
+
+#define FLAG_WIN_SHARE_DELETE FLAG_SHARE_DELETE
+
+#endif /* __ZUCCHINI_AOSP_BASE_CHECK_OP_H */
diff --git a/native/zucchini/vendor/zucchini/aosp/include/base/containers/cxx20_erase.h b/native/zucchini/vendor/zucchini/aosp/include/base/containers/cxx20_erase.h
new file mode 100644
index 0000000..2fac314
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/base/containers/cxx20_erase.h
@@ -0,0 +1,22 @@
+//
+// Copyright (C) 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef __ZUCCHINI_AOSP_BASE_CONTAINERS_CXX20_ERASE_H
+#define __ZUCCHINI_AOSP_BASE_CONTAINERS_CXX20_ERASE_H
+
+#include <base/stl_util.h>
+
+#endif
diff --git a/native/zucchini/vendor/zucchini/aosp/include/build/buildflag.h b/native/zucchini/vendor/zucchini/aosp/include/build/buildflag.h
new file mode 100644
index 0000000..8d7c0e0
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/build/buildflag.h
@@ -0,0 +1,47 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BUILD_BUILDFLAG_H_
+#define BUILD_BUILDFLAG_H_
+
+// These macros un-mangle the names of the build flags in a way that looks
+// natural, and gives errors if the flag is not defined. Normally in the
+// preprocessor it's easy to make mistakes that interpret "you haven't done
+// the setup to know what the flag is" as "flag is off". Normally you would
+// include the generated header rather than include this file directly.
+//
+// This is for use with generated headers. See build/buildflag_header.gni.
+
+// This dance of two macros does a concatenation of two preprocessor args using
+// ## doubly indirectly because using ## directly prevents macros in that
+// parameter from being expanded.
+#define BUILDFLAG_CAT_INDIRECT(a, b) a##b
+#define BUILDFLAG_CAT(a, b) BUILDFLAG_CAT_INDIRECT(a, b)
+
+// Accessor for build flags.
+//
+// To test for a value, if the build file specifies:
+//
+//   ENABLE_FOO=true
+//
+// Then you would check at build-time in source code with:
+//
+//   #include "foo_flags.h"  // The header the build file specified.
+//
+//   #if BUILDFLAG(ENABLE_FOO)
+//     ...
+//   #endif
+//
+// There will no #define called ENABLE_FOO so if you accidentally test for
+// whether that is defined, it will always be negative. You can also use
+// the value in expressions:
+//
+//   const char kSpamServerName[] = BUILDFLAG(SPAM_SERVER_NAME);
+//
+// Because the flag is accessed as a preprocessor macro with (), an error
+// will be thrown if the proper header defining the internal flag value has
+// not been included.
+#define BUILDFLAG(flag) (BUILDFLAG_CAT(BUILDFLAG_INTERNAL_, flag)())
+
+#endif // BUILD_BUILDFLAG_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/abs32_utils.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/abs32_utils.h
new file mode 100644
index 0000000..ecdb61a
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/abs32_utils.h
@@ -0,0 +1,142 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_ABS32_UTILS_H_
+#define COMPONENTS_ZUCCHINI_ABS32_UTILS_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <optional>
+#include <vector>
+
+#include "components/zucchini/address_translator.h"
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/image_utils.h"
+
+namespace zucchini {
+
+// A class to represent an abs32 address (32-bit or 64-bit). Accessors are
+// provided to translate from / to RVA, and to read / write the represented
+// abs32 address from / to an image.
+class AbsoluteAddress {
+ public:
+  AbsoluteAddress(Bitness bitness, uint64_t image_base);
+  AbsoluteAddress(AbsoluteAddress&&);
+  ~AbsoluteAddress();
+
+  // Attempts to translate |rva| to an abs32 address. On success, assigns
+  // |value_| to the result and returns true. On failure (invalid |rva| or
+  // overflow), returns false.
+  bool FromRva(rva_t rva);
+
+  // Returns the RVA for |value_|, or |kInvalidRva| if the represented value
+  // address does not correspond to a valid RVA.
+  rva_t ToRva() const;
+
+  // Attempts to read the abs32 address at |image[offset]| into |value_|. On
+  // success, updates |value_| and returns true. On failure (invalid |offset|),
+  // returns false.
+  bool Read(offset_t offset, const ConstBufferView& image);
+
+  // Attempts to write |value_| to to |(*image)[offset]|. On success, performs
+  // the write and returns true. On failure (invalid |offset|), returns false.
+  bool Write(offset_t offset, MutableBufferView* image);
+
+  uint32_t width() const { return WidthOf(bitness_); }
+
+  // Exposing |value_| for testing.
+  uint64_t* mutable_value() { return &value_; }
+
+ private:
+  const Bitness bitness_;
+  const uint64_t image_base_;  // Accommodates 32-bit and 64-bit.
+  uint64_t value_;             // Accommodates 32-bit and 64-bit.
+};
+
+// A class to extract Win32 abs32 references from |abs32_locations| within
+// |image_| bounded by |[lo, hi)|. GetNext() is used to successively return
+// data as Units, which are locations and (potentially out-of-bound) RVAs.
+// |addr| determines the bitness of abs32 values stored, and mediates all reads.
+class Abs32RvaExtractorWin32 {
+ public:
+  struct Unit {
+    offset_t location;
+    rva_t target_rva;
+  };
+
+  // Requires |lo| <= |hi|, and they must not straddle a reference body (with
+  // length |addr.width()|) in |abs32_locations|.
+  Abs32RvaExtractorWin32(ConstBufferView image,
+                         AbsoluteAddress&& addr,
+                         const std::vector<offset_t>& abs32_locations,
+                         offset_t lo,
+                         offset_t hi);
+  Abs32RvaExtractorWin32(Abs32RvaExtractorWin32&&);
+  ~Abs32RvaExtractorWin32();
+
+  // Visits given abs32 locations, rejects invalid locations and non-existent
+  // RVAs, and returns reference as Unit, or std::nullopt on completion.
+  std::optional<Unit> GetNext();
+
+ private:
+  ConstBufferView image_;
+  AbsoluteAddress addr_;
+  std::vector<offset_t>::const_iterator cur_abs32_;
+  std::vector<offset_t>::const_iterator end_abs32_;
+};
+
+// A reader for Win32 abs32 references that filters and translates results from
+// |abs32_rva_extractor_|.
+class Abs32ReaderWin32 : public ReferenceReader {
+ public:
+  Abs32ReaderWin32(Abs32RvaExtractorWin32&& abs32_rva_extractor,
+                   const AddressTranslator& translator);
+  Abs32ReaderWin32(const Abs32ReaderWin32&) = delete;
+  const Abs32ReaderWin32& operator=(const Abs32ReaderWin32&) = delete;
+  ~Abs32ReaderWin32() override;
+
+  // ReferenceReader:
+  std::optional<Reference> GetNext() override;
+
+ private:
+  Abs32RvaExtractorWin32 abs32_rva_extractor_;
+  AddressTranslator::RvaToOffsetCache target_rva_to_offset_;
+};
+
+// A writer for Win32 abs32 references. |addr| determines the bitness of the
+// abs32 values stored, and mediates all writes.
+class Abs32WriterWin32 : public ReferenceWriter {
+ public:
+  Abs32WriterWin32(MutableBufferView image,
+                   AbsoluteAddress&& addr,
+                   const AddressTranslator& translator);
+  Abs32WriterWin32(const Abs32WriterWin32&) = delete;
+  const Abs32WriterWin32& operator=(const Abs32WriterWin32&) = delete;
+  ~Abs32WriterWin32() override;
+
+  // ReferenceWriter:
+  void PutNext(Reference ref) override;
+
+ private:
+  MutableBufferView image_;
+  AbsoluteAddress addr_;
+  AddressTranslator::OffsetToRvaCache target_offset_to_rva_;
+};
+
+// Given a list of abs32 |locations|, removes all elements whose targets cannot
+// be translated. Returns the number of elements removed.
+size_t RemoveUntranslatableAbs32(ConstBufferView image,
+                                 AbsoluteAddress&& addr,
+                                 const AddressTranslator& translator,
+                                 std::vector<offset_t>* locations);
+
+// Given a sorted list of abs32 |locations|, removes all elements whose body
+// (with |width| given) overlaps with the body of a previous element.
+size_t RemoveOverlappingAbs32Locations(uint32_t width,
+                                       std::vector<offset_t>* locations);
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_ABS32_UTILS_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/address_translator.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/address_translator.h
new file mode 100644
index 0000000..a517a2c
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/address_translator.h
@@ -0,0 +1,199 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_ADDRESS_TRANSLATOR_H_
+#define COMPONENTS_ZUCCHINI_ADDRESS_TRANSLATOR_H_
+
+#include <stdint.h>
+
+#include <tuple>
+#include <vector>
+
+#include "components/zucchini/algorithm.h"
+#include "components/zucchini/image_utils.h"
+
+namespace zucchini {
+
+// There are several ways to reason about addresses in an image:
+// - Offset: Position relative to start of image.
+// - VA (Virtual Address): Virtual memory address of a loaded image. This is
+//   subject to relocation by the OS.
+// - RVA (Relative Virtual Address): VA relative to some base address. This is
+//   the preferred way to specify pointers in an image.
+//
+// Zucchini is primarily concerned with offsets and RVAs. Executable images like
+// PE and ELF are organized into sections. Each section specifies offset and RVA
+// ranges as:
+//   {Offset start, offset size, RVA start, RVA size}.
+// This constitutes a basic unit to translate between offsets and RVAs. Note:
+// |offset size| < |RVA size| is possible. For example, the .bss section can can
+// have zero-filled statically-allocated data that have no corresponding bytes
+// on image (to save space). This poses a problem for Zucchini, which stores
+// addresses as offsets: now we'd have "dangling RVAs" that don't map to
+// offsets! Some ways to handling this are:
+// 1. Ignore all dangling RVAs. This simplifies the algorithm, but also means
+//    some reference targets would escape detection and processing.
+// 2. Create distinct "fake offsets" to accommodate dangling RVAs. Image data
+//    must not be read on these fake offsets, which are only valid as target
+//    addresses for reference matching.
+// As for |RVA size| < |offset size|, the extra portion just gets ignored.
+//
+// Status: Zucchini implements (2) in a simple way: dangling RVAs are mapped to
+// fake offsets by adding a large value. This value can be chosen as an
+// exclusive upper bound of all offsets (i.e., image size). This allows them to
+// be easily detected and processed as a special-case.
+// TODO(huangs): Investigate option (1), now that the refactored code makes
+// experimentation easier.
+// TODO(huangs): Make AddressTranslator smarter: Allocate unused |offset_t|
+// ranges and create "fake" units to accommodate dangling RVAs. Then
+// AddressTranslator can be simplified.
+
+// Virtual Address relative to some base address (RVA). There's distinction
+// between "valid RVA" and "existent RVA":
+// - Valid RVA: An RVA that's reasonably small, i.e., below |kRvaBound|.
+// - Existent RVA: An RVA that has semantic meaning in an image, and may
+//   translate to an offset in an image or (if a dangling RVA) a fake offset.
+//   All existent RVAs are valid RVAs.
+using rva_t = uint32_t;
+// Divide by 2 to match |kOffsetBound|.
+constexpr rva_t kRvaBound = static_cast<rva_t>(-1) / 2;
+constexpr rva_t kInvalidRva = static_cast<rva_t>(-2);
+
+// A utility to translate between offsets and RVAs in an image.
+class AddressTranslator {
+ public:
+  // A basic unit for address translation, roughly maps to a section, but may
+  // be processed (e.g., merged) as an optimization.
+  struct Unit {
+    offset_t offset_end() const { return offset_begin + offset_size; }
+    rva_t rva_end() const { return rva_begin + rva_size; }
+    bool IsEmpty() const {
+      // |rva_size == 0| and |offset_size > 0| means Unit hasn't been trimmed
+      // yet, and once it is then it's empty.
+      // |rva_size > 0| and |offset_size == 0| means Unit has dangling RVA, but
+      // is not empty.
+      return rva_size == 0;
+    }
+    bool CoversOffset(offset_t offset) const {
+      return RangeCovers(offset_begin, offset_size, offset);
+    }
+    bool CoversRva(rva_t rva) const {
+      return RangeCovers(rva_begin, rva_size, rva);
+    }
+    bool CoversDanglingRva(rva_t rva) const {
+      return CoversRva(rva) && rva - rva_begin >= offset_size;
+    }
+    // Assumes valid |offset| (*cannot* be fake offset).
+    rva_t OffsetToRvaUnsafe(offset_t offset) const {
+      return offset - offset_begin + rva_begin;
+    }
+    // Assumes valid |rva| (*can* be danging RVA).
+    offset_t RvaToOffsetUnsafe(rva_t rva, offset_t fake_offset_begin) const {
+      rva_t delta = rva - rva_begin;
+      return delta < offset_size ? delta + offset_begin
+                                 : fake_offset_begin + rva;
+    }
+    bool HasDanglingRva() const { return rva_size > offset_size; }
+    friend bool operator==(const Unit& a, const Unit& b) {
+      return std::tie(a.offset_begin, a.offset_size, a.rva_begin, a.rva_size) ==
+             std::tie(b.offset_begin, b.offset_size, b.rva_begin, b.rva_size);
+    }
+
+    offset_t offset_begin;
+    offset_t offset_size;
+    rva_t rva_begin;
+    rva_t rva_size;
+  };
+
+  // An adaptor for AddressTranslator::OffsetToRva() that caches the last Unit
+  // found, to reduce the number of OffsetToUnit() calls for clustered queries.
+  class OffsetToRvaCache {
+   public:
+    // Embeds |translator| for use. Now object lifetime is tied to |translator|
+    // lifetime.
+    explicit OffsetToRvaCache(const AddressTranslator& translator);
+    OffsetToRvaCache(const OffsetToRvaCache&) = delete;
+    const OffsetToRvaCache& operator=(const OffsetToRvaCache&) = delete;
+
+    rva_t Convert(offset_t offset) const;
+
+   private:
+    const AddressTranslator& translator_;
+    mutable const AddressTranslator::Unit* cached_unit_ = nullptr;
+  };
+
+  // An adaptor for AddressTranslator::RvaToOffset() that caches the last Unit
+  // found, to reduce the number of RvaToUnit() calls for clustered queries.
+  class RvaToOffsetCache {
+   public:
+    // Embeds |translator| for use. Now object lifetime is tied to |translator|
+    // lifetime.
+    explicit RvaToOffsetCache(const AddressTranslator& translator);
+    RvaToOffsetCache(const RvaToOffsetCache&) = delete;
+    const RvaToOffsetCache& operator=(const RvaToOffsetCache&) = delete;
+
+    bool IsValid(rva_t rva) const;
+
+    offset_t Convert(rva_t rva) const;
+
+   private:
+    const AddressTranslator& translator_;
+    mutable const AddressTranslator::Unit* cached_unit_ = nullptr;
+  };
+
+  enum Status {
+    kSuccess = 0,
+    kErrorOverflow,
+    kErrorBadOverlap,
+    kErrorBadOverlapDanglingRva,
+    kErrorFakeOffsetBeginTooLarge,
+  };
+
+  AddressTranslator();
+  AddressTranslator(AddressTranslator&&);
+  AddressTranslator(const AddressTranslator&) = delete;
+  const AddressTranslator& operator=(const AddressTranslator&) = delete;
+  ~AddressTranslator();
+
+  // Consumes |units| to populate data in this class. Performs consistency
+  // checks and overlapping Units. Returns Status to indicate success.
+  Status Initialize(std::vector<Unit>&& units);
+
+  // Returns the (possibly dangling) RVA corresponding to |offset|, or
+  // kInvalidRva if not found.
+  rva_t OffsetToRva(offset_t offset) const;
+
+  // Returns the (possibly fake) offset corresponding to |rva|, or
+  // kInvalidOffset if not found (i.e., |rva| is non-existent).
+  offset_t RvaToOffset(rva_t rva) const;
+
+  // For testing.
+  offset_t fake_offset_begin() const { return fake_offset_begin_; }
+
+  const std::vector<Unit>& units_sorted_by_offset() const {
+    return units_sorted_by_offset_;
+  }
+
+  const std::vector<Unit>& units_sorted_by_rva() const {
+    return units_sorted_by_rva_;
+  }
+
+ private:
+  // Helper to find the Unit that contains given |offset| or |rva|. Returns null
+  // if not found.
+  const Unit* OffsetToUnit(offset_t offset) const;
+  const Unit* RvaToUnit(rva_t rva) const;
+
+  // Storage of Units. All offset ranges are non-empty and disjoint. Likewise
+  // for all RVA ranges.
+  std::vector<Unit> units_sorted_by_offset_;
+  std::vector<Unit> units_sorted_by_rva_;
+
+  // Conversion factor to translate between dangling RVAs and fake offsets.
+  offset_t fake_offset_begin_;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_ADDRESS_TRANSLATOR_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/algorithm.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/algorithm.h
new file mode 100644
index 0000000..4cafe93
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/algorithm.h
@@ -0,0 +1,147 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_ALGORITHM_H_
+#define COMPONENTS_ZUCCHINI_ALGORITHM_H_
+
+#include <stddef.h>
+
+#include <algorithm>
+#include <deque>
+#include <type_traits>
+#include <vector>
+
+#include "base/check_op.h"
+
+// Collection of simple utilities used in for low-level computation.
+
+namespace zucchini {
+
+// Safely determines whether |[begin, begin + size)| is in |[0, bound)|. Note:
+// The special case |[bound, bound)| is not considered to be in |[0, bound)|.
+template <typename T>
+bool RangeIsBounded(T begin, T size, size_t bound) {
+  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned.");
+  return begin < bound && size <= bound - begin;
+}
+
+// Safely determines whether |value| lies in |[begin, begin + size)|. Works
+// properly even if |begin + size| overflows -- although such ranges are
+// considered pathological, and should fail validation elsewhere.
+template <typename T>
+bool RangeCovers(T begin, T size, T value) {
+  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned.");
+  return begin <= value && value - begin < size;
+}
+
+// Returns the integer in inclusive range |[lo, hi]| that's closest to |value|.
+// This departs from the usual usage of semi-inclusive ranges, but is useful
+// because (1) sentinels can use this, (2) a valid output always exists. It is
+// assumed that |lo <= hi|.
+template <class T>
+T InclusiveClamp(T value, T lo, T hi) {
+  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned.");
+  DCHECK_LE(lo, hi);
+  return value <= lo ? lo : (value >= hi ? hi : value);
+}
+
+// Returns the minimum multiple of |m| that's no less than |x|. Assumes |m > 0|
+// and |x| is sufficiently small so that no overflow occurs.
+template <class T>
+constexpr T AlignCeil(T x, T m) {
+  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned.");
+  return T((x + m - 1) / m) * m;
+}
+
+// Specialized alignment helpers that returns the increment to |pos| to get the
+// next n-aligned value, where n is in {2, 4}. This is useful for aligning
+// iterators relative to a base iterator using:
+//   it += IncrementForAlignCeil2(it - base);
+template <class T>
+inline int IncrementForAlignCeil2(T pos) {
+  return static_cast<int>(pos & 1);  // Optimized from (-pos) & 1.
+}
+
+template <class T>
+inline int IncrementForAlignCeil4(T pos) {
+  return static_cast<int>((-pos) & 3);
+}
+
+// Sorts values in |container| and removes duplicates.
+template <class T>
+void SortAndUniquify(std::deque<T>* container) {
+  std::sort(container->begin(), container->end());
+  container->erase(std::unique(container->begin(), container->end()),
+                   container->end());
+  container->shrink_to_fit();
+}
+
+// Extracts a single bit at |pos| from integer |v|.
+template <int pos, typename T>
+constexpr T GetBit(T v) {
+  return (v >> pos) & 1;
+}
+
+// Extracts bits in inclusive range [|lo|, |hi|] from integer |v|, and returns
+// the sign-extend result. For example, let the (MSB-first) bits in a 32-bit int
+// |v| be:
+//   xxxxxxxx xxxxxSii iiiiiiii iyyyyyyy,
+//               hi^          lo^       => lo = 7, hi = 18
+// To extract "Sii iiiiiiii i", calling
+//   GetSignedBits<7, 18>(v);
+// produces the sign-extended result:
+//   SSSSSSSS SSSSSSSS SSSSSiii iiiiiiii.
+template <int lo, int hi, typename T>
+constexpr typename std::make_signed<T>::type GetSignedBits(T v) {
+  constexpr int kNumBits = sizeof(T) * 8;
+  using SignedType = typename std::make_signed<T>::type;
+  // Assumes 0 <= |lo| <= |hi| < |kNumBits|.
+  // How this works:
+  // (1) Shift-left by |kNumBits - 1 - hi| to clear "left" bits.
+  // (2) Shift-right by |kNumBits - 1 - hi + lo| to clear "right" bits. The
+  //     input is casted to a signed type to perform sign-extension.
+  return static_cast<SignedType>(v << (kNumBits - 1 - hi)) >>
+         (kNumBits - 1 - hi + lo);
+}
+
+// Similar to GetSignedBits(), but returns the zero-extended result. For the
+// above example, calling
+//   GetUnsignedBits<7, 18>(v);
+// results in:
+//   00000000 00000000 0000Siii iiiiiiii.
+template <int lo, int hi, typename T>
+constexpr typename std::make_unsigned<T>::type GetUnsignedBits(T v) {
+  constexpr int kNumBits = sizeof(T) * 8;
+  using UnsignedType = typename std::make_unsigned<T>::type;
+  return static_cast<UnsignedType>(v << (kNumBits - 1 - hi)) >>
+         (kNumBits - 1 - hi + lo);
+}
+
+// Copies bits at |pos| in |v| to all higher bits, and returns the result as the
+// same int type as |v|.
+template <typename T>
+constexpr T SignExtend(int pos, T v) {
+  int kNumBits = sizeof(T) * 8;
+  int kShift = kNumBits - 1 - pos;
+  return static_cast<typename std::make_signed<T>::type>(v << kShift) >> kShift;
+}
+
+// Optimized version where |pos| becomes a template parameter.
+template <int pos, typename T>
+constexpr T SignExtend(T v) {
+  constexpr int kNumBits = sizeof(T) * 8;
+  constexpr int kShift = kNumBits - 1 - pos;
+  return static_cast<typename std::make_signed<T>::type>(v << kShift) >> kShift;
+}
+
+// Determines whether |v|, if interpreted as a signed integer, is representable
+// using |digs| bits. |1 <= digs <= sizeof(T)| is assumed.
+template <int digs, typename T>
+constexpr bool SignedFit(T v) {
+  return v == SignExtend<digs - 1, T>(v);
+}
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_ALGORITHM_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/arm_utils.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/arm_utils.h
new file mode 100644
index 0000000..8664f3e
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/arm_utils.h
@@ -0,0 +1,423 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_ARM_UTILS_H_
+#define COMPONENTS_ZUCCHINI_ARM_UTILS_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "base/check_op.h"
+#include "components/zucchini/address_translator.h"
+#include "components/zucchini/buffer_view.h"
+
+namespace zucchini {
+
+// References:
+// * AArch32 (32-bit ARM, AKA ARM32):
+//     https://static.docs.arm.com/ddi0406/c/DDI0406C_C_arm_architecture_reference_manual.pdf
+// * AArch64 (64-bit ARM):
+//     https://static.docs.arm.com/ddi0487/da/DDI0487D_a_armv8_arm.pdf
+
+// Definitions (used in Zucchini):
+// * |instr_rva|: Instruction RVA: The RVA where an instruction is located. In
+//   ARM mode and for AArch64 this is 4-byte aligned; in THUMB2 mode this is
+//   2-byte aligned.
+// * |code|: Instruction code: ARM instruction code as seen in manual. In ARM
+//   mode and for AArch64, this is a 32-bit int. In THUMB2 mode, this may be a
+//   16-bit or 32-bit int.
+// * |disp|: Displacement: For branch instructions (e.g.: B, BL, BLX, and
+//   conditional varieties) this is the value encoded in instruction bytes.
+// * PC: Program Counter: In ARM mode this is |instr_rva + 8|; in THUMB2 mode
+//   this is |instr_rva + 4|; for AArch64 this is |instr_rva|.
+// * |target_rva|: Target RVA: The RVA targeted by a branch instruction.
+//
+// These are related by:
+//   |code| = Fetch(image data at offset(|instr_rva|)).
+//   |disp| = Decode(|code|).
+//   PC = |instr_rva| + {8 in ARM mode, 4 in THUMB2 mode, 0 for AArch64}.
+//   |target_rva| = PC + |disp| - (see "BLX complication" below)
+//
+// Example 1 (ARM mode):
+//   00103050: 00 01 02 EA    B     00183458
+//   |instr_rva| = 0x00103050  (4-byte aligned).
+//   |code| = 0xEA020100  (little endian fetched from data).
+//   |disp| = 0x00080400  (decoded from |code| with A24 -> B encoding T1).
+//   PC = |instr_rva| + 8 = 0x00103058  (ARM mode).
+//   |target_rva| = PC + |disp| = 0x00183458.
+//
+// Example 2 (THUMB2 mode):
+//   001030A2: 00 F0 01 FA    BL    001034A8
+//   |instr_rva| = 0x001030A2  (2-byte aligned).
+//   |code| = 0xF000FA01  (special THUMB2 mode data fetch).
+//   |disp| = 0x00000402  (decoded from |code| with T24 -> BL encoding T1).
+//   PC = |instr_rva| + 4 = 0x001030A6  (THUMB2 mode).
+//   |target_rva| = PC + |disp| = 0x001034A8.
+//
+// Example 3 (AArch64):
+//   0000000000305070: 03 02 01 14    B     000000000034587C
+//   |instr_rva| = 0x00305070  (4-byte aligned, assumed to fit in 32-bit).
+//   |code| = 0x14010203  (little endian fetchd from data).
+//   |disp| = 0x0004080C  (decoded from |code| with Immd -> B).
+//   PC = |instr_rva| = 0x00305070  (AArch64).
+//   |target_rva| = PC + |disp| = 0x0034587C.
+
+// BLX complication: BLX transits between ARM mode and THUMB2 mode, and branches
+// to an address. Therefore |instr_rva| must align by the "old" mode, and
+// |target_rva| must align by the "new" mode. In particular:
+// * BLX encoding A2 (ARM -> THUMB2): |instr_rva| is 4-byte aligned with
+//   PC = |instr_rva| + 8; |target_rva| is 2-byte aligned, and so |disp| is
+//   2-byte aligned.
+// * BLX encoding T2 (THUMB2 -> ARM): |instr_rva| is 2-byte aligned with
+//   PC = |instr_rva| + 4; |target_rva| is 4-byte aligned. Complication: BLX
+//   encoding T2 stores a bit |H| that corresponds to "2" in binary, but |H|
+//   must be set to 0. Thus the encoded value is effectively 4-byte aligned. So
+//   when computing |target_rva| by adding PC (2-byte aligned) to the stored
+//   value (4-byte aligned), the result must be rounded down to the nearest
+//   4-byte aligned address.
+// The last situation creates ambiguity in how |disp| is defined! Alternatives:
+// (1) |disp| := |target_rva| - PC: So |code| <-> |disp| for BLX encoding T2,
+//     requires |instr_rva| % 4 to be determined, and adjustments made.
+// (2) |disp| := Value stored in |code|: So |disp| <-> |target_rva| for BLX
+//     encoding T2 requires adjustment: |disp| -> |target_rva| needs to round
+//     down, whereas |target_rva| -> |disp| needs to round up.
+// We adopt (2) to simplify |code| <-> |disp|, since that gets used.
+
+using arm_disp_t = int32_t;
+
+// Alignment requirement for |target_rva|, useful for |disp| <-> |target_rva|
+// (also requires |instr_rva|). Alignment is determined by parsing |code| in
+// *Decode() functions. kArmAlignFail is also defined to indicate parse failure.
+// Alignments can be 2 or 4. These values are also used in the enum, so
+// |x % align| with |x & (align - 1)| to compute alignment.
+enum ArmAlign : uint32_t {
+  kArmAlignFail = 0U,
+  kArmAlign2 = 2U,
+  kArmAlign4 = 4U,
+};
+
+// Traits for rel32 address types (technically rel64 for AArch64 -- but we
+// assume values are small enough), which form collections of strategies to
+// process each rel32 address type.
+template <typename ENUM_ADDR_TYPE,
+          ENUM_ADDR_TYPE ADDR_TYPE,
+          typename CODE_T,
+          CODE_T (*FETCH)(ConstBufferView, offset_t),
+          void (*STORE)(MutableBufferView, offset_t, CODE_T),
+          ArmAlign (*DECODE)(CODE_T, arm_disp_t*),
+          bool (*ENCODE)(arm_disp_t, CODE_T*),
+          bool (*READ)(rva_t, CODE_T, rva_t*),
+          bool (*WRITE)(rva_t, rva_t, CODE_T*)>
+class ArmAddrTraits {
+ public:
+  static constexpr ENUM_ADDR_TYPE addr_type = ADDR_TYPE;
+  using code_t = CODE_T;
+  static constexpr CODE_T (*Fetch)(ConstBufferView, offset_t) = FETCH;
+  static constexpr void (*Store)(MutableBufferView, offset_t, CODE_T) = STORE;
+  static constexpr ArmAlign (*Decode)(CODE_T, arm_disp_t*) = DECODE;
+  static constexpr bool (*Encode)(arm_disp_t, CODE_T*) = ENCODE;
+  static constexpr bool (*Read)(rva_t, CODE_T, rva_t*) = READ;
+  static constexpr bool (*Write)(rva_t, rva_t, CODE_T*) = WRITE;
+};
+
+// Given THUMB2 instruction |code16|, returns 2 if it's from a 16-bit THUMB2
+// instruction, or 4 if it's from a 32-bit THUMB2 instruction.
+inline int GetThumb2InstructionSize(uint16_t code16) {
+  return ((code16 & 0xF000) == 0xF000 || (code16 & 0xF800) == 0xE800) ? 4 : 2;
+}
+
+// A translator for ARM mode and THUMB2 mode with static functions that
+// translate among |code|, |disp|, and |target_rva|.
+class AArch32Rel32Translator {
+ public:
+  // Rel32 address types enumeration.
+  enum AddrType : uint8_t {
+    ADDR_NONE = 0xFF,
+    // Naming: Here "A24" represents ARM mode instructions where |code|
+    // dedicates 24 bits (including sign bit) to specify |disp|. Similarly, "T8"
+    // represents THUMB2 mode instructions with 8 bits for |disp|. Currently
+    // only {A24, T8, T11, T20, T24} are defined. These are not to be confused
+    // with "B encoding A1", "B encoding T3", etc., which are specific encoding
+    // schemes given by the manual for the "B" (or other) instructions (only
+    // {A1, A2, T1, T2, T3, T4} are seen).
+    ADDR_A24 = 0,
+    ADDR_T8,
+    ADDR_T11,
+    ADDR_T20,
+    ADDR_T24,
+    NUM_ADDR_TYPE
+  };
+
+  AArch32Rel32Translator();
+  AArch32Rel32Translator(const AArch32Rel32Translator&) = delete;
+  const AArch32Rel32Translator& operator=(const AArch32Rel32Translator&) =
+      delete;
+
+  // Fetches the 32-bit ARM instruction |code| at |view[idx]|.
+  static inline uint32_t FetchArmCode32(ConstBufferView view, offset_t idx) {
+    return view.read<uint32_t>(idx);
+  }
+
+  // Fetches the 16-bit THUMB2 instruction |code| at |view[idx]|.
+  static inline uint16_t FetchThumb2Code16(ConstBufferView view, offset_t idx) {
+    return view.read<uint16_t>(idx);
+  }
+
+  // Fetches the 32-bit THUMB2 instruction |code| at |view[idx]|.
+  static inline uint32_t FetchThumb2Code32(ConstBufferView view, offset_t idx) {
+    // By convention, 32-bit THUMB2 instructions are written (as seen later) as:
+    //   [byte3, byte2, byte1, byte0].
+    // However (assuming little-endian ARM) the in-memory representation is
+    //   [byte2, byte3, byte0, byte1].
+    return (static_cast<uint32_t>(view.read<uint16_t>(idx)) << 16) |
+           view.read<uint16_t>(idx + 2);
+  }
+
+  // Stores the 32-bit ARM instruction |code| to |mutable_view[idx]|.
+  static inline void StoreArmCode32(MutableBufferView mutable_view,
+                                    offset_t idx,
+                                    uint32_t code) {
+    mutable_view.write<uint32_t>(idx, code);
+  }
+
+  // Stores the 16-bit THUMB2 instruction |code| to |mutable_view[idx]|.
+  static inline void StoreThumb2Code16(MutableBufferView mutable_view,
+                                       offset_t idx,
+                                       uint16_t code) {
+    mutable_view.write<uint16_t>(idx, code);
+  }
+
+  // Stores the next 32-bit THUMB2 instruction |code| to |mutable_view[idx]|.
+  static inline void StoreThumb2Code32(MutableBufferView mutable_view,
+                                       offset_t idx,
+                                       uint32_t code) {
+    mutable_view.write<uint16_t>(idx, static_cast<uint16_t>(code >> 16));
+    mutable_view.write<uint16_t>(idx + 2, static_cast<uint16_t>(code & 0xFFFF));
+  }
+
+  // The following functions convert |code| (16-bit or 32-bit) from/to |disp|
+  // or |target_rva|, for specific branch instruction types.
+  // Read*() and write*() functions convert between |code| and |target_rva|.
+  // * Decode*() determines whether |code16/code32| is a branch instruction
+  //   of a specific type. If so, then extracts |*disp| and returns the required
+  //   ArmAlign. Otherwise returns kArmAlignFail.
+  // * Encode*() determines whether |*code16/*code32| is a branch instruction of
+  //   a specific type, and whether it can accommodate |disp|. If so, then
+  //   re-encodes |*code32| using |disp|, and returns true. Otherwise returns
+  //   false.
+  // * Read*() is similar to Decode*(), but on success, extracts |*target_rva|
+  //   using |instr_rva| as aid, performs the proper alignment, and returns
+  //   true. Otherwise returns false.
+  // * Write*() is similar to Encode*(), takes |target_rva| instead, and uses
+  //   |instr_rva| as aid.
+  static ArmAlign DecodeA24(uint32_t code32, arm_disp_t* disp);
+  static bool EncodeA24(arm_disp_t disp, uint32_t* code32);
+  // TODO(huangs): Refactor the Read*() functions: These are identical
+  // except for Decode*() and Get*TargetRvaFromDisp().
+  static bool ReadA24(rva_t instr_rva, uint32_t code32, rva_t* target_rva);
+  static bool WriteA24(rva_t instr_rva, rva_t target_rva, uint32_t* code32);
+
+  static ArmAlign DecodeT8(uint16_t code16, arm_disp_t* disp);
+  static bool EncodeT8(arm_disp_t disp, uint16_t* code16);
+  static bool ReadT8(rva_t instr_rva, uint16_t code16, rva_t* target_rva);
+  static bool WriteT8(rva_t instr_rva, rva_t target_rva, uint16_t* code16);
+
+  static ArmAlign DecodeT11(uint16_t code16, arm_disp_t* disp);
+  static bool EncodeT11(arm_disp_t disp, uint16_t* code16);
+  static bool ReadT11(rva_t instr_rva, uint16_t code16, rva_t* target_rva);
+  static bool WriteT11(rva_t instr_rva, rva_t target_rva, uint16_t* code16);
+
+  static ArmAlign DecodeT20(uint32_t code32, arm_disp_t* disp);
+  static bool EncodeT20(arm_disp_t disp, uint32_t* code32);
+  static bool ReadT20(rva_t instr_rva, uint32_t code32, rva_t* target_rva);
+  static bool WriteT20(rva_t instr_rva, rva_t target_rva, uint32_t* code32);
+
+  static ArmAlign DecodeT24(uint32_t code32, arm_disp_t* disp);
+  static bool EncodeT24(arm_disp_t disp, uint32_t* code32);
+  static bool ReadT24(rva_t instr_rva, uint32_t code32, rva_t* target_rva);
+  static bool WriteT24(rva_t instr_rva, rva_t target_rva, uint32_t* code32);
+
+  // Computes |target_rva| from |instr_rva| and |disp| in ARM mode.
+  static inline rva_t GetArmTargetRvaFromDisp(rva_t instr_rva,
+                                              arm_disp_t disp,
+                                              ArmAlign align) {
+    rva_t ret = static_cast<rva_t>(instr_rva + 8 + disp);
+    // Align down.
+    DCHECK_NE(align, kArmAlignFail);
+    return ret - (ret & static_cast<rva_t>(align - 1));
+  }
+
+  // Computes |target_rva| from |instr_rva| and |disp| in THUMB2 mode.
+  static inline rva_t GetThumb2TargetRvaFromDisp(rva_t instr_rva,
+                                                 arm_disp_t disp,
+                                                 ArmAlign align) {
+    rva_t ret = static_cast<rva_t>(instr_rva + 4 + disp);
+    // Align down.
+    DCHECK_NE(align, kArmAlignFail);
+    return ret - (ret & static_cast<rva_t>(align - 1));
+  }
+
+  // Computes |disp| from |instr_rva| and |target_rva| in ARM mode.
+  static inline arm_disp_t GetArmDispFromTargetRva(rva_t instr_rva,
+                                                   rva_t target_rva,
+                                                   ArmAlign align) {
+    // Assumes that |instr_rva + 8| does not overflow.
+    arm_disp_t ret = static_cast<arm_disp_t>(target_rva) -
+                     static_cast<arm_disp_t>(instr_rva + 8);
+    // Align up.
+    DCHECK_NE(align, kArmAlignFail);
+    return ret + ((-ret) & static_cast<arm_disp_t>(align - 1));
+  }
+
+  // Computes |disp| from |instr_rva| and |target_rva| in THUMB2 mode.
+  static inline arm_disp_t GetThumb2DispFromTargetRva(rva_t instr_rva,
+                                                      rva_t target_rva,
+                                                      ArmAlign align) {
+    // Assumes that |instr_rva + 4| does not overflow.
+    arm_disp_t ret = static_cast<arm_disp_t>(target_rva) -
+                     static_cast<arm_disp_t>(instr_rva + 4);
+    // Align up.
+    DCHECK_NE(align, kArmAlignFail);
+    return ret + ((-ret) & static_cast<arm_disp_t>(align - 1));
+  }
+
+  // Strategies to process each rel32 address type.
+  using AddrTraits_A24 = ArmAddrTraits<AddrType,
+                                       ADDR_A24,
+                                       uint32_t,
+                                       FetchArmCode32,
+                                       StoreArmCode32,
+                                       DecodeA24,
+                                       EncodeA24,
+                                       ReadA24,
+                                       WriteA24>;
+  using AddrTraits_T8 = ArmAddrTraits<AddrType,
+                                      ADDR_T8,
+                                      uint16_t,
+                                      FetchThumb2Code16,
+                                      StoreThumb2Code16,
+                                      DecodeT8,
+                                      EncodeT8,
+                                      ReadT8,
+                                      WriteT8>;
+  using AddrTraits_T11 = ArmAddrTraits<AddrType,
+                                       ADDR_T11,
+                                       uint16_t,
+                                       FetchThumb2Code16,
+                                       StoreThumb2Code16,
+                                       DecodeT11,
+                                       EncodeT11,
+                                       ReadT11,
+                                       WriteT11>;
+  using AddrTraits_T20 = ArmAddrTraits<AddrType,
+                                       ADDR_T20,
+                                       uint32_t,
+                                       FetchThumb2Code32,
+                                       StoreThumb2Code32,
+                                       DecodeT20,
+                                       EncodeT20,
+                                       ReadT20,
+                                       WriteT20>;
+  using AddrTraits_T24 = ArmAddrTraits<AddrType,
+                                       ADDR_T24,
+                                       uint32_t,
+                                       FetchThumb2Code32,
+                                       StoreThumb2Code32,
+                                       DecodeT24,
+                                       EncodeT24,
+                                       ReadT24,
+                                       WriteT24>;
+};
+
+// Translator for AArch64, which is simpler than 32-bit ARM. Although pointers
+// are 64-bit, displacements are within 32-bit.
+class AArch64Rel32Translator {
+ public:
+  // Rel64 address types enumeration.
+  enum AddrType : uint8_t {
+    ADDR_NONE = 0xFF,
+    ADDR_IMMD14 = 0,
+    ADDR_IMMD19,
+    ADDR_IMMD26,
+    NUM_ADDR_TYPE
+  };
+
+  // Although RVA for 64-bit architecture can be 64-bit in length, we make the
+  // bold assumption that for ELF images that RVA will stay nicely in 32-bit!
+  AArch64Rel32Translator();
+  AArch64Rel32Translator(const AArch64Rel32Translator&) = delete;
+  const AArch64Rel32Translator& operator=(const AArch64Rel32Translator&) =
+      delete;
+
+  static inline uint32_t FetchCode32(ConstBufferView view, offset_t idx) {
+    return view.read<uint32_t>(idx);
+  }
+
+  static inline void StoreCode32(MutableBufferView mutable_view,
+                                 offset_t idx,
+                                 uint32_t code) {
+    mutable_view.write<uint32_t>(idx, code);
+  }
+
+  // Conversion functions for |code32| from/to |disp| or |target_rva|, similar
+  // to the counterparts in AArch32Rel32Translator.
+  static ArmAlign DecodeImmd14(uint32_t code32, arm_disp_t* disp);
+  static bool EncodeImmd14(arm_disp_t disp, uint32_t* code32);
+  // TODO(huangs): Refactor the Read*() functions: These are identical
+  // except for Decode*().
+  static bool ReadImmd14(rva_t instr_rva, uint32_t code32, rva_t* target_rva);
+  static bool WriteImmd14(rva_t instr_rva, rva_t target_rva, uint32_t* code32);
+
+  static ArmAlign DecodeImmd19(uint32_t code32, arm_disp_t* disp);
+  static bool EncodeImmd19(arm_disp_t disp, uint32_t* code32);
+  static bool ReadImmd19(rva_t instr_rva, uint32_t code32, rva_t* target_rva);
+  static bool WriteImmd19(rva_t instr_rva, rva_t target_rva, uint32_t* code32);
+
+  static ArmAlign DecodeImmd26(uint32_t code32, arm_disp_t* disp);
+  static bool EncodeImmd26(arm_disp_t disp, uint32_t* code32);
+  static bool ReadImmd26(rva_t instr_rva, uint32_t code32, rva_t* target_rva);
+  static bool WriteImmd26(rva_t instr_rva, rva_t target_rva, uint32_t* code32);
+
+  static inline rva_t GetTargetRvaFromDisp(rva_t instr_rva, arm_disp_t disp) {
+    return static_cast<rva_t>(instr_rva + disp);
+  }
+
+  static inline arm_disp_t GetDispFromTargetRva(rva_t instr_rva,
+                                                rva_t target_rva) {
+    return static_cast<arm_disp_t>(target_rva - instr_rva);
+  }
+
+  // Strategies to process each rel32 address type.
+  using AddrTraits_Immd14 = ArmAddrTraits<AddrType,
+                                          ADDR_IMMD14,
+                                          uint32_t,
+                                          FetchCode32,
+                                          StoreCode32,
+                                          DecodeImmd14,
+                                          EncodeImmd14,
+                                          ReadImmd14,
+                                          WriteImmd14>;
+  using AddrTraits_Immd19 = ArmAddrTraits<AddrType,
+                                          ADDR_IMMD19,
+                                          uint32_t,
+                                          FetchCode32,
+                                          StoreCode32,
+                                          DecodeImmd19,
+                                          EncodeImmd19,
+                                          ReadImmd19,
+                                          WriteImmd19>;
+  using AddrTraits_Immd26 = ArmAddrTraits<AddrType,
+                                          ADDR_IMMD26,
+                                          uint32_t,
+                                          FetchCode32,
+                                          StoreCode32,
+                                          DecodeImmd26,
+                                          EncodeImmd26,
+                                          ReadImmd26,
+                                          WriteImmd26>;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_ARM_UTILS_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_sink.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_sink.h
new file mode 100644
index 0000000..24798af
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_sink.h
@@ -0,0 +1,68 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_BUFFER_SINK_H_
+#define COMPONENTS_ZUCCHINI_BUFFER_SINK_H_
+
+#include <stdint.h>
+
+#include <algorithm>
+#include <iterator>
+
+#include "base/check_op.h"
+#include "components/zucchini/buffer_view.h"
+
+namespace zucchini {
+
+// BufferSink acts like an output stream with convenience methods to serialize
+// data into a contiguous sequence of raw data. The underlying MutableBufferView
+// emulates a cursor to track current write position, and guards against buffer
+// overrun. Where applicable, BufferSink should be passed by pointer to maintain
+// cursor progress across writes.
+class BufferSink : public MutableBufferView {
+ public:
+  using iterator = MutableBufferView::iterator;
+
+  using MutableBufferView::MutableBufferView;
+  BufferSink() = default;
+  explicit BufferSink(MutableBufferView buffer);
+  BufferSink(const BufferSink&) = default;
+  BufferSink& operator=(BufferSink&&) = default;
+
+  // If sufficient space is available, writes the binary representation of
+  // |value| starting at the cursor, while advancing the cursor beyond the
+  // written region, and returns true. Otherwise returns false.
+  template <class T>
+  bool PutValue(const T& value) {
+    DCHECK_NE(begin(), nullptr);
+    if (Remaining() < sizeof(T))
+      return false;
+    *reinterpret_cast<T*>(begin()) = value;
+    remove_prefix(sizeof(T));
+    return true;
+  }
+
+  // If sufficient space is available, writes the raw bytes [|first|, |last|)
+  // starting at the cursor, while advancing the cursor beyond the written
+  // region, and returns true. Otherwise returns false.
+  template <class It>
+  bool PutRange(It first, It last) {
+    static_assert(sizeof(typename std::iterator_traits<It>::value_type) ==
+                      sizeof(uint8_t),
+                  "value_type should fit in uint8_t");
+    DCHECK_NE(begin(), nullptr);
+    DCHECK(last >= first);
+    if (Remaining() < size_type(last - first))
+      return false;
+    std::copy(first, last, begin());
+    remove_prefix(last - first);
+    return true;
+  }
+
+  size_type Remaining() const { return size(); }
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_BUFFER_SINK_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_source.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_source.h
new file mode 100644
index 0000000..7426d4e
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_source.h
@@ -0,0 +1,141 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_BUFFER_SOURCE_H_
+#define COMPONENTS_ZUCCHINI_BUFFER_SOURCE_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <initializer_list>
+#include <type_traits>
+
+#include "base/check_op.h"
+#include "components/zucchini/buffer_view.h"
+
+namespace zucchini {
+
+// BufferSource acts like an input stream with convenience methods to parse data
+// from a contiguous sequence of raw data. The underlying ConstBufferView
+// emulates a cursor to track current read position, and guards against buffer
+// overrun. Where applicable, BufferSource should be passed by pointer to
+// maintain cursor progress across reads.
+class BufferSource : public ConstBufferView {
+ public:
+  // LEB128 info: http://dwarfstd.org/doc/dwarf-2.0.0.pdf , Section 7.6.
+  enum : size_t { kMaxLeb128Size = 5 };
+
+  static BufferSource FromRange(const_iterator first, const_iterator last) {
+    return BufferSource(ConstBufferView::FromRange(first, last));
+  }
+
+  using ConstBufferView::ConstBufferView;
+  BufferSource() = default;
+  explicit BufferSource(ConstBufferView buffer);
+  BufferSource(const BufferSource&) = default;
+  BufferSource& operator=(BufferSource&&) = default;
+
+  // Moves the cursor forward by |n| bytes, or to the end if data is exhausted.
+  // Returns a reference to *this, to allow chaining, e.g.:
+  //   if (!buffer_source.Skip(1024).GetValue<uint32_t>(&value)) {
+  //      ... // Handle error.
+  //   }
+  // Notice that Skip() defers error handling to GetValue().
+  BufferSource& Skip(size_type n);
+
+  // Returns true if |value| matches data starting at the cursor when
+  // reinterpreted as the integral type |T|.
+  template <class T>
+  bool CheckNextValue(const T& value) const {
+    static_assert(std::is_integral<T>::value,
+                  "Value type must be an integral type");
+    DCHECK_NE(begin(), nullptr);
+    if (Remaining() < sizeof(T))
+      return false;
+    return value == *reinterpret_cast<const T*>(begin());
+  }
+
+  // Returns true if the next bytes.size() bytes at the cursor match those in
+  // |bytes|.
+  bool CheckNextBytes(std::initializer_list<uint8_t> bytes) const;
+
+  // Same as CheckNextBytes(), but moves the cursor by bytes.size() if read is
+  // successfull.
+  bool ConsumeBytes(std::initializer_list<uint8_t> bytes);
+
+  // Tries to reinterpret data as type |T|, starting at the cursor and to write
+  // the result into |value|, while moving the cursor forward by sizeof(T).
+  // Returns true if sufficient data is available, and false otherwise.
+  template <class T>
+  bool GetValue(T* value) {
+    static_assert(std::is_standard_layout<T>::value,
+                  "Value type must be a standard layout type");
+
+    DCHECK_NE(begin(), nullptr);
+    if (Remaining() < sizeof(T))
+      return false;
+    *value = *reinterpret_cast<const T*>(begin());
+    remove_prefix(sizeof(T));
+    return true;
+  }
+
+  // Tries to reinterpret data as type |T| at the cursor and to return a
+  // reinterpreted pointer of type |T| pointing into the underlying data, while
+  // moving the cursor forward by sizeof(T). Returns nullptr if insufficient
+  // data is available.
+  template <class T>
+  const T* GetPointer() {
+    static_assert(std::is_standard_layout<T>::value,
+                  "Value type must be a standard layout type");
+
+    DCHECK_NE(begin(), nullptr);
+    if (Remaining() < sizeof(T))
+      return nullptr;
+    const T* ptr = reinterpret_cast<const T*>(begin());
+    remove_prefix(sizeof(T));
+    return ptr;
+  }
+
+  // Tries to reinterpret data as an array of type |T| with |count| elements,
+  // starting at the cursor, and to return a reinterpreted pointer of type |T|
+  // pointing into the underlying data, while advancing the cursor beyond the
+  // array. Returns nullptr if insufficient data is available.
+  template <class T>
+  const T* GetArray(size_t count) {
+    static_assert(std::is_standard_layout<T>::value,
+                  "Value type must be a standard layout type");
+
+    if (Remaining() / sizeof(T) < count)
+      return nullptr;
+    const T* array = reinterpret_cast<const T*>(begin());
+    remove_prefix(count * sizeof(T));
+    return array;
+  }
+
+  // If sufficient data is available, assigns |buffer| to point to a region of
+  // |size| bytes starting at the cursor, while advancing the cursor beyond the
+  // region, and returns true. Otherwise returns false.
+  bool GetRegion(size_type size, ConstBufferView* buffer);
+
+  // Reads an Unsigned Little Endian Base 128 (uleb128) int at |first_|. If
+  // successful, writes the result to |value|, advances |first_|, and returns
+  // true. Otherwise returns false.
+  bool GetUleb128(uint32_t* value);
+
+  // Reads a Signed Little Endian Base 128 (sleb128) int at |first_|. If
+  // successful, writes the result to |value|, advances |first_|, and returns
+  // true. Otherwise returns false.
+  bool GetSleb128(int32_t* value);
+
+  // Reads uleb128 / sleb128 at |first_| but discards the result. If successful,
+  // advances |first_| and returns true. Otherwise returns false.
+  bool SkipLeb128();
+
+  // Returns the number of bytes remaining from cursor until end.
+  size_type Remaining() const { return size(); }
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_BUFFER_SOURCE_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_view.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_view.h
new file mode 100644
index 0000000..661e3c3
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_view.h
@@ -0,0 +1,217 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_BUFFER_VIEW_H_
+#define COMPONENTS_ZUCCHINI_BUFFER_VIEW_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <algorithm>
+#include <type_traits>
+
+#include "base/check_op.h"
+#include "components/zucchini/algorithm.h"
+
+namespace zucchini {
+
+// Describes a region within a buffer, with starting offset and size.
+struct BufferRegion {
+  // The region data are stored as |offset| and |size|, but often it is useful
+  // to represent it as an interval [lo(), hi()) = [offset, offset + size).
+  size_t lo() const { return offset; }
+  size_t hi() const { return offset + size; }
+
+  // Returns whether the Region fits in |[0, container_size)|. Special case:
+  // a size-0 region starting at |container_size| fits.
+  bool FitsIn(size_t container_size) const {
+    return offset <= container_size && container_size - offset >= size;
+  }
+
+  // Returns |v| clipped to the inclusive range |[lo(), hi()]|.
+  size_t InclusiveClamp(size_t v) const {
+    return zucchini::InclusiveClamp(v, lo(), hi());
+  }
+
+  // Region data use size_t to match BufferViewBase::size_type, to make it
+  // convenient to index into buffer view.
+  size_t offset;
+  size_t size;
+};
+
+namespace internal {
+
+// TODO(huangs): Rename to BasicBufferView.
+// BufferViewBase should not be used directly; it is an implementation used for
+// both BufferView and MutableBufferView.
+template <class T>
+class BufferViewBase {
+ public:
+  using value_type = T;
+  using reference = T&;
+  using pointer = T*;
+  using iterator = T*;
+  using const_iterator = typename std::add_const<T>::type*;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+
+  static BufferViewBase FromRange(iterator first, iterator last) {
+    DCHECK_GE(last, first);
+    BufferViewBase ret;
+    ret.first_ = first;
+    ret.last_ = last;
+    return ret;
+  }
+
+  BufferViewBase() = default;
+
+  BufferViewBase(iterator first, size_type size)
+      : first_(first), last_(first_ + size) {
+    DCHECK_GE(last_, first_);
+  }
+
+  template <class U>
+  BufferViewBase(const BufferViewBase<U>& that)
+      : first_(that.begin()), last_(that.end()) {}
+
+  template <class U>
+  BufferViewBase(BufferViewBase<U>&& that)
+      : first_(that.begin()), last_(that.end()) {}
+
+  BufferViewBase(const BufferViewBase&) = default;
+  BufferViewBase& operator=(const BufferViewBase&) = default;
+
+  // Iterators
+
+  iterator begin() const { return first_; }
+  iterator end() const { return last_; }
+  const_iterator cbegin() const { return begin(); }
+  const_iterator cend() const { return end(); }
+
+  // Capacity
+
+  bool empty() const { return first_ == last_; }
+  size_type size() const { return last_ - first_; }
+
+  // Returns whether the buffer is large enough to cover |region|.
+  bool covers(const BufferRegion& region) const {
+    return region.FitsIn(size());
+  }
+
+  // Returns whether the buffer is large enough to cover an array starting at
+  // |offset| with |num| elements, each taking |elt_size| bytes.
+  bool covers_array(size_t offset, size_t num, size_t elt_size) {
+    DCHECK_GT(elt_size, 0U);
+    // Use subtraction and division to avoid overflow.
+    return offset <= size() && (size() - offset) / elt_size >= num;
+  }
+
+  // Element access
+
+  // Returns the raw value at specified location |pos|.
+  // If |pos| is not within the range of the buffer, the process is terminated.
+  reference operator[](size_type pos) const {
+    CHECK_LT(pos, size());
+    return first_[pos];
+  }
+
+  // Returns a sub-buffer described by |region|.
+  BufferViewBase operator[](BufferRegion region) const {
+    DCHECK_LE(region.offset, size());
+    DCHECK_LE(region.size, size() - region.offset);
+    return {begin() + region.offset, region.size};
+  }
+
+  template <class U>
+  const U& read(size_type pos) const {
+    // TODO(huangs): Use can_access<U>(pos) after fixing can_access().
+    CHECK_LE(sizeof(U), size());
+    CHECK_LE(pos, size() - sizeof(U));
+    return *reinterpret_cast<const U*>(begin() + pos);
+  }
+
+  template <class U>
+  void write(size_type pos, const U& value) {
+    // TODO(huangs): Use can_access<U>(pos) after fixing can_access().
+    CHECK_LE(sizeof(U), size());
+    CHECK_LE(pos, size() - sizeof(U));
+    *reinterpret_cast<U*>(begin() + pos) = value;
+  }
+
+  // Returns a mutable reference to an object type U whose raw storage starts
+  // at location |pos|.
+  template <class U>
+  U& modify(size_type pos) {
+    // TODO(huangs): Use can_access<U>(pos) after fixing can_access().
+    CHECK_LE(sizeof(U), size());
+    CHECK_LE(pos, size() - sizeof(U));
+    return *reinterpret_cast<U*>(begin() + pos);
+  }
+
+  template <class U>
+  bool can_access(size_type pos) const {
+    return pos < size() && size() - pos >= sizeof(U);
+  }
+
+  // Returns a BufferRegion describing the full view, with offset = 0. If the
+  // BufferViewBase is derived from another, this does *not* return the
+  // original region used for its definition (hence "local").
+  BufferRegion local_region() const { return BufferRegion{0, size()}; }
+
+  bool equals(BufferViewBase other) const {
+    return size() == other.size() && std::equal(begin(), end(), other.begin());
+  }
+
+  // Modifiers
+
+  void shrink(size_type new_size) {
+    DCHECK_LE(first_ + new_size, last_);
+    last_ = first_ + new_size;
+  }
+
+  // Moves the start of the view forward by n bytes.
+  void remove_prefix(size_type n) {
+    DCHECK_LE(n, size());
+    first_ += n;
+  }
+
+  // Moves the start of the view to |it|, which is in range [begin(), end()).
+  void seek(iterator it) {
+    DCHECK_GE(it, begin());
+    DCHECK_LE(it, end());
+    first_ = it;
+  }
+
+  // Given |origin| that contains |*this|, minimally increase |first_| (possibly
+  // by 0) so that |first_ <= last_|, and |first_ - origin.first_| is a multiple
+  // of |alignment|. On success, updates |first_| and returns true. Otherwise
+  // returns false.
+  bool AlignOn(BufferViewBase origin, size_type alignment) {
+    DCHECK_GT(alignment, 0U);
+    DCHECK_LE(origin.first_, first_);
+    DCHECK_GE(origin.last_, last_);
+    size_type aligned_size =
+        AlignCeil(static_cast<size_type>(first_ - origin.first_), alignment);
+    if (aligned_size > static_cast<size_type>(last_ - origin.first_))
+      return false;
+    first_ = origin.first_ + aligned_size;
+    return true;
+  }
+
+ private:
+  iterator first_ = nullptr;
+  iterator last_ = nullptr;
+};
+
+}  // namespace internal
+
+// Classes to encapsulate a contiguous sequence of raw data, without owning the
+// encapsulated memory regions. These are intended to be used as value types.
+
+using ConstBufferView = internal::BufferViewBase<const uint8_t>;
+using MutableBufferView = internal::BufferViewBase<uint8_t>;
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_BUFFER_VIEW_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/crc32.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/crc32.h
new file mode 100644
index 0000000..c729f5b
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/crc32.h
@@ -0,0 +1,17 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_CRC32_H_
+#define COMPONENTS_ZUCCHINI_CRC32_H_
+
+#include <stdint.h>
+
+namespace zucchini {
+
+// Calculates CRC-32 of the given range [|first|, |last|).
+uint32_t CalculateCrc32(const uint8_t* first, const uint8_t* last);
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_CRC32_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler.h
new file mode 100644
index 0000000..7ec739b
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler.h
@@ -0,0 +1,155 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_DISASSEMBLER_H_
+#define COMPONENTS_ZUCCHINI_DISASSEMBLER_H_
+
+#include <stddef.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/image_utils.h"
+
+namespace zucchini {
+
+// A vacuous ReferenceReader that produces no references.
+class EmptyReferenceReader : public ReferenceReader {
+ public:
+  std::optional<Reference> GetNext() override;
+};
+
+// A vacuous EmptyReferenceWriter that does not write.
+class EmptyReferenceWriter : public ReferenceWriter {
+ public:
+  void PutNext(Reference reference) override;
+};
+
+// Disassembler needs to be declared before ReferenceGroup because the latter
+// contains member pointers based on the former, and we use a compiler flag,
+// -fcomplete-member-pointers, which enforces that member pointer base types are
+// complete. This flag helps prevent us from running into problems in the
+// Microsoft C++ ABI (see https://crbug.com/847724).
+
+class ReferenceGroup;
+
+// A Disassembler is used to encapsulate architecture specific operations, to:
+// - Describe types of references found in the architecture using traits.
+// - Extract references contained in an image file.
+// - Correct target for some references.
+class Disassembler {
+ public:
+  // Attempts to parse |image| and create an architecture-specifc Disassembler,
+  // as determined by DIS, which is inherited from Disassembler. Returns an
+  // instance of DIS if successful, and null otherwise.
+  template <class DIS>
+  static std::unique_ptr<DIS> Make(ConstBufferView image) {
+    auto disasm = std::make_unique<DIS>();
+    if (!disasm->Parse(image))
+      return nullptr;
+    return disasm;
+  }
+
+  Disassembler(const Disassembler&) = delete;
+  const Disassembler& operator=(const Disassembler&) = delete;
+  virtual ~Disassembler();
+
+  // Returns the type of executable handled by the Disassembler.
+  virtual ExecutableType GetExeType() const = 0;
+
+  // Returns a more detailed description of the executable type.
+  virtual std::string GetExeTypeString() const = 0;
+
+  // Creates and returns a vector that contains all groups of references.
+  // Groups must be aggregated by pool.
+  virtual std::vector<ReferenceGroup> MakeReferenceGroups() const = 0;
+
+  ConstBufferView image() const { return image_; }
+  size_t size() const { return image_.size(); }
+
+  int num_equivalence_iterations() const { return num_equivalence_iterations_; }
+
+ protected:
+  explicit Disassembler(int num_equivalence_iterations);
+
+  // Parses |image| and initializes internal states. Returns true on success.
+  // This must be called once and before any other operation.
+  virtual bool Parse(ConstBufferView image) = 0;
+
+  // Raw image data. After Parse(), a Disassembler should shrink this to contain
+  // only the portion containing the executable file it recognizes.
+  ConstBufferView image_;
+
+  // The number of iterations to run for equivalence map generation. This should
+  // roughly be the max length of reference indirection chains.
+  int num_equivalence_iterations_;
+};
+
+// A ReferenceGroup is associated with a specific |type| and has convenience
+// methods to obtain readers and writers for that type. A ReferenceGroup does
+// not store references; it is a lightweight class that communicates with the
+// disassembler to operate on them.
+class ReferenceGroup {
+ public:
+  // Member function pointer used to obtain a ReferenceReader.
+  using ReaderFactory = std::unique_ptr<ReferenceReader> (
+      Disassembler::*)(offset_t lower, offset_t upper);
+
+  // Member function pointer used to obtain a ReferenceWriter.
+  using WriterFactory = std::unique_ptr<ReferenceWriter> (Disassembler::*)(
+      MutableBufferView image);
+
+  // RefinedGeneratorFactory and RefinedReceptorFactory don't have to be
+  // identical to GeneratorFactory and ReceptorFactory, but they must be
+  // convertible. As a result, they can be pointer to member function of a
+  // derived Disassembler.
+  template <class RefinedReaderFactory, class RefinedWriterFactory>
+  ReferenceGroup(ReferenceTypeTraits traits,
+                 RefinedReaderFactory reader_factory,
+                 RefinedWriterFactory writer_factory)
+      : traits_(traits),
+        reader_factory_(static_cast<ReaderFactory>(reader_factory)),
+        writer_factory_(static_cast<WriterFactory>(writer_factory)) {}
+
+  // Returns a reader for all references in the binary.
+  // Invalidates any other writer or reader previously obtained for |disasm|.
+  std::unique_ptr<ReferenceReader> GetReader(Disassembler* disasm) const;
+
+  // Returns a reader for references whose bytes are entirely contained in
+  // |[lower, upper)|.
+  // Invalidates any other writer or reader previously obtained for |disasm|.
+  std::unique_ptr<ReferenceReader> GetReader(offset_t lower,
+                                             offset_t upper,
+                                             Disassembler* disasm) const;
+
+  // Returns a writer for references in |image|, assuming that |image| was the
+  // same one initially parsed by |disasm|.
+  // Invalidates any other writer or reader previously obtained for |disasm|.
+  std::unique_ptr<ReferenceWriter> GetWriter(MutableBufferView image,
+                                             Disassembler* disasm) const;
+
+  // Returns traits describing the reference type.
+  const ReferenceTypeTraits& traits() const { return traits_; }
+
+  // Shorthand for traits().width.
+  offset_t width() const { return traits().width; }
+
+  // Shorthand for traits().type_tag.
+  TypeTag type_tag() const { return traits().type_tag; }
+
+  // Shorthand for traits().pool_tag.
+  PoolTag pool_tag() const { return traits().pool_tag; }
+
+ private:
+  ReferenceTypeTraits traits_;
+  ReaderFactory reader_factory_ = nullptr;
+  WriterFactory writer_factory_ = nullptr;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_DISASSEMBLER_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_dex.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_dex.h
new file mode 100644
index 0000000..d9d93b2
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_dex.h
@@ -0,0 +1,295 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_DISASSEMBLER_DEX_H_
+#define COMPONENTS_ZUCCHINI_DISASSEMBLER_DEX_H_
+
+#include <stdint.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "components/zucchini/disassembler.h"
+#include "components/zucchini/image_utils.h"
+#include "components/zucchini/type_dex.h"
+
+namespace zucchini {
+
+// For consistency, let "canonical order" of DEX data types be the order defined
+// in https://source.android.com/devices/tech/dalvik/dex-format "Type Codes"
+// section.
+
+class DisassemblerDex : public Disassembler {
+ public:
+  static constexpr uint16_t kVersion = 1;
+  // Pools follow canonical order.
+  enum ReferencePool : uint8_t {
+    kStringId,
+    kTypeId,
+    kProtoId,
+    kFieldId,
+    kMethodId,
+    // kClassDef,  // Unused
+    kCallSiteId,
+    kMethodHandle,
+    kTypeList,
+    kAnnotationSetRefList,
+    kAnnotionSet,
+    kClassData,
+    kCode,
+    kStringData,
+    kAnnotation,
+    kEncodedArray,
+    kAnnotationsDirectory,
+    kCallSite,
+    kNumPools
+  };
+
+  // Types are grouped and ordered by target ReferencePool. This is required by
+  // Zucchini-apply, which visits references by type order and sequentially
+  // handles pools in the same order. Type-pool association is established in
+  // MakeReferenceGroups(), and verified by a unit test.
+  enum ReferenceType : uint8_t {
+    kTypeIdToDescriptorStringId,  // kStringId
+    kProtoIdToShortyStringId,
+    kFieldIdToNameStringId,
+    kMethodIdToNameStringId,
+    kClassDefToSourceFileStringId,
+    kCodeToStringId16,
+    kCodeToStringId32,
+
+    kProtoIdToReturnTypeId,  // kTypeId
+    kFieldIdToClassTypeId,
+    kFieldIdToTypeId,
+    kMethodIdToClassTypeId,
+    kClassDefToClassTypeId,
+    kClassDefToSuperClassTypeId,
+    kTypeListToTypeId,
+    kCodeToTypeId,
+
+    kCodeToProtoId,  // kProtoId
+    kMethodIdToProtoId,
+
+    kCodeToFieldId,  // kFieldId
+    kMethodHandleToFieldId,
+    kAnnotationsDirectoryToFieldId,
+
+    kCodeToMethodId,  // kMethodId
+    kMethodHandleToMethodId,
+    kAnnotationsDirectoryToMethodId,
+    kAnnotationsDirectoryToParameterMethodId,
+
+    kCodeToCallSiteId,  // kCallSiteId
+
+    kCodeToMethodHandle,  // kMethodHandle
+
+    kProtoIdToParametersTypeList,  // kTypeList
+    kClassDefToInterfacesTypeList,
+
+    kAnnotationsDirectoryToParameterAnnotationSetRef,  // kAnnotationSetRef,
+
+    kAnnotationSetRefListToAnnotationSet,  // kAnnotationSet,
+    kAnnotationsDirectoryToClassAnnotationSet,
+    kAnnotationsDirectoryToFieldAnnotationSet,
+    kAnnotationsDirectoryToMethodAnnotationSet,
+
+    kClassDefToClassData,  // kClassData
+
+    kCodeToRelCode8,  // kCode
+    kCodeToRelCode16,
+    kCodeToRelCode32,
+
+    kStringIdToStringData,  // kStringData
+
+    kAnnotationSetToAnnotation,  // kAnnotation
+
+    kClassDefToStaticValuesEncodedArray,  // kEncodedArrayItem
+
+    kClassDefToAnnotationDirectory,  // kAnnotationsDirectory
+
+    kCallSiteIdToCallSite,  // kCallSite
+
+    kNumTypes
+  };
+
+  DisassemblerDex();
+  DisassemblerDex(const DisassemblerDex&) = delete;
+  const DisassemblerDex& operator=(const DisassemblerDex&) = delete;
+  ~DisassemblerDex() override;
+
+  // Applies quick checks to determine if |image| *may* point to the start of an
+  // executable. Returns true on success.
+  static bool QuickDetect(ConstBufferView image);
+
+  // Disassembler:
+  ExecutableType GetExeType() const override;
+  std::string GetExeTypeString() const override;
+  std::vector<ReferenceGroup> MakeReferenceGroups() const override;
+
+  // Functions that return reference readers. These follow canonical order of
+  // *locations* (unlike targets for ReferenceType). This allows functions with
+  // similar parsing logic to appear togeter.
+  std::unique_ptr<ReferenceReader> MakeReadStringIdToStringData(offset_t lo,
+                                                                offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadTypeIdToDescriptorStringId32(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadProtoIdToShortyStringId32(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadProtoIdToReturnTypeId32(offset_t lo,
+                                                                   offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadProtoIdToParametersTypeList(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadFieldToClassTypeId16(offset_t lo,
+                                                                offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadFieldToTypeId16(offset_t lo,
+                                                           offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadFieldToNameStringId32(offset_t lo,
+                                                                 offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadMethodIdToClassTypeId16(offset_t lo,
+                                                                   offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadMethodIdToProtoId16(offset_t lo,
+                                                               offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadMethodIdToNameStringId32(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadClassDefToClassTypeId32(offset_t lo,
+                                                                   offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadClassDefToSuperClassTypeId32(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadClassDefToInterfacesTypeList(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadClassDefToSourceFileStringId32(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadClassDefToAnnotationDirectory(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadClassDefToClassData(offset_t lo,
+                                                               offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadClassDefToStaticValuesEncodedArray(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCallSiteIdToCallSite32(offset_t lo,
+                                                                  offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadMethodHandleToFieldId16(offset_t lo,
+                                                                   offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadMethodHandleToMethodId16(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadTypeListToTypeId16(offset_t lo,
+                                                              offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadAnnotationSetToAnnotation(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadAnnotationSetRefListToAnnotationSet(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader>
+  MakeReadAnnotationsDirectoryToClassAnnotationSet(offset_t lo, offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadAnnotationsDirectoryToFieldId32(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader>
+  MakeReadAnnotationsDirectoryToFieldAnnotationSet(offset_t lo, offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadAnnotationsDirectoryToMethodId32(
+      offset_t lo,
+      offset_t hi);
+  std::unique_ptr<ReferenceReader>
+  MakeReadAnnotationsDirectoryToMethodAnnotationSet(offset_t lo, offset_t hi);
+  std::unique_ptr<ReferenceReader>
+  MakeReadAnnotationsDirectoryToParameterMethodId32(offset_t lo, offset_t hi);
+  std::unique_ptr<ReferenceReader>
+  MakeReadAnnotationsDirectoryToParameterAnnotationSetRef(offset_t lo,
+                                                          offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToStringId16(offset_t lo,
+                                                            offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToStringId32(offset_t lo,
+                                                            offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToTypeId16(offset_t lo,
+                                                          offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToProtoId16(offset_t lo,
+                                                           offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToFieldId16(offset_t lo,
+                                                           offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToMethodId16(offset_t lo,
+                                                            offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToCallSiteId16(offset_t lo,
+                                                              offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToMethodHandle16(offset_t lo,
+                                                                offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToRelCode8(offset_t lo,
+                                                          offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToRelCode16(offset_t lo,
+                                                           offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToRelCode32(offset_t lo,
+                                                           offset_t hi);
+
+  // Functions that return reference writers. Different readers may share a
+  // common writer. Therefore these loosely follow canonical order of locations,
+  std::unique_ptr<ReferenceWriter> MakeWriteStringId16(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteStringId32(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteTypeId16(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteTypeId32(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteProtoId16(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteFieldId16(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteFieldId32(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteMethodId16(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteMethodId32(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteCallSiteId16(
+      MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteMethodHandle16(
+      MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteRelCode8(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteRelCode16(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteRelCode32(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteAbs32(MutableBufferView image);
+
+ private:
+  friend Disassembler;
+  using MapItemMap = std::map<uint16_t, const dex::MapItem*>;
+
+  // Disassembler:
+  bool Parse(ConstBufferView image) override;
+
+  bool ParseHeader();
+
+  const dex::HeaderItem* header_ = nullptr;
+  int dex_version_ = 0;
+  MapItemMap map_item_map_ = {};
+  dex::MapItem string_map_item_ = {};
+  dex::MapItem type_map_item_ = {};
+  dex::MapItem proto_map_item_ = {};
+  dex::MapItem field_map_item_ = {};
+  dex::MapItem method_map_item_ = {};
+  dex::MapItem class_def_map_item_ = {};
+  dex::MapItem call_site_map_item_ = {};
+  dex::MapItem method_handle_map_item_ = {};
+  dex::MapItem type_list_map_item_ = {};
+  dex::MapItem annotation_set_ref_list_map_item_ = {};
+  dex::MapItem annotation_set_map_item_ = {};
+  dex::MapItem code_map_item_ = {};
+  dex::MapItem annotations_directory_map_item_ = {};
+
+  // Sorted list of offsets of parsed items in |image_|.
+  std::vector<offset_t> code_item_offsets_;
+  std::vector<offset_t> type_list_offsets_;
+  std::vector<offset_t> annotation_set_ref_list_offsets_;
+  std::vector<offset_t> annotation_set_offsets_;
+  std::vector<offset_t> annotations_directory_item_offsets_;
+  std::vector<offset_t> annotations_directory_item_field_annotation_offsets_;
+  std::vector<offset_t> annotations_directory_item_method_annotation_offsets_;
+  std::vector<offset_t>
+      annotations_directory_item_parameter_annotation_offsets_;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_DISASSEMBLER_DEX_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_elf.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_elf.h
new file mode 100644
index 0000000..353c444
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_elf.h
@@ -0,0 +1,356 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_DISASSEMBLER_ELF_H_
+#define COMPONENTS_ZUCCHINI_DISASSEMBLER_ELF_H_
+
+#include <stdint.h>
+
+#include <algorithm>
+#include <deque>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "components/zucchini/address_translator.h"
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/disassembler.h"
+#include "components/zucchini/image_utils.h"
+#include "components/zucchini/rel32_finder.h"
+#include "components/zucchini/rel32_utils.h"
+#include "components/zucchini/reloc_elf.h"
+#include "components/zucchini/type_elf.h"
+
+namespace zucchini {
+
+struct ArmReferencePool {
+  enum : uint8_t {
+    kPoolReloc,
+    kPoolAbs32,
+    kPoolRel32,
+  };
+};
+
+struct AArch32ReferenceType {
+  enum : uint8_t {
+    kReloc,  // kPoolReloc
+
+    kAbs32,  // kPoolAbs32
+
+    kRel32_A24,  // kPoolRel32
+    kRel32_T8,
+    kRel32_T11,
+    kRel32_T20,
+    kRel32_T24,
+
+    kTypeCount
+  };
+};
+
+struct AArch64ReferenceType {
+  enum : uint8_t {
+    kReloc,  // kPoolReloc
+
+    kAbs32,  // kPoolAbs32
+
+    kRel32_Immd14,  // kPoolRel32
+    kRel32_Immd19,
+    kRel32_Immd26,
+
+    kTypeCount
+  };
+};
+
+struct Elf32Traits {
+  static constexpr uint16_t kVersion = 1;
+  static constexpr Bitness kBitness = kBit32;
+  static constexpr elf::FileClass kIdentificationClass = elf::ELFCLASS32;
+  using Elf_Shdr = elf::Elf32_Shdr;
+  using Elf_Phdr = elf::Elf32_Phdr;
+  using Elf_Ehdr = elf::Elf32_Ehdr;
+  using Elf_Rel = elf::Elf32_Rel;
+  using Elf_Rela = elf::Elf32_Rela;
+};
+
+// Architecture-specific definitions.
+
+struct Elf32IntelTraits : public Elf32Traits {
+  static constexpr ExecutableType kExeType = kExeTypeElfX86;
+  static const char kExeTypeString[];
+  static constexpr elf::MachineArchitecture kMachineValue = elf::EM_386;
+  static constexpr uint32_t kRelType = elf::R_386_RELATIVE;
+  enum : uint32_t { kVAWidth = 4 };
+  using Rel32FinderUse = Rel32FinderX86;
+};
+
+struct ElfAArch32Traits : public Elf32Traits {
+  static constexpr ExecutableType kExeType = kExeTypeElfAArch32;
+  static const char kExeTypeString[];
+  static constexpr elf::MachineArchitecture kMachineValue = elf::EM_ARM;
+  static constexpr uint32_t kRelType = elf::R_ARM_RELATIVE;
+  enum : uint32_t { kVAWidth = 4 };
+  using ArmReferenceType = AArch32ReferenceType;
+  using Rel32FinderUse = Rel32FinderAArch32;
+};
+
+struct Elf64Traits {
+  static constexpr uint16_t kVersion = 1;
+  static constexpr Bitness kBitness = kBit64;
+  static constexpr elf::FileClass kIdentificationClass = elf::ELFCLASS64;
+  using Elf_Shdr = elf::Elf64_Shdr;
+  using Elf_Phdr = elf::Elf64_Phdr;
+  using Elf_Ehdr = elf::Elf64_Ehdr;
+  using Elf_Rel = elf::Elf64_Rel;
+  using Elf_Rela = elf::Elf64_Rela;
+};
+
+// Architecture-specific definitions.
+struct Elf64IntelTraits : public Elf64Traits {
+  static constexpr ExecutableType kExeType = kExeTypeElfX64;
+  static const char kExeTypeString[];
+  static constexpr elf::MachineArchitecture kMachineValue = elf::EM_X86_64;
+  static constexpr uint32_t kRelType = elf::R_X86_64_RELATIVE;
+  enum : uint32_t { kVAWidth = 8 };
+  using Rel32FinderUse = Rel32FinderX64;
+};
+
+struct ElfAArch64Traits : public Elf64Traits {
+  static constexpr ExecutableType kExeType = kExeTypeElfAArch64;
+  static const char kExeTypeString[];
+  static constexpr elf::MachineArchitecture kMachineValue = elf::EM_AARCH64;
+  // TODO(huangs): See if R_AARCH64_GLOB_DAT and R_AARCH64_JUMP_SLOT should be
+  // used.
+  static constexpr uint32_t kRelType = elf::R_AARCH64_RELATIVE;
+  enum : uint32_t { kVAWidth = 8 };
+  using ArmReferenceType = AArch64ReferenceType;
+  using Rel32FinderUse = Rel32FinderAArch64;
+};
+
+// Decides whether target |offset| is covered by a section in |sorted_headers|.
+template <class ELF_SHDR>
+bool IsTargetOffsetInElfSectionList(
+    const std::vector<const ELF_SHDR*>& sorted_headers,
+    offset_t offset) {
+  // Use binary search to search in a list of intervals, in a fashion similar to
+  // AddressTranslator::OffsetToUnit().
+  auto comp = [](offset_t offset, const ELF_SHDR* header) -> bool {
+    return offset < header->sh_offset;
+  };
+  auto it = std::upper_bound(sorted_headers.begin(), sorted_headers.end(),
+                             offset, comp);
+  if (it == sorted_headers.begin())
+    return false;
+  --it;
+  // Just check offset without worrying about width, since this is a target.
+  // Not using RangeCovers() because |sh_offset| and |sh_size| can be 64-bit.
+  return offset >= (*it)->sh_offset &&
+         offset - (*it)->sh_offset < (*it)->sh_size;
+}
+
+// Disassembler for ELF.
+template <class TRAITS>
+class DisassemblerElf : public Disassembler {
+ public:
+  using Traits = TRAITS;
+  static constexpr uint16_t kVersion = Traits::kVersion;
+  // Applies quick checks to determine whether |image| *may* point to the start
+  // of an executable. Returns true iff the check passes.
+  static bool QuickDetect(ConstBufferView image);
+
+  DisassemblerElf(const DisassemblerElf&) = delete;
+  const DisassemblerElf& operator=(const DisassemblerElf&) = delete;
+  ~DisassemblerElf() override;
+
+  // Disassembler:
+  ExecutableType GetExeType() const override;
+  std::string GetExeTypeString() const override;
+  std::vector<ReferenceGroup> MakeReferenceGroups() const override = 0;
+
+  // Read/Write functions that are common among different architectures.
+  std::unique_ptr<ReferenceReader> MakeReadRelocs(offset_t lo, offset_t hi);
+  std::unique_ptr<ReferenceWriter> MakeWriteRelocs(MutableBufferView image);
+
+  const AddressTranslator& translator() const { return translator_; }
+
+ protected:
+  friend Disassembler;
+
+  DisassemblerElf();
+
+  bool Parse(ConstBufferView image) override;
+
+  // Returns the supported Elf_Ehdr::e_machine enum.
+  static constexpr elf::MachineArchitecture supported_architecture() {
+    return Traits::kMachineValue;
+  }
+
+  // Returns the type to look for in the reloc section.
+  static constexpr uint32_t supported_relocation_type() {
+    return Traits::kRelType;
+  }
+
+  // Performs architecture-specific parsing of an executable section, to extract
+  // rel32 references.
+  virtual void ParseExecSection(const typename Traits::Elf_Shdr& section) = 0;
+
+  // Processes rel32 data after they are extracted from executable sections.
+  virtual void PostProcessRel32() = 0;
+
+  // Parses ELF header and section headers, and performs basic validation.
+  // Returns whether parsing was successful.
+  bool ParseHeader();
+
+  // Extracts and stores section headers that we need.
+  void ExtractInterestingSectionHeaders();
+
+  // Parsing functions that extract references from various sections.
+  void GetAbs32FromRelocSections();
+  void GetRel32FromCodeSections();
+  void ParseSections();
+
+  // Main ELF header.
+  const typename Traits::Elf_Ehdr* header_ = nullptr;
+
+  // Section header table, ordered by section id.
+  elf::Elf32_Half sections_count_ = 0;
+  const typename Traits::Elf_Shdr* sections_ = nullptr;
+
+  // Program header table.
+  elf::Elf32_Half segments_count_ = 0;
+  const typename Traits::Elf_Phdr* segments_ = nullptr;
+
+  // Bit fields to store the role each section may play.
+  std::vector<int> section_judgements_;
+
+  // Translator between offsets and RVAs.
+  AddressTranslator translator_;
+
+  // Identity translator for abs32 translation.
+  AddressTranslator identity_translator_;
+
+  // Extracted relocation section dimensions data, sorted by file offsets.
+  std::vector<SectionDimensionsElf> reloc_section_dims_;
+
+  // Headers of executable sections, sorted by file offsets of the data each
+  // header points to.
+  std::vector<const typename Traits::Elf_Shdr*> exec_headers_;
+
+  // Sorted file offsets of abs32 locations.
+  std::vector<offset_t> abs32_locations_;
+};
+
+// Disassembler for ELF with Intel architectures.
+template <class TRAITS>
+class DisassemblerElfIntel : public DisassemblerElf<TRAITS> {
+ public:
+  using Traits = TRAITS;
+  enum ReferenceType : uint8_t { kReloc, kAbs32, kRel32, kTypeCount };
+
+  DisassemblerElfIntel();
+  DisassemblerElfIntel(const DisassemblerElfIntel&) = delete;
+  const DisassemblerElfIntel& operator=(const DisassemblerElfIntel&) = delete;
+  ~DisassemblerElfIntel() override;
+
+  // Disassembler:
+  std::vector<ReferenceGroup> MakeReferenceGroups() const override;
+
+  // DisassemblerElf:
+  void ParseExecSection(const typename Traits::Elf_Shdr& section) override;
+  void PostProcessRel32() override;
+
+  // Specialized Read/Write functions.
+  std::unique_ptr<ReferenceReader> MakeReadAbs32(offset_t lo, offset_t hi);
+  std::unique_ptr<ReferenceWriter> MakeWriteAbs32(MutableBufferView image);
+  std::unique_ptr<ReferenceReader> MakeReadRel32(offset_t lo, offset_t hi);
+  std::unique_ptr<ReferenceWriter> MakeWriteRel32(MutableBufferView image);
+
+ private:
+  // Sorted file offsets of rel32 locations.
+  // Using std::deque to reduce peak memory footprint.
+  std::deque<offset_t> rel32_locations_;
+};
+
+using DisassemblerElfX86 = DisassemblerElfIntel<Elf32IntelTraits>;
+using DisassemblerElfX64 = DisassemblerElfIntel<Elf64IntelTraits>;
+
+// Disassembler for ELF with ARM architectures.
+template <class TRAITS>
+class DisassemblerElfArm : public DisassemblerElf<TRAITS> {
+ public:
+  using Traits = TRAITS;
+  DisassemblerElfArm();
+  DisassemblerElfArm(const DisassemblerElfArm&) = delete;
+  const DisassemblerElfArm& operator=(const DisassemblerElfArm&) = delete;
+  ~DisassemblerElfArm() override;
+
+  // Determines whether target |offset| is in an executable section.
+  bool IsTargetOffsetInExecSection(offset_t offset) const;
+
+  // Creates an architecture-specific Rel32Finder for ParseExecSection.
+  virtual std::unique_ptr<typename Traits::Rel32FinderUse> MakeRel32Finder(
+      const typename Traits::Elf_Shdr& section) = 0;
+
+  // DisassemblerElf:
+  void ParseExecSection(const typename Traits::Elf_Shdr& section) override;
+  void PostProcessRel32() override;
+
+  // Specialized Read/Write functions.
+  std::unique_ptr<ReferenceReader> MakeReadAbs32(offset_t lo, offset_t hi);
+  std::unique_ptr<ReferenceWriter> MakeWriteAbs32(MutableBufferView image);
+
+  // Specialized Read/Write functions for different rel32 address types.
+  template <class ADDR_TRAITS>
+  std::unique_ptr<ReferenceReader> MakeReadRel32(offset_t lower,
+                                                 offset_t upper);
+  template <class ADDR_TRAITS>
+  std::unique_ptr<ReferenceWriter> MakeWriteRel32(MutableBufferView image);
+
+ protected:
+  // Sorted file offsets of rel32 locations for each rel32 address type.
+  std::deque<offset_t>
+      rel32_locations_table_[Traits::ArmReferenceType::kTypeCount];
+};
+
+// Disassembler for ELF with AArch32 (AKA ARM32).
+class DisassemblerElfAArch32 : public DisassemblerElfArm<ElfAArch32Traits> {
+ public:
+  DisassemblerElfAArch32();
+  DisassemblerElfAArch32(const DisassemblerElfAArch32&) = delete;
+  const DisassemblerElfAArch32& operator=(const DisassemblerElfAArch32&) =
+      delete;
+  ~DisassemblerElfAArch32() override;
+
+  // Disassembler:
+  std::vector<ReferenceGroup> MakeReferenceGroups() const override;
+
+  // DisassemblerElfArm:
+  std::unique_ptr<typename Traits::Rel32FinderUse> MakeRel32Finder(
+      const typename Traits::Elf_Shdr& section) override;
+
+  // Under the naive assumption that an executable section is entirely ARM mode
+  // or THUMB2 mode, this function implements heuristics to distinguish between
+  // the two. Returns true if section is THUMB2 mode; otherwise return false.
+  bool IsExecSectionThumb2(const typename Traits::Elf_Shdr& section) const;
+};
+
+// Disassembler for ELF with AArch64 (AKA ARM64).
+class DisassemblerElfAArch64 : public DisassemblerElfArm<ElfAArch64Traits> {
+ public:
+  DisassemblerElfAArch64();
+  DisassemblerElfAArch64(const DisassemblerElfAArch64&) = delete;
+  const DisassemblerElfAArch64& operator=(const DisassemblerElfAArch64&) =
+      delete;
+  ~DisassemblerElfAArch64() override;
+
+  // Disassembler:
+  std::vector<ReferenceGroup> MakeReferenceGroups() const override;
+
+  // DisassemblerElfArm:
+  std::unique_ptr<typename Traits::Rel32FinderUse> MakeRel32Finder(
+      const typename Traits::Elf_Shdr& section) override;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_DISASSEMBLER_ELF_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_no_op.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_no_op.h
new file mode 100644
index 0000000..1d436dd
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_no_op.h
@@ -0,0 +1,41 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_DISASSEMBLER_NO_OP_H_
+#define COMPONENTS_ZUCCHINI_DISASSEMBLER_NO_OP_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/disassembler.h"
+#include "components/zucchini/image_utils.h"
+
+namespace zucchini {
+
+// This disassembler works on any file and does not look for reference.
+class DisassemblerNoOp : public Disassembler {
+ public:
+  static constexpr uint16_t kVersion = 1;
+
+  DisassemblerNoOp();
+  DisassemblerNoOp(const DisassemblerNoOp&) = delete;
+  const DisassemblerNoOp& operator=(const DisassemblerNoOp&) = delete;
+  ~DisassemblerNoOp() override;
+
+  // Disassembler:
+  ExecutableType GetExeType() const override;
+  std::string GetExeTypeString() const override;
+  std::vector<ReferenceGroup> MakeReferenceGroups() const override;
+
+ private:
+  friend Disassembler;
+
+  bool Parse(ConstBufferView image) override;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_DISASSEMBLER_NO_OP_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/element_detection.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/element_detection.h
new file mode 100644
index 0000000..7d4b0bc
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/element_detection.h
@@ -0,0 +1,62 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_ELEMENT_DETECTION_H_
+#define COMPONENTS_ZUCCHINI_ELEMENT_DETECTION_H_
+
+#include <stddef.h>
+
+#include <memory>
+#include <optional>
+
+#include "base/callback.h"
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/image_utils.h"
+
+namespace zucchini {
+
+class Disassembler;
+
+// Attempts to detect an executable located at start of |image|. If found,
+// returns the corresponding disassembler. Otherwise returns null.
+std::unique_ptr<Disassembler> MakeDisassemblerWithoutFallback(
+    ConstBufferView image);
+
+// Attempts to create a disassembler corresponding to |exe_type| and initialize
+// it with |image|, On failure, returns null.
+std::unique_ptr<Disassembler> MakeDisassemblerOfType(ConstBufferView image,
+                                                     ExecutableType exe_type);
+
+// Returns the version associated with disassembler of type |exe_type|.
+uint16_t DisassemblerVersionOfType(ExecutableType exe_type);
+
+// Attempts to detect an element associated with |image| and returns it, or
+// returns nullopt if no element is detected.
+using ElementDetector =
+    base::RepeatingCallback<std::optional<Element>(ConstBufferView image)>;
+
+// Implementation of ElementDetector using disassemblers.
+std::optional<Element> DetectElementFromDisassembler(ConstBufferView image);
+
+// A class to scan through an image and iteratively detect elements.
+class ElementFinder {
+ public:
+  ElementFinder(ConstBufferView image, ElementDetector&& detector);
+  ElementFinder(const ElementFinder&) = delete;
+  const ElementFinder& operator=(const ElementFinder&) = delete;
+  ~ElementFinder();
+
+  // Scans for the next executable using |detector|. Returns the next element
+  // found, or nullopt if no more element can be found.
+  std::optional<Element> GetNext();
+
+ private:
+  ConstBufferView image_;
+  ElementDetector detector_;
+  offset_t pos_ = 0;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_ELEMENT_DETECTION_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/encoded_view.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/encoded_view.h
new file mode 100644
index 0000000..864d265
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/encoded_view.h
@@ -0,0 +1,185 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_ENCODED_VIEW_H_
+#define COMPONENTS_ZUCCHINI_ENCODED_VIEW_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <iterator>
+#include <vector>
+
+#include "components/zucchini/image_index.h"
+#include "components/zucchini/image_utils.h"
+
+namespace zucchini {
+
+// Zucchini-gen performs semantics-aware matching:
+// - Same-typed reference target in "old" and "new" can be associated.
+//   Associated targets are assigned an identifier called "label" (and for
+//   unassociated targets, label = 0).
+// - EncodedView maps each offset in "old" and "new" images to a "projected
+//   value", which can be:
+//   - Raw byte value (0-255) for non-references.
+//   - Reference "projected value" (> 256) that depends on target {type, label}
+//     at each reference's location (byte 0).
+//   - Reference padding value (256) at the body of each reference (bytes 1+).
+// - The projected values for "old" and "new" are used to build the equivalence
+//   map.
+
+constexpr size_t kReferencePaddingProjection = 256;
+constexpr size_t kBaseReferenceProjection = 257;
+
+// A Range (providing begin and end iterators) that adapts ImageIndex to make
+// image data appear as an Encoded Image, that is encoded data under a higher
+// level of abstraction than raw bytes. In particular:
+// - First byte of each reference become a projection of its type and label.
+// - Subsequent bytes of each reference becomes |kReferencePaddingProjection|.
+// - Non-reference raw bytes remain as raw bytes.
+class EncodedView {
+ public:
+  // RandomAccessIterator whose values are the results of Projection().
+  class Iterator {
+   public:
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = size_t;
+    using difference_type = ptrdiff_t;
+    using reference = size_t;
+    using pointer = size_t*;
+
+    Iterator(const EncodedView* encoded_view, difference_type pos)
+        : encoded_view_(encoded_view), pos_(pos) {}
+
+    Iterator(const Iterator&) = default;
+
+    Iterator& operator=(const Iterator&) = default;
+
+    value_type operator*() const {
+      return encoded_view_->Projection(static_cast<offset_t>(pos_));
+    }
+
+    value_type operator[](difference_type n) const {
+      return encoded_view_->Projection(static_cast<offset_t>(pos_ + n));
+    }
+
+    Iterator& operator++() {
+      ++pos_;
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      Iterator tmp = *this;
+      ++pos_;
+      return tmp;
+    }
+
+    Iterator& operator--() {
+      --pos_;
+      return *this;
+    }
+
+    Iterator operator--(int) {
+      Iterator tmp = *this;
+      --pos_;
+      return tmp;
+    }
+
+    Iterator& operator+=(difference_type n) {
+      pos_ += n;
+      return *this;
+    }
+
+    Iterator& operator-=(difference_type n) {
+      pos_ -= n;
+      return *this;
+    }
+
+    friend bool operator==(Iterator a, Iterator b) { return a.pos_ == b.pos_; }
+
+    friend bool operator!=(Iterator a, Iterator b) { return !(a == b); }
+
+    friend bool operator<(Iterator a, Iterator b) { return a.pos_ < b.pos_; }
+
+    friend bool operator>(Iterator a, Iterator b) { return b < a; }
+
+    friend bool operator<=(Iterator a, Iterator b) { return !(b < a); }
+
+    friend bool operator>=(Iterator a, Iterator b) { return !(a < b); }
+
+    friend difference_type operator-(Iterator a, Iterator b) {
+      return a.pos_ - b.pos_;
+    }
+
+    friend Iterator operator+(Iterator it, difference_type n) {
+      it += n;
+      return it;
+    }
+
+    friend Iterator operator-(Iterator it, difference_type n) {
+      it -= n;
+      return it;
+    }
+
+   private:
+    const EncodedView* encoded_view_;
+    difference_type pos_;
+  };
+
+  using value_type = size_t;
+  using size_type = offset_t;
+  using difference_type = ptrdiff_t;
+  using const_iterator = Iterator;
+
+  // |image_index| is the annotated image being adapted, and is required to
+  // remain valid for the lifetime of the object.
+  explicit EncodedView(const ImageIndex& image_index);
+  EncodedView(const EncodedView&) = delete;
+  const EncodedView& operator=(const EncodedView&) = delete;
+  ~EncodedView();
+
+  // Projects |location| to a scalar value that describes the content at a
+  // higher level of abstraction.
+  value_type Projection(offset_t location) const;
+
+  bool IsToken(offset_t location) const {
+    return image_index_.IsToken(location);
+  }
+
+  // Returns the cardinality of the projection, i.e., the upper bound on
+  // values returned by Projection().
+  value_type Cardinality() const;
+
+  // Associates |labels| to targets for a given |pool|, replacing previous
+  // association. Values in |labels| must be smaller than |bound|.
+  void SetLabels(PoolTag pool, std::vector<uint32_t>&& labels, size_t bound);
+  const ImageIndex& image_index() const { return image_index_; }
+
+  // Range functions.
+  size_type size() const { return size_type(image_index_.size()); }
+  const_iterator begin() const {
+    return const_iterator{this, difference_type(0)};
+  }
+  const_iterator end() const {
+    return const_iterator{this, difference_type(size())};
+  }
+
+ private:
+  struct PoolInfo {
+    PoolInfo();
+    PoolInfo(PoolInfo&&);
+    ~PoolInfo();
+
+    // |labels| translates IndirectReference target_key to label.
+    std::vector<uint32_t> labels;
+    size_t bound = 0;
+  };
+
+  const ImageIndex& image_index_;
+  std::vector<PoolInfo> pool_infos_;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_ENCODED_VIEW_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/equivalence_map.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/equivalence_map.h
new file mode 100644
index 0000000..af99ac4
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/equivalence_map.h
@@ -0,0 +1,208 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_EQUIVALENCE_MAP_H_
+#define COMPONENTS_ZUCCHINI_EQUIVALENCE_MAP_H_
+
+#include <stddef.h>
+
+#include <deque>
+#include <limits>
+#include <vector>
+
+#include "components/zucchini/image_index.h"
+#include "components/zucchini/image_utils.h"
+#include "components/zucchini/targets_affinity.h"
+
+namespace zucchini {
+
+constexpr double kMismatchFatal = -std::numeric_limits<double>::infinity();
+
+class EncodedView;
+class EquivalenceSource;
+
+// Returns similarity score between a token (raw byte or first byte of a
+// reference) in |old_image_index| at |src| and a token in |new_image_index|
+// at |dst|. |targets_affinities| describes affinities for each target pool and
+// is used to evaluate similarity between references, hence it's size must be
+// equal to the number of pools in both |old_image_index| and |new_image_index|.
+// Both |src| and |dst| must refer to tokens in |old_image_index| and
+// |new_image_index|.
+double GetTokenSimilarity(
+    const ImageIndex& old_image_index,
+    const ImageIndex& new_image_index,
+    const std::vector<TargetsAffinity>& targets_affinities,
+    offset_t src,
+    offset_t dst);
+
+// Returns a similarity score between content in |old_image_index| and
+// |new_image_index| at regions described by |equivalence|, using
+// |targets_affinities| to evaluate similarity between references.
+double GetEquivalenceSimilarity(
+    const ImageIndex& old_image_index,
+    const ImageIndex& new_image_index,
+    const std::vector<TargetsAffinity>& targets_affinities,
+    const Equivalence& equivalence);
+
+// Extends |equivalence| forward and returns the result. This is related to
+// VisitEquivalenceSeed().
+EquivalenceCandidate ExtendEquivalenceForward(
+    const ImageIndex& old_image_index,
+    const ImageIndex& new_image_index,
+    const std::vector<TargetsAffinity>& targets_affinities,
+    const EquivalenceCandidate& equivalence,
+    double min_similarity);
+
+// Extends |equivalence| backward and returns the result. This is related to
+// VisitEquivalenceSeed().
+EquivalenceCandidate ExtendEquivalenceBackward(
+    const ImageIndex& old_image_index,
+    const ImageIndex& new_image_index,
+    const std::vector<TargetsAffinity>& targets_affinities,
+    const EquivalenceCandidate& equivalence,
+    double min_similarity);
+
+// Creates an equivalence, starting with |src| and |dst| as offset hint, and
+// extends it both forward and backward, trying to maximise similarity between
+// |old_image_index| and |new_image_index|, and returns the result.
+// |targets_affinities| is used to evaluate similarity between references.
+// |min_similarity| describes the minimum acceptable similarity score and is
+// used as threshold to discard bad equivalences.
+EquivalenceCandidate VisitEquivalenceSeed(
+    const ImageIndex& old_image_index,
+    const ImageIndex& new_image_index,
+    const std::vector<TargetsAffinity>& targets_affinities,
+    offset_t src,
+    offset_t dst,
+    double min_similarity);
+
+// Container of pruned equivalences used to map offsets from |old_image| to
+// offsets in |new_image|. Equivalences are pruned by cropping smaller
+// equivalences to avoid overlaps, to make the equivalence map (for covered
+// bytes in |old_image| and |new_image|) one-to-one.
+class OffsetMapper {
+ public:
+  using const_iterator = std::deque<Equivalence>::const_iterator;
+
+  // Constructors for various data sources. "Old" and "new" image sizes are
+  // needed for bounds checks and to handle dangling targets.
+  // - From a list of |equivalences|, already sorted (by |src_offset|) and
+  //   pruned, useful for tests.
+  OffsetMapper(std::deque<Equivalence>&& equivalences,
+               offset_t old_image_size,
+               offset_t new_image_size);
+  // - From a generator, useful for Zucchini-apply.
+  OffsetMapper(EquivalenceSource&& equivalence_source,
+               offset_t old_image_size,
+               offset_t new_image_size);
+  // - From an EquivalenceMap that needs to be processed, useful for
+  //   Zucchini-gen.
+  OffsetMapper(const EquivalenceMap& equivalence_map,
+               offset_t old_image_size,
+               offset_t new_image_size);
+  ~OffsetMapper();
+
+  size_t size() const { return equivalences_.size(); }
+  const_iterator begin() const { return equivalences_.begin(); }
+  const_iterator end() const { return equivalences_.end(); }
+
+  // Returns naive extended forward-projection of "old" |offset| that follows
+  // |eq|'s delta. |eq| needs not cover |offset|.
+  // - Averts underflow / overflow by clamping to |[0, new_image_size_)|.
+  // - However, |offset| is *not* restricted to |[0, old_image_size_)|; the
+  //   caller must to make the check (hence "naive").
+  offset_t NaiveExtendedForwardProject(const Equivalence& unit,
+                                       offset_t offset) const;
+
+  // Returns an offset in |new_image| corresponding to |offset| in |old_image|.
+  // Assumes |equivalences_| to be non-empty. Cases:
+  // - If |offset| is covered (i.e., in an "old" block), then use the delta of
+  //   the (unique) equivalence unit that covers |offset|.
+  // - If |offset| is non-covered, but in |[0, old_image_size_)|, then find the
+  //   nearest "old" block, use its delta, and avert underflow / overflow by
+  //   clamping the result to |[0, new_image_size_)|.
+  // - If |offset| is >= |new_image_size_| (a "fake offset"), then use
+  //   |new_image_size_ - old_image_size_| as the delta.
+  offset_t ExtendedForwardProject(offset_t offset) const;
+
+  // Given sorted |offsets|, applies a projection in-place of all offsets that
+  // are part of a pruned equivalence from |old_image| to |new_image|. Other
+  // offsets are removed from |offsets|.
+  void ForwardProjectAll(std::deque<offset_t>* offsets) const;
+
+  // Accessor for testing.
+  const std::deque<Equivalence> equivalences() const { return equivalences_; }
+
+  // Sorts |equivalences| by |src_offset| and removes all source overlaps; so a
+  // source location that was covered by some Equivalence would become covered
+  // by exactly one Equivalence. Moreover, for the offset, the equivalence
+  // corresponds to the largest (pre-pruning) covering Equivalence, and in case
+  // of a tie, the Equivalence with minimal |src_offset|. |equivalences| may
+  // change in size since empty Equivalences are removed.
+  static void PruneEquivalencesAndSortBySource(
+      std::deque<Equivalence>* equivalences);
+
+ private:
+  // |equivalences_| is pruned, i.e., no "old" blocks overlap (and no "new"
+  // block overlaps). Also, it is sorted by "old" offsets.
+  std::deque<Equivalence> equivalences_;
+  const offset_t old_image_size_;
+  const offset_t new_image_size_;
+};
+
+// Container of equivalences between |old_image_index| and |new_image_index|,
+// sorted by |Equivalence::dst_offset|, only used during patch generation.
+class EquivalenceMap {
+ public:
+  using const_iterator = std::vector<EquivalenceCandidate>::const_iterator;
+
+  EquivalenceMap();
+  // Initializes the object with |equivalences|.
+  explicit EquivalenceMap(std::vector<EquivalenceCandidate>&& candidates);
+  EquivalenceMap(EquivalenceMap&&);
+  EquivalenceMap(const EquivalenceMap&) = delete;
+  ~EquivalenceMap();
+
+  // Finds relevant equivalences between |old_view| and |new_view|, using
+  // suffix array |old_sa| computed from |old_view| and using
+  // |targets_affinities| to evaluate similarity between references. This
+  // function is not symmetric. Equivalences might overlap in |old_view|, but
+  // not in |new_view|. It tries to maximize accumulated similarity within each
+  // equivalence, while maximizing |new_view| coverage. The minimum similarity
+  // of an equivalence is given by |min_similarity|.
+  void Build(const std::vector<offset_t>& old_sa,
+             const EncodedView& old_view,
+             const EncodedView& new_view,
+             const std::vector<TargetsAffinity>& targets_affinities,
+             double min_similarity);
+
+  size_t size() const { return candidates_.size(); }
+  const_iterator begin() const { return candidates_.begin(); }
+  const_iterator end() const { return candidates_.end(); }
+
+ private:
+  // Discovers equivalence candidates between |old_view| and |new_view| and
+  // stores them in the object. Note that resulting candidates are not sorted
+  // and might be overlapping in new image.
+  void CreateCandidates(const std::vector<offset_t>& old_sa,
+                        const EncodedView& old_view,
+                        const EncodedView& new_view,
+                        const std::vector<TargetsAffinity>& targets_affinities,
+                        double min_similarity);
+  // Sorts candidates by their offset in new image.
+  void SortByDestination();
+  // Visits |candidates_| (sorted by |dst_offset|) and remove all destination
+  // overlaps. Candidates with low similarity scores are more likely to be
+  // shrunken. Unfit candidates may be removed.
+  void Prune(const EncodedView& old_view,
+             const EncodedView& new_view,
+             const std::vector<TargetsAffinity>& targets_affinities,
+             double min_similarity);
+
+  std::vector<EquivalenceCandidate> candidates_;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_EQUIVALENCE_MAP_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_index.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_index.h
new file mode 100644
index 0000000..b5acee1
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_index.h
@@ -0,0 +1,116 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_IMAGE_INDEX_H_
+#define COMPONENTS_ZUCCHINI_IMAGE_INDEX_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <map>
+#include <vector>
+
+#include "base/check_op.h"
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/image_utils.h"
+#include "components/zucchini/reference_set.h"
+#include "components/zucchini/target_pool.h"
+
+namespace zucchini {
+
+class Disassembler;
+
+// A class that holds annotations of an image, allowing quick access to its raw
+// and reference content. The memory overhead of storing all references is
+// relatively high, so this is only used during patch generation.
+class ImageIndex {
+ public:
+  explicit ImageIndex(ConstBufferView image);
+  ImageIndex(const ImageIndex&) = delete;
+  ImageIndex(ImageIndex&&);
+  ~ImageIndex();
+
+  // Inserts all references read from |disasm|. This should be called exactly
+  // once. If overlap between any two references of any type is encountered,
+  // returns false and leaves the object in an invalid state. Otherwise,
+  // returns true.
+  // TODO(huangs): Refactor ReaderFactory and WriterFactory so
+  // |const Disassembler&| can be used here.
+  bool Initialize(Disassembler* disasm);
+
+  // Returns the array size needed to accommodate all reference type values.
+  size_t TypeCount() const {
+    if (reference_sets_.empty())
+      return 0U;
+    return reference_sets_.rbegin()->first.value() + 1;  // Max key + 1.
+  }
+
+  // Returns the array size needed to accommodate all pool values.
+  size_t PoolCount() const {
+    if (target_pools_.empty())
+      return 0U;
+    return target_pools_.rbegin()->first.value() + 1;  // Max key + 1.
+  }
+
+  // Returns true if |image_[location]| is either:
+  // - A raw value.
+  // - The first byte of a reference.
+  bool IsToken(offset_t location) const;
+
+  // Returns true if |image_[location]| is part of a reference.
+  bool IsReference(offset_t location) const {
+    return LookupType(location) != kNoTypeTag;
+  }
+
+  // Returns the type tag of the reference covering |location|, or kNoTypeTag if
+  // |location| is not part of a reference.
+  TypeTag LookupType(offset_t location) const {
+    DCHECK_LT(location, size());
+    return type_tags_[location];
+  }
+
+  // Returns the raw value at |location|.
+  uint8_t GetRawValue(offset_t location) const {
+    DCHECK_LT(location, size());
+    return image_[location];
+  }
+
+  const std::map<PoolTag, TargetPool>& target_pools() const {
+    return target_pools_;
+  }
+  const std::map<TypeTag, ReferenceSet>& reference_sets() const {
+    return reference_sets_;
+  }
+
+  const TargetPool& pool(PoolTag pool_tag) const {
+    return target_pools_.at(pool_tag);
+  }
+  const ReferenceSet& refs(TypeTag type_tag) const {
+    return reference_sets_.at(type_tag);
+  }
+
+  // Returns the size of the image.
+  size_t size() const { return image_.size(); }
+
+ private:
+  // Inserts to |*this| index, all references described by |traits| read from
+  // |ref_reader|, which gets consumed. This should be called exactly once for
+  // each reference type. If overlap between any two references of any type is
+  // encountered, returns false and leaves the object in an invalid state.
+  // Otherwise, returns true.
+  bool InsertReferences(const ReferenceTypeTraits& traits,
+                        ReferenceReader&& ref_reader);
+
+  const ConstBufferView image_;
+
+  // Used for random access lookup of reference type, for each byte in |image_|.
+  std::vector<TypeTag> type_tags_;
+
+  std::map<PoolTag, TargetPool> target_pools_;
+  std::map<TypeTag, ReferenceSet> reference_sets_;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_IMAGE_INDEX_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_utils.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_utils.h
new file mode 100644
index 0000000..7bfa8cf
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_utils.h
@@ -0,0 +1,225 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_IMAGE_UTILS_H_
+#define COMPONENTS_ZUCCHINI_IMAGE_UTILS_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <optional>
+#include <string>
+
+#include "base/format_macros.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/strings/stringprintf.h"
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/typed_value.h"
+
+namespace zucchini {
+
+// offset_t is used to describe an offset in an image.
+// Files bigger than 4GB are not supported.
+using offset_t = uint32_t;
+// Divide by 2 since label marking uses the most significant bit.
+constexpr offset_t kOffsetBound = static_cast<offset_t>(-1) / 2;
+// Use 0xFFFFFFF*E*, since 0xFFFFFFF*F* is a sentinel value for Dex references.
+constexpr offset_t kInvalidOffset = static_cast<offset_t>(-2);
+
+// key_t is used to identify an offset in a table.
+using key_t = uint32_t;
+
+enum Bitness : uint8_t {
+  // The numerical values are intended to simplify WidthOf() below.
+  kBit32 = 4,
+  kBit64 = 8
+};
+
+inline uint32_t WidthOf(Bitness bitness) {
+  return static_cast<uint32_t>(bitness);
+}
+
+// Used to uniquely identify a reference type.
+// Strongly typed objects are used to avoid ambiguitees with PoolTag.
+struct TypeTag : public TypedValue<TypeTag, uint8_t> {
+  // inheriting constructor:
+  using TypedValue<TypeTag, uint8_t>::TypedValue;
+};
+
+// Used to uniquely identify a pool.
+struct PoolTag : public TypedValue<PoolTag, uint8_t> {
+  // inheriting constructor:
+  using TypedValue<PoolTag, uint8_t>::TypedValue;
+};
+
+constexpr TypeTag kNoTypeTag(0xFF);  // Typically used to identify raw data.
+constexpr PoolTag kNoPoolTag(0xFF);
+
+// Specification of references in an image file.
+struct ReferenceTypeTraits {
+  constexpr ReferenceTypeTraits(offset_t width_in,
+                                TypeTag type_tag_in,
+                                PoolTag pool_tag_in)
+      : width(width_in), type_tag(type_tag_in), pool_tag(pool_tag_in) {}
+
+  // |width| specifies number of bytes covered by the reference's binary
+  // encoding.
+  const offset_t width;
+  // |type_tag| identifies the reference type being described.
+  const TypeTag type_tag;
+  // |pool_tag| identifies the pool this type belongs to.
+  const PoolTag pool_tag;
+};
+
+// There is no need to store |type| because references of the same type are
+// always aggregated into the same container, and so during iteration we'd have
+// |type| already.
+struct Reference {
+  offset_t location;
+  offset_t target;
+};
+
+inline bool operator==(const Reference& a, const Reference& b) {
+  return a.location == b.location && a.target == b.target;
+}
+
+// Interface for extracting References through member function GetNext().
+// This is used by Disassemblers to extract references from an image file.
+// Typically, a Reader lazily extracts values and does not hold any storage.
+class ReferenceReader {
+ public:
+  virtual ~ReferenceReader() = default;
+
+  // Returns the next available Reference, or nullopt_t if exhausted.
+  // Extracted References must be ordered by their location in the image.
+  virtual std::optional<Reference> GetNext() = 0;
+};
+
+// Interface for writing References through member function
+// PutNext(reference). This is used by Disassemblers to write new References
+// in the image file.
+class ReferenceWriter {
+ public:
+  virtual ~ReferenceWriter() = default;
+
+  // Writes |reference| in the underlying image file. This operation always
+  // succeeds.
+  virtual void PutNext(Reference reference) = 0;
+};
+
+// An Equivalence is a block of length |length| that approximately match in
+// |old_image| at an offset of |src_offset| and in |new_image| at an offset of
+// |dst_offset|.
+struct Equivalence {
+  offset_t src_offset;
+  offset_t dst_offset;
+  offset_t length;
+
+  offset_t src_end() const { return src_offset + length; }
+  offset_t dst_end() const { return dst_offset + length; }
+};
+
+inline bool operator==(const Equivalence& a, const Equivalence& b) {
+  return a.src_offset == b.src_offset && a.dst_offset == b.dst_offset &&
+         a.length == b.length;
+}
+
+// Same as Equivalence, but with a similarity score. This is only used when
+// generating the patch.
+struct EquivalenceCandidate {
+  Equivalence eq;
+  double similarity;
+};
+
+template <size_t N>
+inline constexpr uint32_t ExeTypeToUint32(const char (&exe_type)[N]) {
+  static_assert(N == 5, "Expected ExeType of length 4 + 1 null byte.");
+  return (exe_type[3] << 24) | (exe_type[2] << 16) | (exe_type[1] << 8) |
+         exe_type[0];
+}
+
+// Enumerations for supported executables. Values in this enum must be distinct.
+// Once present, values should never be altered or removed to ensure backwards
+// compatibility and patch type collision avoidance.
+enum ExecutableType : uint32_t {
+  kExeTypeUnknown = UINT32_MAX,
+  kExeTypeNoOp = ExeTypeToUint32("NoOp"),
+  kExeTypeWin32X86 = ExeTypeToUint32("Px86"),
+  kExeTypeWin32X64 = ExeTypeToUint32("Px64"),
+  kExeTypeElfX86 = ExeTypeToUint32("Ex86"),
+  kExeTypeElfX64 = ExeTypeToUint32("Ex64"),
+  kExeTypeElfAArch32 = ExeTypeToUint32("EA32"),
+  kExeTypeElfAArch64 = ExeTypeToUint32("EA64"),
+  kExeTypeDex = ExeTypeToUint32("DEX "),
+  kExeTypeZtf = ExeTypeToUint32("ZTF "),
+};
+
+constexpr ExecutableType CastToExecutableType(uint32_t possible_exe_type) {
+  switch (static_cast<ExecutableType>(possible_exe_type)) {
+    case kExeTypeNoOp:        // Falls through.
+    case kExeTypeWin32X86:    // Falls through.
+    case kExeTypeWin32X64:    // Falls through.
+    case kExeTypeElfX86:      // Falls through.
+    case kExeTypeElfX64:      // Falls through.
+    case kExeTypeElfAArch32:  // Falls through.
+    case kExeTypeElfAArch64:  // Falls through.
+    case kExeTypeDex:         // Falls through.
+    case kExeTypeZtf:         // Falls through.
+    case kExeTypeUnknown:
+      return static_cast<ExecutableType>(possible_exe_type);
+    default:
+      return kExeTypeUnknown;
+  }
+}
+
+inline std::string CastExecutableTypeToString(ExecutableType exe_type) {
+  uint32_t v = static_cast<uint32_t>(exe_type);
+  char result[] = {static_cast<char>(v), static_cast<char>(v >> 8),
+                   static_cast<char>(v >> 16), static_cast<char>(v >> 24), 0};
+  return result;
+}
+
+// A region in an image with associated executable type |exe_type|. If
+// |exe_type == kExeTypeNoOp|, then the Element represents a region of raw data.
+struct Element : public BufferRegion {
+  Element() = default;
+  constexpr Element(const BufferRegion& region_in, ExecutableType exe_type_in)
+      : BufferRegion(region_in), exe_type(exe_type_in) {}
+  constexpr explicit Element(const BufferRegion& region_in)
+      : BufferRegion(region_in), exe_type(kExeTypeNoOp) {}
+
+  // Similar to lo() and hi(), but returns values in offset_t.
+  offset_t BeginOffset() const { return base::checked_cast<offset_t>(lo()); }
+  offset_t EndOffset() const { return base::checked_cast<offset_t>(hi()); }
+
+  BufferRegion region() const { return {offset, size}; }
+
+  friend bool operator==(const Element& a, const Element& b) {
+    return a.exe_type == b.exe_type && a.offset == b.offset && a.size == b.size;
+  }
+
+  ExecutableType exe_type;
+};
+
+// A matched pair of Elements.
+struct ElementMatch {
+  bool IsValid() const { return old_element.exe_type == new_element.exe_type; }
+  ExecutableType exe_type() const { return old_element.exe_type; }
+
+  // Represents match as "#+#=#+#", where "#" denotes the integers:
+  //   [offset in "old", size in "old", offset in "new", size in "new"].
+  // Note that element type is omitted.
+  std::string ToString() const {
+    return base::StringPrintf("%" PRIuS "+%" PRIuS "=%" PRIuS "+%" PRIuS "",
+                              old_element.offset, old_element.size,
+                              new_element.offset, new_element.size);
+  }
+
+  Element old_element;
+  Element new_element;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_IMAGE_UTILS_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/io_utils.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/io_utils.h
new file mode 100644
index 0000000..63eeec8
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/io_utils.h
@@ -0,0 +1,144 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_IO_UTILS_H_
+#define COMPONENTS_ZUCCHINI_IO_UTILS_H_
+
+#include <stdint.h>
+
+#include <cctype>
+#include <istream>
+#include <ostream>
+#include <sstream>
+#include <string>
+
+namespace zucchini {
+
+// An std::ostream wrapper that that limits number of std::endl lines to output,
+// useful for preventing excessive debug message output. Usage requires some
+// work by the caller. Sample:
+//   static LimitedOutputStream los(std::cerr, 10);
+//   if (!los.full()) {
+//     ...  // Prepare message. Block may be skipped so don't do other work!
+//     los << message;
+//     los << std::endl;  // Important!
+//   }
+class LimitedOutputStream : public std::ostream {
+ private:
+  class StreamBuf : public std::stringbuf {
+   public:
+    StreamBuf(std::ostream& os, int limit);
+    ~StreamBuf() override;
+
+    int sync() override;
+    bool full() const { return counter_ >= limit_; }
+
+   private:
+    std::ostream& os_;
+    const int limit_;
+    int counter_ = 0;
+  };
+
+ public:
+  LimitedOutputStream(std::ostream& os, int limit);
+  LimitedOutputStream(const LimitedOutputStream&) = delete;
+  const LimitedOutputStream& operator=(const LimitedOutputStream&) = delete;
+  bool full() const { return buf_.full(); }
+
+ private:
+  StreamBuf buf_;
+};
+
+// A class to render hexadecimal numbers for std::ostream with 0-padding. This
+// is more concise and flexible than stateful STL manipulator alternatives; so:
+//   std::ios old_fmt(nullptr);
+//   old_fmt.copyfmt(std::cout);
+//   std::cout << std::uppercase << std::hex;
+//   std::cout << std::setfill('0') << std::setw(8) << int_data << std::endl;
+//   std::cout.copyfmt(old_fmt);
+// can be expressed as:
+//   std::cout << AxHex<8>(int_data) << std::endl;
+template <int N, typename T = uint32_t>
+struct AsHex {
+  explicit AsHex(T value_in) : value(value_in) {}
+  T value;
+};
+
+template <int N, typename T>
+std::ostream& operator<<(std::ostream& os, const AsHex<N, T>& as_hex) {
+  char buf[N + 1];
+  buf[N] = '\0';
+  T value = as_hex.value;
+  for (int i = N - 1; i >= 0; --i, value >>= 4)
+    buf[i] = "0123456789ABCDEF"[static_cast<int>(value & 0x0F)];
+  if (value)
+    os << "...";  // To indicate data truncation, or negative values.
+  os << buf;
+  return os;
+}
+
+// An output manipulator to simplify printing list separators. Sample usage:
+//   PrefixSep sep(",");
+//   for (int i : {3, 1, 4, 1, 5, 9})
+//      std::cout << sep << i;
+//   std::cout << std::endl;  // Outputs "3,1,4,1,5,9\n".
+class PrefixSep {
+ public:
+  explicit PrefixSep(const std::string& sep_str) : sep_str_(sep_str) {}
+  PrefixSep(const PrefixSep&) = delete;
+  const PrefixSep& operator=(const PrefixSep&) = delete;
+
+  friend std::ostream& operator<<(std::ostream& ostr, PrefixSep& obj);
+
+ private:
+  std::string sep_str_;
+  bool first_ = true;
+};
+
+// An input manipulator that dictates the expected next character in
+// |std::istream|, and invalidates the stream if expectation is not met.
+class EatChar {
+ public:
+  explicit EatChar(char ch) : ch_(ch) {}
+  EatChar(const EatChar&) = delete;
+  const EatChar& operator=(const EatChar&) = delete;
+
+  friend inline std::istream& operator>>(std::istream& istr,
+                                         const EatChar& obj) {
+    if (!istr.fail() && istr.get() != obj.ch_)
+      istr.setstate(std::ios_base::failbit);
+    return istr;
+  }
+
+ private:
+  char ch_;
+};
+
+// An input manipulator that reads an unsigned integer from |std::istream|,
+// and invalidates the stream on failure. Intolerant of leading white spaces,
+template <typename T>
+class StrictUInt {
+ public:
+  explicit StrictUInt(T& var) : var_(var) {}
+  StrictUInt(const StrictUInt&) = default;
+
+  friend std::istream& operator>>(std::istream& istr, StrictUInt<T> obj) {
+    if (!istr.fail() && !::isdigit(istr.peek())) {
+      istr.setstate(std::ios_base::failbit);
+      return istr;
+    }
+    return istr >> obj.var_;
+  }
+
+ private:
+  T& var_;
+};
+
+// Stub out uint8_t: istream treats it as char, and value won't be read as int!
+template <>
+struct StrictUInt<uint8_t> {};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_IO_UTILS_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_reader.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_reader.h
new file mode 100644
index 0000000..ed0ab9c
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_reader.h
@@ -0,0 +1,285 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_PATCH_READER_H_
+#define COMPONENTS_ZUCCHINI_PATCH_READER_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <map>
+#include <optional>
+#include <vector>
+
+#include "base/debug/stack_trace.h"
+#include "base/logging.h"
+#include "base/numerics/checked_math.h"
+#include "components/zucchini/buffer_source.h"
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/image_utils.h"
+#include "components/zucchini/patch_utils.h"
+
+namespace zucchini {
+
+namespace patch {
+
+// The Parse*() functions below attempt to extract data of a specific type from
+// the beginning of |source|. A parse function: On success, consumes the used
+// portion of |source|, writes data into the output parameter, and returns
+// true. Otherwise returns false and does not consume |source|.
+
+// Parses |source| for the next ElementMatch.
+bool ParseElementMatch(BufferSource* source, ElementMatch* element_match);
+
+// Parses |source| for the next embedded BufferSource.
+bool ParseBuffer(BufferSource* source, BufferSource* buffer);
+
+// Parses |source| for the next VarUInt.
+template <class T>
+bool ParseVarUInt(BufferSource* source, T* value) {
+  auto bytes_read = DecodeVarUInt(source->begin(), source->end(), value);
+  if (!bytes_read) {
+    LOG(ERROR) << "Impossible to read VarUInt from source.";
+    LOG(ERROR) << base::debug::StackTrace().ToString();
+    return false;
+  }
+  // Advance |source| beyond the VarUInt value.
+  source->Skip(bytes_read);
+  return true;
+}
+
+// Parses |source| for the next VarInt.
+template <class T>
+bool ParseVarInt(BufferSource* source, T* value) {
+  auto bytes_read = DecodeVarInt(source->begin(), source->end(), value);
+  if (!bytes_read) {
+    LOG(ERROR) << "Impossible to read VarInt from source.";
+    LOG(ERROR) << base::debug::StackTrace().ToString();
+    return false;
+  }
+  // Advance |source| beyond the VarInt value.
+  source->Skip(bytes_read);
+  return true;
+}
+
+}  // namespace patch
+
+// The *Source classes below are light-weight (i.e., allows copying) visitors to
+// read patch data. Each of them has an associated "main type", and performs the
+// following:
+// - Consumes portions of a BufferSource (required to remain valid for the
+//   lifetime of the object).
+// - Decodes consumed data, which represent a list of items with "main type".
+// - Dispenses "main type" elements (hence "Source" in the name).
+//
+// Common "core functions" implemented by *Source classes are:
+// - bool Initialize(BufferSource* source): Consumes data from BufferSource and
+//   initializes internal states. Returns true if successful, and false
+//   otherwise (|source| may be partially consumed).
+// - std::optional<MAIN_TYPE> GetNext(OPT_PARAMS): Decodes consumed data and
+//   returns the next item as std::optional (returns std::nullopt on failure).
+// - bool Done() const: Returns true if no more items remain; otherwise false.
+//
+// Usage of *Source instances don't mix, and GetNext() have dissimilar
+// interfaces. Therefore we do not use inheritance to relate *Source  classes,
+// and simply implement "core functions" with matching names.
+
+// Source for Equivalences.
+class EquivalenceSource {
+ public:
+  EquivalenceSource();
+  EquivalenceSource(const EquivalenceSource&);
+  ~EquivalenceSource();
+
+  // Core functions.
+  bool Initialize(BufferSource* source);
+  std::optional<Equivalence> GetNext();
+  bool Done() const {
+    return src_skip_.empty() && dst_skip_.empty() && copy_count_.empty();
+  }
+
+  // Accessors for unittest.
+  BufferSource src_skip() const { return src_skip_; }
+  BufferSource dst_skip() const { return dst_skip_; }
+  BufferSource copy_count() const { return copy_count_; }
+
+ private:
+  BufferSource src_skip_;
+  BufferSource dst_skip_;
+  BufferSource copy_count_;
+
+  base::CheckedNumeric<offset_t> previous_src_offset_ = 0;
+  base::CheckedNumeric<offset_t> previous_dst_offset_ = 0;
+};
+
+// Source for extra data.
+class ExtraDataSource {
+ public:
+  ExtraDataSource();
+  ExtraDataSource(const ExtraDataSource&);
+  ~ExtraDataSource();
+
+  // Core functions.
+  bool Initialize(BufferSource* source);
+  // |size| is the size in bytes of the buffer requested.
+  std::optional<ConstBufferView> GetNext(offset_t size);
+  bool Done() const { return extra_data_.empty(); }
+
+  // Accessors for unittest.
+  BufferSource extra_data() const { return extra_data_; }
+
+ private:
+  BufferSource extra_data_;
+};
+
+// Source for raw delta.
+class RawDeltaSource {
+ public:
+  RawDeltaSource();
+  RawDeltaSource(const RawDeltaSource&);
+  ~RawDeltaSource();
+
+  // Core functions.
+  bool Initialize(BufferSource* source);
+  std::optional<RawDeltaUnit> GetNext();
+  bool Done() const {
+    return raw_delta_skip_.empty() && raw_delta_diff_.empty();
+  }
+
+  // Accessors for unittest.
+  BufferSource raw_delta_skip() const { return raw_delta_skip_; }
+  BufferSource raw_delta_diff() const { return raw_delta_diff_; }
+
+ private:
+  BufferSource raw_delta_skip_;
+  BufferSource raw_delta_diff_;
+
+  base::CheckedNumeric<offset_t> copy_offset_compensation_ = 0;
+};
+
+// Source for reference delta.
+class ReferenceDeltaSource {
+ public:
+  ReferenceDeltaSource();
+  ReferenceDeltaSource(const ReferenceDeltaSource&);
+  ~ReferenceDeltaSource();
+
+  // Core functions.
+  bool Initialize(BufferSource* source);
+  std::optional<int32_t> GetNext();
+  bool Done() const { return source_.empty(); }
+
+  // Accessors for unittest.
+  BufferSource reference_delta() const { return source_; }
+
+ private:
+  BufferSource source_;
+};
+
+// Source for additional targets.
+class TargetSource {
+ public:
+  TargetSource();
+  TargetSource(const TargetSource&);
+  ~TargetSource();
+
+  // Core functions.
+  bool Initialize(BufferSource* source);
+  std::optional<offset_t> GetNext();
+  bool Done() const { return extra_targets_.empty(); }
+
+  // Accessors for unittest.
+  BufferSource extra_targets() const { return extra_targets_; }
+
+ private:
+  BufferSource extra_targets_;
+
+  base::CheckedNumeric<offset_t> target_compensation_ = 0;
+};
+
+// Following are utility classes providing a structured view on data forming a
+// patch.
+
+// Utility to read a patch element. A patch element contains all the information
+// necessary to patch a single element. This class provide access
+// to the multiple streams of data forming the patch element.
+class PatchElementReader {
+ public:
+  PatchElementReader();
+  PatchElementReader(PatchElementReader&&);
+  ~PatchElementReader();
+
+  // If data read from |source| is well-formed, initialize cached sources to
+  // read from it, and returns true. Otherwise returns false.
+  bool Initialize(BufferSource* source);
+
+  const ElementMatch& element_match() const { return element_match_; }
+  const Element& old_element() const { return element_match_.old_element; }
+  const Element& new_element() const { return element_match_.new_element; }
+
+  // The Get*() functions below return copies of cached sources. Callers may
+  // assume the following:
+  // - Equivalences satisfy basic boundary constraints
+  //   - "Old" / "new" blocks lie entirely in "old" / "new" images.
+  //   - "New" blocks are sorted.
+  EquivalenceSource GetEquivalenceSource() const { return equivalences_; }
+  ExtraDataSource GetExtraDataSource() const { return extra_data_; }
+  RawDeltaSource GetRawDeltaSource() const { return raw_delta_; }
+  ReferenceDeltaSource GetReferenceDeltaSource() const {
+    return reference_delta_;
+  }
+  TargetSource GetExtraTargetSource(PoolTag tag) const {
+    auto pos = extra_targets_.find(tag);
+    return pos != extra_targets_.end() ? pos->second : TargetSource();
+  }
+
+ private:
+  // Checks that "old" and "new" blocks of each item in |equivalences_| satisfy
+  // basic order and image bound constraints (using |element_match_| data). Also
+  // validates that the amount of extra data is correct. Returns true if
+  // successful.
+  bool ValidateEquivalencesAndExtraData();
+
+  ElementMatch element_match_;
+
+  // Cached sources.
+  EquivalenceSource equivalences_;
+  ExtraDataSource extra_data_;
+  RawDeltaSource raw_delta_;
+  ReferenceDeltaSource reference_delta_;
+  std::map<PoolTag, TargetSource> extra_targets_;
+};
+
+// Utility to read a Zucchini ensemble patch. An ensemble patch is the
+// concatenation of a patch header with a vector of patch elements.
+class EnsemblePatchReader {
+ public:
+  // If data read from |buffer| is well-formed, initializes and returns
+  // an instance of EnsemblePatchReader. Otherwise returns std::nullopt.
+  static std::optional<EnsemblePatchReader> Create(ConstBufferView buffer);
+
+  EnsemblePatchReader();
+  EnsemblePatchReader(EnsemblePatchReader&&);
+  ~EnsemblePatchReader();
+
+  // If data read from |source| is well-formed, initialize internal state to
+  // read from it, and returns true. Otherwise returns false.
+  bool Initialize(BufferSource* source);
+
+  // Check old / new image file validity, comparing against expected size and
+  // CRC32. Return true if file matches expectations, false otherwise.
+  bool CheckOldFile(ConstBufferView old_image) const;
+  bool CheckNewFile(ConstBufferView new_image) const;
+
+  const PatchHeader& header() const { return header_; }
+  const std::vector<PatchElementReader>& elements() const { return elements_; }
+
+ private:
+  PatchHeader header_;
+  std::vector<PatchElementReader> elements_;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_PATCH_READER_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_utils.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_utils.h
new file mode 100644
index 0000000..82b2b48
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_utils.h
@@ -0,0 +1,139 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_PATCH_UTILS_H_
+#define COMPONENTS_ZUCCHINI_PATCH_UTILS_H_
+
+#include <stdint.h>
+
+#include <iterator>
+#include <type_traits>
+
+#include "components/zucchini/image_utils.h"
+#include "components/zucchini/version_info.h"
+
+namespace zucchini {
+
+// A Zucchini 'ensemble' patch is the concatenation of a patch header with a
+// list of patch 'elements', each containing data for patching individual
+// elements.
+
+// Supported by MSVC, g++, and clang++. Ensures no gaps in packing.
+#pragma pack(push, 1)
+
+// Header for a Zucchini patch, found at the beginning of an ensemble patch.
+struct PatchHeader {
+  // Magic signature at the beginning of a Zucchini patch file.
+  enum : uint32_t { kMagic = 'Z' | ('u' << 8) | ('c' << 16) | ('c' << 24) };
+
+  uint32_t magic = 0;
+  uint16_t major_version = kInvalidVersion;
+  uint16_t minor_version = kInvalidVersion;
+  uint32_t old_size = 0;
+  uint32_t old_crc = 0;
+  uint32_t new_size = 0;
+  uint32_t new_crc = 0;
+};
+
+// Sanity check.
+static_assert(sizeof(PatchHeader) == 24, "PatchHeader must be 24 bytes");
+
+// Header for a patch element, found at the beginning of every patch element.
+struct PatchElementHeader {
+  uint32_t old_offset;
+  uint32_t old_length;
+  uint32_t new_offset;
+  uint32_t new_length;
+  uint32_t exe_type;  // ExecutableType.
+  uint16_t version = kInvalidVersion;
+};
+
+// Sanity check.
+static_assert(sizeof(PatchElementHeader) == 22,
+              "PatchElementHeader must be 22 bytes");
+
+#pragma pack(pop)
+
+// Descibes a raw FIX operation.
+struct RawDeltaUnit {
+  offset_t copy_offset;  // Offset in copy regions.
+  int8_t diff;           // Bytewise difference.
+};
+
+// A Zucchini patch contains data streams encoded using varint format to reduce
+// uncompressed size.
+
+// Writes |value| as a varint in |dst| and returns an iterator pointing beyond
+// the written region. |dst| is assumed to hold enough space. Typically, this
+// will write to a vector using back insertion, e.g.:
+//   EncodeVarUInt(value, std::back_inserter(vector));
+template <class T, class It>
+It EncodeVarUInt(T value, It dst) {
+  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned");
+
+  while (value >= 0x80) {
+    *dst++ = static_cast<uint8_t>(value) | 0x80;
+    value >>= 7;
+  }
+  *dst++ = static_cast<uint8_t>(value);
+  return dst;
+}
+
+// Same as EncodeVarUInt(), but for signed values.
+template <class T, class It>
+It EncodeVarInt(T value, It dst) {
+  static_assert(std::is_signed<T>::value, "Value type must be signed");
+
+  using unsigned_value_type = typename std::make_unsigned<T>::type;
+  if (value < 0)
+    return EncodeVarUInt((unsigned_value_type(~value) << 1) | 1, dst);
+  else
+    return EncodeVarUInt(unsigned_value_type(value) << 1, dst);
+}
+
+// Tries to read a varint unsigned integer from |[first, last)|. If
+// succesful, writes result into |value| and returns the number of bytes
+// read from |[first, last)|. Otherwise returns 0.
+template <class T, class It>
+typename std::iterator_traits<It>::difference_type DecodeVarUInt(It first,
+                                                                 It last,
+                                                                 T* value) {
+  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned");
+
+  uint8_t sh = 0;
+  T val = 0;
+  for (auto it = first; it != last;) {
+    val |= T(*it & 0x7F) << sh;
+    if (*(it++) < 0x80) {
+      *value = val;
+      return it - first;
+    }
+    sh += 7;
+    if (sh >= sizeof(T) * 8)  // Overflow!
+      return 0;
+  }
+  return 0;
+}
+
+// Same as DecodeVarUInt(), but for signed values.
+template <class T, class It>
+typename std::iterator_traits<It>::difference_type DecodeVarInt(It first,
+                                                                It last,
+                                                                T* value) {
+  static_assert(std::is_signed<T>::value, "Value type must be signed");
+
+  typename std::make_unsigned<T>::type tmp = 0;
+  auto res = DecodeVarUInt(first, last, &tmp);
+  if (res) {
+    if (tmp & 1)
+      *value = ~static_cast<T>(tmp >> 1);
+    else
+      *value = static_cast<T>(tmp >> 1);
+  }
+  return res;
+}
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_PATCH_UTILS_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_writer.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_writer.h
new file mode 100644
index 0000000..9bcaad8
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_writer.h
@@ -0,0 +1,272 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_PATCH_WRITER_H_
+#define COMPONENTS_ZUCCHINI_PATCH_WRITER_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <map>
+#include <optional>
+#include <utility>
+#include <vector>
+
+#include "base/check.h"
+#include "components/zucchini/buffer_sink.h"
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/image_utils.h"
+#include "components/zucchini/patch_utils.h"
+
+namespace zucchini {
+
+namespace patch {
+
+// If sufficient space is available, serializes |element_match| into |sink| and
+// returns true. Otherwise returns false, and |sink| will be in an undefined
+// state.
+bool SerializeElementMatch(const ElementMatch& element_match, BufferSink* sink);
+
+// Returns the size in bytes required to serialize |element_match|.
+size_t SerializedElementMatchSize(const ElementMatch& element_match);
+
+// If sufficient space is available, serializes |buffer| into |sink| and returns
+// true. Otherwise returns false, and |sink| will be in an undefined state.
+bool SerializeBuffer(const std::vector<uint8_t>& buffer, BufferSink* sink);
+
+// Returns the size in bytes required to serialize |buffer|.
+size_t SerializedBufferSize(const std::vector<uint8_t>& buffer);
+
+}  // namespace patch
+
+// Each of *Sink classes below has an associated "main type", and performs the
+// following:
+// - Receives multiple "main type" elements (hence "Sink" in the name).
+// - Encodes list of received data, and writes them to internal storage (e.g.,
+//   applying delta encoding).
+// - Writes encoded data to BufferSink.
+//
+// Common "core functions" implemented for *Sink classes are:
+// - void PutNext(const MAIN_TYPE& inst): Encodes and writes an instance of
+//   MAIN_TYPE to internal storage. Assumptions may be applied to successive
+//   |inst| provided.
+// - size_t SerializedSize() const: Returns the serialized size in bytes of
+//   internal storage.
+// - bool SerializeInto(BufferSink* sink) const: If |sink| has enough space,
+//   serializes internal storage into |sink|, and returns true. Otherwise
+//   returns false.
+//
+// Usage of *Sink instances don't mix, and PuttNext() have dissimilar
+// interfaces. Therefore we do not use inheritance to relate *Sink classes,
+// simply implement "core functions" with matching names.
+
+// Sink for equivalences.
+class EquivalenceSink {
+ public:
+  EquivalenceSink();
+  EquivalenceSink(const std::vector<uint8_t>& src_skip,
+                  const std::vector<uint8_t>& dst_skip,
+                  const std::vector<uint8_t>& copy_count);
+
+  EquivalenceSink(EquivalenceSink&&);
+  ~EquivalenceSink();
+
+  // Core functions.
+  // Equivalences must be given by increasing |Equivalence::dst_offset|.
+  void PutNext(const Equivalence& equivalence);
+  size_t SerializedSize() const;
+  bool SerializeInto(BufferSink* sink) const;
+
+ private:
+  // Offset in source, delta-encoded starting from end of last equivalence, and
+  // stored as signed varint.
+  std::vector<uint8_t> src_skip_;
+  // Offset in destination, delta-encoded starting from end of last equivalence,
+  // and stored as unsigned varint.
+  std::vector<uint8_t> dst_skip_;
+  // Length of equivalence stored as unsigned varint.
+  // TODO(etiennep): Investigate on bias.
+  std::vector<uint8_t> copy_count_;
+
+  offset_t src_offset_ = 0;  // Last offset in source.
+  offset_t dst_offset_ = 0;  // Last offset in destination.
+};
+
+// Sink for extra data.
+class ExtraDataSink {
+ public:
+  ExtraDataSink();
+  explicit ExtraDataSink(const std::vector<uint8_t>& extra_data);
+  ExtraDataSink(ExtraDataSink&&);
+  ~ExtraDataSink();
+
+  // Core functions.
+  void PutNext(ConstBufferView region);
+  size_t SerializedSize() const;
+  bool SerializeInto(BufferSink* sink) const;
+
+ private:
+  std::vector<uint8_t> extra_data_;
+};
+
+// Sink for raw delta.
+class RawDeltaSink {
+ public:
+  RawDeltaSink();
+  RawDeltaSink(const std::vector<uint8_t>& raw_delta_skip,
+               const std::vector<uint8_t>& raw_delta_diff);
+  RawDeltaSink(RawDeltaSink&&);
+  ~RawDeltaSink();
+
+  // Core functions.
+  // Deltas must be given by increasing |RawDeltaUnit::copy_offset|.
+  void PutNext(const RawDeltaUnit& delta);
+  size_t SerializedSize() const;
+  bool SerializeInto(BufferSink* sink) const;
+
+ private:
+  std::vector<uint8_t> raw_delta_skip_;  // Copy offset stating from last delta.
+  std::vector<uint8_t> raw_delta_diff_;  // Bytewise difference.
+
+  // We keep track of the compensation needed for next copy offset, taking into
+  // accound delta encoding and bias of -1. Stored delta are biased by -1, so a
+  // sequence of single byte deltas is represented as a string of 0's.
+  offset_t copy_offset_compensation_ = 0;
+};
+
+// Sink for reference delta.
+class ReferenceDeltaSink {
+ public:
+  ReferenceDeltaSink();
+  explicit ReferenceDeltaSink(const std::vector<uint8_t>& reference_delta);
+  ReferenceDeltaSink(ReferenceDeltaSink&&);
+  ~ReferenceDeltaSink();
+
+  // Core functions.
+  void PutNext(int32_t diff);
+  size_t SerializedSize() const;
+  bool SerializeInto(BufferSink* sink) const;
+
+ private:
+  std::vector<uint8_t> reference_delta_;
+};
+
+// Sink for additional targets.
+class TargetSink {
+ public:
+  TargetSink();
+  explicit TargetSink(const std::vector<uint8_t>& extra_targets);
+  TargetSink(TargetSink&&);
+  ~TargetSink();
+
+  // Core functions.
+  // Targets must be given by increasing order.
+  void PutNext(uint32_t target);
+  size_t SerializedSize() const;
+  bool SerializeInto(BufferSink* sink) const;
+
+ private:
+  // Targets are delta-encoded and biaised by 1, stored as unsigned varint.
+  std::vector<uint8_t> extra_targets_;
+
+  // We keep track of the compensation needed for next target, taking into
+  // accound delta encoding and bias of -1.
+  offset_t target_compensation_ = 0;
+};
+
+// Following are utility classes to write structured data forming a patch.
+
+// Utility to write a patch element. A patch element contains all the
+// information necessary to patch a single element. This class
+// provides an interface to individually set different building blocks of data
+// in the patch element.
+class PatchElementWriter {
+ public:
+  PatchElementWriter();
+  explicit PatchElementWriter(ElementMatch element_match);
+  PatchElementWriter(PatchElementWriter&&);
+  ~PatchElementWriter();
+
+  const ElementMatch& element_match() const { return element_match_; }
+  const Element& old_element() const { return element_match_.old_element; }
+  const Element& new_element() const { return element_match_.new_element; }
+
+  // Following methods set individual blocks for this element. Previous
+  // corresponding block is replaced. All streams must be set before call to
+  // SerializedSize() of SerializeInto().
+
+  void SetEquivalenceSink(EquivalenceSink&& equivalences) {
+    equivalences_.emplace(std::move(equivalences));
+  }
+  void SetExtraDataSink(ExtraDataSink&& extra_data) {
+    extra_data_.emplace(std::move(extra_data));
+  }
+  void SetRawDeltaSink(RawDeltaSink&& raw_delta) {
+    raw_delta_.emplace(std::move(raw_delta));
+  }
+  void SetReferenceDeltaSink(ReferenceDeltaSink reference_delta) {
+    reference_delta_.emplace(std::move(reference_delta));
+  }
+  // Set additional targets for pool identified with |pool_tag|.
+  void SetTargetSink(PoolTag pool_tag, TargetSink&& extra_targets) {
+    DCHECK(pool_tag != kNoPoolTag);
+    extra_targets_.emplace(pool_tag, std::move(extra_targets));
+  }
+
+  // Returns the serialized size in bytes of the data this object is holding.
+  size_t SerializedSize() const;
+
+  // If sufficient space is available, serializes data into |sink|, which is at
+  // least SerializedSize() bytes, and returns true. Otherwise returns false.
+  bool SerializeInto(BufferSink* sink) const;
+
+ private:
+  ElementMatch element_match_;
+  std::optional<EquivalenceSink> equivalences_;
+  std::optional<ExtraDataSink> extra_data_;
+  std::optional<RawDeltaSink> raw_delta_;
+  std::optional<ReferenceDeltaSink> reference_delta_;
+  std::map<PoolTag, TargetSink> extra_targets_;
+};
+
+// Utility to write a Zucchini ensemble patch. An ensemble patch is the
+// concatenation of a patch header with a vector of patch elements.
+class EnsemblePatchWriter {
+ public:
+  explicit EnsemblePatchWriter(const PatchHeader& header);
+  EnsemblePatchWriter(ConstBufferView old_image, ConstBufferView new_image);
+  EnsemblePatchWriter(const EnsemblePatchWriter&) = delete;
+  const EnsemblePatchWriter& operator=(const EnsemblePatchWriter&) = delete;
+  ~EnsemblePatchWriter();
+
+  // Reserves space for |count| patch elements.
+  void ReserveElements(size_t count) { elements_.reserve(count); }
+
+  // Adds an patch element into the patch. Patch elements must be ordered by
+  // their location in the new image file.
+  void AddElement(PatchElementWriter&& patch_element);
+
+  // Returns the serialized size in bytes of the data this object is holding.
+  size_t SerializedSize() const;
+
+  // If sufficient space is available, serializes data into |sink|, which is at
+  // least SerializedSize() bytes, and returns true. Otherwise returns false.
+  bool SerializeInto(BufferSink* sink) const;
+
+  // If sufficient space is available, serializes data into |buffer|, which is
+  // at least SerializedSize() bytes, and returns true. Otherwise returns false.
+  bool SerializeInto(MutableBufferView buffer) const {
+    BufferSink sink(buffer);
+    return SerializeInto(&sink);
+  }
+
+ private:
+  PatchHeader header_;
+  std::vector<PatchElementWriter> elements_;
+  offset_t current_dst_offset_ = 0;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_PATCH_WRITER_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reference_set.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reference_set.h
new file mode 100644
index 0000000..07940f0
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reference_set.h
@@ -0,0 +1,64 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_REFERENCE_SET_H_
+#define COMPONENTS_ZUCCHINI_REFERENCE_SET_H_
+
+#include <stddef.h>
+
+#include <vector>
+
+#include "components/zucchini/image_utils.h"
+
+namespace zucchini {
+
+class TargetPool;
+
+// Container of distinct references of one type, along with traits, only used
+// during patch generation.
+class ReferenceSet {
+ public:
+  using const_iterator = std::vector<Reference>::const_iterator;
+
+  // |traits| specifies the reference represented. |target_pool| specifies
+  // common targets shared by all reference represented, and mediates target
+  // translation between offsets and indexes.
+  ReferenceSet(const ReferenceTypeTraits& traits,
+               const TargetPool& target_pool);
+  ReferenceSet(const ReferenceSet&) = delete;
+  ReferenceSet(ReferenceSet&&);
+  ~ReferenceSet();
+
+  // Either one of the initializers below should be called exactly once. These
+  // insert all references from |ref_reader/refs| into this class. The targets
+  // of these references must be in |target_pool_|.
+  void InitReferences(ReferenceReader&& ref_reader);
+  void InitReferences(const std::vector<Reference>& refs);
+
+  const std::vector<Reference>& references() const { return references_; }
+  const ReferenceTypeTraits& traits() const { return traits_; }
+  const TargetPool& target_pool() const { return target_pool_; }
+  TypeTag type_tag() const { return traits_.type_tag; }
+  PoolTag pool_tag() const { return traits_.pool_tag; }
+  offset_t width() const { return traits_.width; }
+
+  // Looks up the Reference by an |offset| that it spans. |offset| is assumed to
+  // be valid, i.e., |offset| must be spanned by some Reference in
+  // |references_|.
+  Reference at(offset_t offset) const;
+
+  size_t size() const { return references_.size(); }
+  const_iterator begin() const { return references_.begin(); }
+  const_iterator end() const { return references_.end(); }
+
+ private:
+  ReferenceTypeTraits traits_;
+  const TargetPool& target_pool_;
+  // List of distinct Reference instances sorted by location.
+  std::vector<Reference> references_;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_REFERENCE_SET_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_finder.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_finder.h
new file mode 100644
index 0000000..3ebeb95
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_finder.h
@@ -0,0 +1,284 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_REL32_FINDER_H_
+#define COMPONENTS_ZUCCHINI_REL32_FINDER_H_
+
+#include <stddef.h>
+
+#include <vector>
+
+#include "components/zucchini/address_translator.h"
+#include "components/zucchini/arm_utils.h"
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/image_utils.h"
+
+namespace zucchini {
+
+// See README.md for definitions on abs32 and rel32 references. The following
+// are assumed:
+// * Abs32 reference bodies have fixed widths.
+// * Rel32 locations can be identified by heuristically disassembling machine
+//   code, and errors are tolerated.
+// * The collection all abs32 and rel32 reference bodies do not overlap.
+
+// A class to visit non-empty contiguous gaps in |region| that lie outside of
+// |abs32_locations| elements, each with a body that spans |abs32_width_| bytes.
+// For example, given:
+//   region = [base_ + 4, base_ + 26),
+//   abs32_locations = {2, 6, 15, 20, 27},
+//   abs32_width_ = 4,
+// the following is obtained:
+//             111111111122222222223   -> offsets
+//   0123456789012345678901234567890
+//   ....**********************.....   -> region = *
+//     ^   ^        ^    ^      ^      -> abs32 locations
+//     aaaaaaaa     aaaa aaaa   aaaa   -> abs32 bodies
+//   ....------*****----*----**.....   -> regions excluding abs32 -> 3 gaps
+// The resulting gaps (non-empty, so [6, 6) is excluded) are:
+//   [10, 15), [19, 20), [24, 26).
+// These gaps can then be passed to Rel32Finder (below) to find rel32 references
+// with bodies that are guaranteed to not overlap with any abs32 bodies.
+class Abs32GapFinder {
+ public:
+  // |abs32_locations| is a sorted list of non-overlapping abs32 locations in
+  // |image|, each spanning |abs32_width| bytes. Gaps are searched in |region|,
+  // which must be part of |image|.
+  Abs32GapFinder(ConstBufferView image,
+                 ConstBufferView region,
+                 const std::vector<offset_t>& abs32_locations,
+                 size_t abs32_width);
+  Abs32GapFinder(const Abs32GapFinder&) = delete;
+  const Abs32GapFinder& operator=(const Abs32GapFinder&) = delete;
+  ~Abs32GapFinder();
+
+  // Searches for the next available gap, and returns successfulness.
+  bool FindNext();
+
+  // Returns the cached result from the last successful FindNext().
+  ConstBufferView GetGap() const { return gap_; }
+
+ private:
+  const ConstBufferView::const_iterator base_;
+  const ConstBufferView::const_iterator region_end_;
+  ConstBufferView::const_iterator cur_lo_;
+  const std::vector<offset_t>::const_iterator abs32_end_;
+  std::vector<offset_t>::const_iterator abs32_cur_;
+  const size_t abs32_width_;
+  ConstBufferView gap_;
+};
+
+// A class to scan regions within an image to find successive rel32 references.
+// Architecture-specific parsing and result extraction are delegated to
+// inherited classes (say, Rel32Finder_Impl). Sample extraction loop, combined
+// with Abs32GapFinder usage:
+//
+//   Abs32GapFinder gap_finder(...);
+//   Rel32Finder_Impl finder(...);
+//   while (gap_finder.FindNext()) {
+//     rel_finder.SetRegion(gap_finder.GetGap());
+//     while (rel_finder.FindNext()) {
+//       auto rel32 = rel_finder.GetRel32();  // In Rel32Finder_Impl.
+//       if (architecture_specific_validation(rel32)) {
+//         rel_finder.Accept();
+//         // Store rel32.
+//       }
+//     }
+//   }
+class Rel32Finder {
+ public:
+  Rel32Finder(ConstBufferView image, const AddressTranslator& translator);
+  Rel32Finder(const Rel32Finder&) = delete;
+  const Rel32Finder& operator=(const Rel32Finder&) = delete;
+  virtual ~Rel32Finder();
+
+  // Assigns the scan |region| for rel32 references to enable FindNext() use.
+  void SetRegion(ConstBufferView region);
+
+  // Scans for the next rel32 reference, and returns whether any is found, so a
+  // "while" loop can be used for iterative rel32 extraction. The results are
+  // cached in Rel32Finder_Impl and obtained by Rel32Finder_Impl::GetRel32().
+  bool FindNext();
+
+  // When a rel32 reference is found, the caller needs to decide whether to keep
+  // the result (perhaps following more validation). If it decides to keep the
+  // result, then it must call Accept(), so the next call to FindNext() can skip
+  // the accepted rel32 reference.
+  void Accept();
+
+  // Accessors for unittest.
+  ConstBufferView::const_iterator accept_it() const { return accept_it_; }
+  ConstBufferView region() const { return region_; }
+
+ protected:
+  // Alternatives for where to continue the next scan when a rel32 reference is
+  // found. nulls indicate that no rel32 references remain.
+  struct NextIterators {
+    // The next iterator if the caller does not call Accept().
+    ConstBufferView::const_iterator reject;
+
+    // The next iterator if the caller calls Accept().
+    ConstBufferView::const_iterator accept;
+  };
+
+  // Detects and extracts architecture-specific rel32 reference. For each one
+  // found, the implementation should cache the necessary data to be retrieved
+  // via accessors. Returns a NextIterators that stores alternatives for where
+  // to continue the scan. If no rel32 reference is found then the returned
+  // NextIterators are nulls.
+  virtual NextIterators Scan(ConstBufferView region) = 0;
+
+  const ConstBufferView image_;
+  AddressTranslator::OffsetToRvaCache offset_to_rva_;
+
+ private:
+  ConstBufferView region_;
+  ConstBufferView::const_iterator accept_it_ = nullptr;
+};
+
+// Parsing for X86 or X64: we perform naive scan for opcodes that have rel32 as
+// an argument, and disregard instruction alignment.
+class Rel32FinderIntel : public Rel32Finder {
+ public:
+  Rel32FinderIntel(const Rel32FinderIntel&) = delete;
+  const Rel32FinderIntel& operator=(const Rel32FinderIntel&) = delete;
+
+  // Struct to store GetRel32() results.
+  struct Result {
+    offset_t location;
+    rva_t target_rva;
+
+    // Some references must have their target in the same section as location,
+    // which we use this to heuristically reject rel32 reference candidates.
+    // When true, this constraint is relaxed.
+    bool can_point_outside_section;
+  };
+
+  using Rel32Finder::Rel32Finder;
+
+  // Returns the cached result from the last successful FindNext().
+  const Result& GetRel32() { return rel32_; }
+
+ protected:
+  // Helper for Scan() that also assigns |rel32_|.
+  Rel32Finder::NextIterators SetResult(ConstBufferView::const_iterator cursor,
+                                       uint32_t code_size,
+                                       bool can_point_outside_section);
+
+  // Cached results.
+  Result rel32_;
+
+  // Rel32Finder:
+  NextIterators Scan(ConstBufferView region) override = 0;
+};
+
+// X86 instructions.
+class Rel32FinderX86 : public Rel32FinderIntel {
+ public:
+  using Rel32FinderIntel::Rel32FinderIntel;
+
+  Rel32FinderX86(const Rel32FinderX86&) = delete;
+  const Rel32FinderX86& operator=(const Rel32FinderX86&) = delete;
+
+ private:
+  // Rel32Finder:
+  NextIterators Scan(ConstBufferView region) override;
+};
+
+// X64 instructions.
+class Rel32FinderX64 : public Rel32FinderIntel {
+ public:
+  using Rel32FinderIntel::Rel32FinderIntel;
+
+  Rel32FinderX64(const Rel32FinderX64&) = delete;
+  const Rel32FinderX64& operator=(const Rel32FinderX64&) = delete;
+
+ private:
+  // Rel32Finder:
+  NextIterators Scan(ConstBufferView region) override;
+};
+
+// Base class for ARM (AArch32 and AArch64) instructions.
+template <typename ADDR_TYPE>
+class Rel32FinderArm : public Rel32Finder {
+ public:
+  struct Result {
+    offset_t location;
+    rva_t target_rva;
+    ADDR_TYPE type;
+
+    // For testing.
+    bool operator==(const Result& other) const {
+      return location == other.location && target_rva == other.target_rva &&
+             type == other.type;
+    }
+  };
+
+  Rel32FinderArm(ConstBufferView image, const AddressTranslator& translator);
+  Rel32FinderArm(const Rel32FinderArm&) = delete;
+  const Rel32FinderArm& operator=(const Rel32FinderArm&) = delete;
+  ~Rel32FinderArm() override;
+
+  // Helper for Scan*() that also assigns |rel32_|.
+  NextIterators SetResult(Result&& result,
+                          ConstBufferView::const_iterator cursor,
+                          int instr_size);
+
+  // SetResult() for end of scan.
+  NextIterators SetEmptyResult();
+
+ protected:
+  // Cached results.
+  Result rel32_;
+};
+
+// AArch32 instructions.
+class Rel32FinderAArch32
+    : public Rel32FinderArm<AArch32Rel32Translator::AddrType> {
+ public:
+  Rel32FinderAArch32(ConstBufferView image,
+                     const AddressTranslator& translator,
+                     bool is_thumb2);
+  Rel32FinderAArch32(const Rel32FinderAArch32&) = delete;
+  const Rel32FinderAArch32& operator=(const Rel32FinderAArch32&) = delete;
+  ~Rel32FinderAArch32() override;
+
+  const Result& GetRel32() const { return rel32_; }
+
+ private:
+  // Rel32 extraction, assuming segment is in ARM mode.
+  NextIterators ScanA32(ConstBufferView region);
+
+  // Rel32 extraction, assuming segment is in THUMB2 mode.
+  NextIterators ScanT32(ConstBufferView region);
+
+  // Rel32Finder:
+  NextIterators Scan(ConstBufferView region) override;
+
+  // Indicates whether segment is in THUMB2 or ARM mod. In general this can
+  // change throughout a section. However, currently we assume that this is
+  // constant for an entire section.
+  const bool is_thumb2_;
+};
+
+// AArch64 instructions.
+class Rel32FinderAArch64
+    : public Rel32FinderArm<AArch64Rel32Translator::AddrType> {
+ public:
+  Rel32FinderAArch64(ConstBufferView image,
+                     const AddressTranslator& translator);
+  Rel32FinderAArch64(const Rel32FinderAArch64&) = delete;
+  const Rel32FinderAArch64& operator=(const Rel32FinderAArch64&) = delete;
+  ~Rel32FinderAArch64() override;
+
+  const Result& GetRel32() const { return rel32_; }
+
+ private:
+  // Rel32Finder:
+  NextIterators Scan(ConstBufferView region) override;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_REL32_FINDER_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_utils.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_utils.h
new file mode 100644
index 0000000..30dd4af
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_utils.h
@@ -0,0 +1,184 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_REL32_UTILS_H_
+#define COMPONENTS_ZUCCHINI_REL32_UTILS_H_
+
+#include <algorithm>
+#include <deque>
+#include <memory>
+#include <optional>
+
+#include "base/logging.h"
+#include "components/zucchini/address_translator.h"
+#include "components/zucchini/arm_utils.h"
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/image_utils.h"
+#include "components/zucchini/io_utils.h"
+
+namespace zucchini {
+
+// Reader that emits x86 / x64 References (locations and target) from a list of
+// valid locations, constrained by a portion of an image.
+class Rel32ReaderX86 : public ReferenceReader {
+ public:
+  // |image| is an image containing x86 / x64 code in [|lo|, |hi|).
+  // |locations| is a sorted list of offsets of rel32 reference locations.
+  // |translator| (for |image|) is embedded into |target_rva_to_offset_| and
+  // |location_offset_to_rva_| for address translation, and therefore must
+  // outlive |*this|.
+  Rel32ReaderX86(ConstBufferView image,
+                 offset_t lo,
+                 offset_t hi,
+                 const std::deque<offset_t>* locations,
+                 const AddressTranslator& translator);
+  Rel32ReaderX86(const Rel32ReaderX86&) = delete;
+  const Rel32ReaderX86& operator=(const Rel32ReaderX86&) = delete;
+  ~Rel32ReaderX86() override;
+
+  // Returns the next reference, or std::nullopt if exhausted.
+  std::optional<Reference> GetNext() override;
+
+ private:
+  ConstBufferView image_;
+  AddressTranslator::RvaToOffsetCache target_rva_to_offset_;
+  AddressTranslator::OffsetToRvaCache location_offset_to_rva_;
+  const offset_t hi_;
+  const std::deque<offset_t>::const_iterator last_;
+  std::deque<offset_t>::const_iterator current_;
+};
+
+// Writer for x86 / x64 rel32 References.
+class Rel32WriterX86 : public ReferenceWriter {
+ public:
+  // |image| wraps the raw bytes of a binary in which rel32 references will be
+  // written. |translator| (for |image|) is embedded into
+  // |target_offset_to_rva_| and |location_offset_to_rva_| for address
+  // translation, and therefore must outlive |*this|.
+  Rel32WriterX86(MutableBufferView image, const AddressTranslator& translator);
+  Rel32WriterX86(const Rel32WriterX86&) = delete;
+  const Rel32WriterX86& operator=(const Rel32WriterX86&) = delete;
+  ~Rel32WriterX86() override;
+
+  void PutNext(Reference ref) override;
+
+ private:
+  MutableBufferView image_;
+  AddressTranslator::OffsetToRvaCache target_offset_to_rva_;
+  AddressTranslator::OffsetToRvaCache location_offset_to_rva_;
+};
+
+// Reader that emits x86 / x64 References (locations and target) of a spcific
+// type from a list of valid locations, constrained by a portion of an image.
+template <class ADDR_TRAITS>
+class Rel32ReaderArm : public ReferenceReader {
+ public:
+  using CODE_T = typename ADDR_TRAITS::code_t;
+
+  Rel32ReaderArm(const AddressTranslator& translator,
+                 ConstBufferView view,
+                 const std::deque<offset_t>& rel32_locations,
+                 offset_t lo,
+                 offset_t hi)
+      : view_(view),
+        offset_to_rva_(translator),
+        rva_to_offset_(translator),
+        hi_(hi) {
+    cur_it_ =
+        std::lower_bound(rel32_locations.begin(), rel32_locations.end(), lo);
+    rel32_end_ = rel32_locations.end();
+  }
+
+  Rel32ReaderArm(const Rel32ReaderArm&) = delete;
+  const Rel32ReaderArm& operator=(const Rel32ReaderArm&) = delete;
+
+  std::optional<Reference> GetNext() override {
+    while (cur_it_ < rel32_end_ && *cur_it_ < hi_) {
+      offset_t location = *(cur_it_++);
+      CODE_T code = ADDR_TRAITS::Fetch(view_, location);
+      rva_t instr_rva = offset_to_rva_.Convert(location);
+      rva_t target_rva = kInvalidRva;
+      if (ADDR_TRAITS::Read(instr_rva, code, &target_rva)) {
+        offset_t target = rva_to_offset_.Convert(target_rva);
+        if (target != kInvalidOffset)
+          return Reference{location, target};
+      }
+    }
+    return std::nullopt;
+  }
+
+ private:
+  ConstBufferView view_;
+  AddressTranslator::OffsetToRvaCache offset_to_rva_;
+  AddressTranslator::RvaToOffsetCache rva_to_offset_;
+  std::deque<offset_t>::const_iterator cur_it_;
+  std::deque<offset_t>::const_iterator rel32_end_;
+  offset_t hi_;
+};
+
+// Writer for ARM rel32 References of a specific type.
+template <class ADDR_TRAITS>
+class Rel32WriterArm : public ReferenceWriter {
+ public:
+  using CODE_T = typename ADDR_TRAITS::code_t;
+
+  Rel32WriterArm(const AddressTranslator& translator,
+                 MutableBufferView mutable_view)
+      : mutable_view_(mutable_view), offset_to_rva_(translator) {}
+
+  Rel32WriterArm(const Rel32WriterArm&) = delete;
+  const Rel32WriterArm& operator=(const Rel32WriterArm&) = delete;
+
+  void PutNext(Reference ref) override {
+    CODE_T code = ADDR_TRAITS::Fetch(mutable_view_, ref.location);
+    rva_t instr_rva = offset_to_rva_.Convert(ref.location);
+    rva_t target_rva = offset_to_rva_.Convert(ref.target);
+    if (ADDR_TRAITS::Write(instr_rva, target_rva, &code)) {
+      ADDR_TRAITS::Store(mutable_view_, ref.location, code);
+    } else {
+      LOG(ERROR) << "Write error: " << AsHex<8>(ref.location) << ": "
+                 << AsHex<static_cast<int>(sizeof(CODE_T)) * 2>(code)
+                 << " <= " << AsHex<8>(target_rva) << ".";
+    }
+  }
+
+ private:
+  MutableBufferView mutable_view_;
+  AddressTranslator::OffsetToRvaCache offset_to_rva_;
+};
+
+// Type for specialized versions of ArmCopyDisp().
+// TODO(etiennep/huangs): Fold ReferenceByteMixer into Disassembler and remove
+//     direct function pointer usage.
+using ArmCopyDispFun = bool (*)(ConstBufferView src_view,
+                                offset_t src_idx,
+                                MutableBufferView dst_view,
+                                offset_t dst_idx);
+
+// Copier that makes |*dst_it| similar to |*src_it| (both assumed to point to
+// rel32 instructions of type ADDR_TRAITS) by copying the displacement (i.e.,
+// payload bits) from |src_it| to |dst_it|. If successful, updates |*dst_it|,
+// and returns true. Otherwise returns false. Note that alignment is not an
+// issue since the displacement is not translated to target RVA!
+template <class ADDR_TRAITS>
+bool ArmCopyDisp(ConstBufferView src_view,
+                 offset_t src_idx,
+                 MutableBufferView dst_view,
+                 offset_t dst_idx) {
+  using CODE_T = typename ADDR_TRAITS::code_t;
+  CODE_T src_code = ADDR_TRAITS::Fetch(src_view, src_idx);
+  arm_disp_t disp = 0;
+  if (ADDR_TRAITS::Decode(src_code, &disp)) {
+    CODE_T dst_code = ADDR_TRAITS::Fetch(dst_view, dst_idx);
+    if (ADDR_TRAITS::Encode(disp, &dst_code)) {
+      ADDR_TRAITS::Store(dst_view, dst_idx, dst_code);
+      return true;
+    }
+  }
+  return false;
+}
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_REL32_UTILS_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reloc_elf.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reloc_elf.h
new file mode 100644
index 0000000..f53aff2
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reloc_elf.h
@@ -0,0 +1,102 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_RELOC_ELF_H_
+#define COMPONENTS_ZUCCHINI_RELOC_ELF_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <optional>
+#include <vector>
+
+#include "base/numerics/safe_conversions.h"
+#include "components/zucchini/address_translator.h"
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/image_utils.h"
+#include "components/zucchini/type_elf.h"
+
+namespace zucchini {
+
+// Section dimensions for ELF files, to store relevant dimensions data from
+// Elf32_Shdr and Elf64_Shdr, while reducing code duplication from templates.
+struct SectionDimensionsElf {
+  SectionDimensionsElf() = default;
+
+  template <class Elf_Shdr>
+  explicit SectionDimensionsElf(const Elf_Shdr& section)
+      : region(BufferRegion{base::checked_cast<size_t>(section.sh_offset),
+                            base::checked_cast<size_t>(section.sh_size)}),
+        entry_size(base::checked_cast<offset_t>(section.sh_entsize)) {}
+
+  friend bool operator<(const SectionDimensionsElf& a,
+                        const SectionDimensionsElf& b) {
+    return a.region.offset < b.region.offset;
+  }
+
+  friend bool operator<(offset_t offset, const SectionDimensionsElf& section) {
+    return offset < section.region.offset;
+  }
+
+  BufferRegion region;
+  offset_t entry_size;  // Varies across REL / RELA sections.
+};
+
+// A Generator to visit all reloc structs located in [|lo|, |hi|) (excluding
+// truncated strct at |lo| but inlcuding truncated struct at |hi|), and emit
+// valid References with |rel_type|. This implements a nested loop unrolled into
+// a generator: the outer loop has |cur_section_dimensions_| visiting
+// |reloc_section_dims| (sorted by |region.offset|), and the inner loop has
+// |cursor_| visiting successive reloc structs within |cur_section_dimensions_|.
+class RelocReaderElf : public ReferenceReader {
+ public:
+  RelocReaderElf(
+      ConstBufferView image,
+      Bitness bitness,
+      const std::vector<SectionDimensionsElf>& reloc_section_dimensions,
+      uint32_t rel_type,
+      offset_t lo,
+      offset_t hi,
+      const AddressTranslator& translator);
+  ~RelocReaderElf() override;
+
+  // If |rel| contains |r_offset| for |rel_type_|, return the RVA. Otherwise
+  // return |kInvalidRva|. These also handle Elf*_Rela, by using the fact that
+  // Elf*_Rel is a prefix of Elf*_Rela.
+  rva_t GetRelocationTarget(elf::Elf32_Rel rel) const;
+  rva_t GetRelocationTarget(elf::Elf64_Rel rel) const;
+
+  // ReferenceReader:
+  std::optional<Reference> GetNext() override;
+
+ private:
+  const ConstBufferView image_;
+  const Bitness bitness_;
+  const uint32_t rel_type_;
+  const std::vector<SectionDimensionsElf>& reloc_section_dimensions_;
+  std::vector<SectionDimensionsElf>::const_iterator cur_section_dimensions_;
+  offset_t hi_;
+  offset_t cursor_;
+  AddressTranslator::RvaToOffsetCache target_rva_to_offset_;
+};
+
+class RelocWriterElf : public ReferenceWriter {
+ public:
+  RelocWriterElf(MutableBufferView image,
+                 Bitness bitness,
+                 const AddressTranslator& translator);
+  ~RelocWriterElf() override;
+
+  // ReferenceWriter:
+  void PutNext(Reference ref) override;
+
+ private:
+  MutableBufferView image_;
+  const Bitness bitness_;
+  AddressTranslator::OffsetToRvaCache target_offset_to_rva_;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_RELOC_ELF_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/suffix_array.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/suffix_array.h
new file mode 100644
index 0000000..75b3a38
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/suffix_array.h
@@ -0,0 +1,475 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_SUFFIX_ARRAY_H_
+#define COMPONENTS_ZUCCHINI_SUFFIX_ARRAY_H_
+
+#include <algorithm>
+#include <iterator>
+#include <numeric>
+#include <vector>
+
+#include "base/check.h"
+
+namespace zucchini {
+
+// A functor class that implements the naive suffix sorting algorithm that uses
+// std::sort with lexicographical compare. This is only meant as reference of
+// the interface.
+class NaiveSuffixSort {
+ public:
+  // Type requirements:
+  // |InputRng| is an input random access range.
+  // |KeyType| is an unsigned integer type.
+  // |SAIt| is a random access iterator with mutable references.
+  template <class InputRng, class KeyType, class SAIt>
+  // |str| is the input string on which suffix sort is applied.
+  // Characters found in |str| must be in the range [0, |key_bound|)
+  // |suffix_array| is the beginning of the destination range, which is at least
+  // as large as |str|.
+  void operator()(const InputRng& str,
+                  KeyType key_bound,
+                  SAIt suffix_array) const {
+    using size_type = typename SAIt::value_type;
+
+    size_type n = static_cast<size_type>(std::end(str) - std::begin(str));
+
+    // |suffix_array| is first filled with ordered indices of |str|.
+    // Those indices are then sorted with lexicographical comparisons in |str|.
+    std::iota(suffix_array, suffix_array + n, 0);
+    std::sort(suffix_array, suffix_array + n, [&str](size_type i, size_type j) {
+      return std::lexicographical_compare(std::begin(str) + i, std::end(str),
+                                          std::begin(str) + j, std::end(str));
+    });
+  }
+};
+
+// A functor class that implements suffix array induced sorting (SA-IS)
+// algorithm with linear time and memory complexity,
+// see http://ieeexplore.ieee.org/abstract/document/5582081/
+class InducedSuffixSort {
+ public:
+  // Type requirements:
+  // |InputRng| is an input random access range.
+  // |KeyType| is an unsigned integer type.
+  // |SAIt| is a random access iterator with mutable values.
+  template <class InputRng, class KeyType, class SAIt>
+  // |str| is the input string on which suffix sort is applied.
+  // Characters found in |str| must be in the range [0, |key_bound|)
+  // |suffix_array| is the beginning of the destination range, which is at least
+  // as large as |str|.
+  void operator()(const InputRng& str,
+                  KeyType key_bound,
+                  SAIt suffix_array) const {
+    using value_type = typename InputRng::value_type;
+    using size_type = typename SAIt::value_type;
+
+    static_assert(std::is_unsigned<value_type>::value,
+                  "SA-IS only supports input string with unsigned values");
+    static_assert(std::is_unsigned<KeyType>::value, "KeyType must be unsigned");
+
+    size_type n = static_cast<size_type>(std::end(str) - std::begin(str));
+
+    Implementation<size_type, KeyType>::SuffixSort(std::begin(str), n,
+                                                   key_bound, suffix_array);
+  }
+
+  // Given string S of length n. We assume S is terminated by a unique sentinel
+  // $, which is considered as the smallest character. This sentinel does not
+  // exist in memory and is only treated implicitly, hence |n| does not count
+  // the sentinel in this implementation. We denote suf(S,i) the suffix formed
+  // by S[i..n).
+
+  // A suffix suf(S,i) is said to be S-type or L-type, if suf(S,i) < suf(S,i+1)
+  // or suf(S,i) > suf(S,i+1), respectively.
+  enum SLType : bool { SType, LType };
+
+  // A character S[i] is said to be S-type or L-type if the suffix suf(S,i) is
+  // S-type or L-type, respectively.
+
+  // A character S[i] is called LMS (leftmost S-type), if S[i] is S-type and
+  // S[i-1] is L-type. A suffix suf(S,i) is called LMS, if S[i] is an LMS
+  // character.
+
+  // A substring S[i..j) is an LMS-substring if
+  // (1) S[i] is LMS, S[j] is LMS or the sentinel $, and S[i..j) has no other
+  //     LMS characters, or
+  // (2) S[i..j) is the sentinel $.
+
+  template <class SizeType, class KeyType>
+  struct Implementation {
+    static_assert(std::is_unsigned<SizeType>::value,
+                  "SizeType must be unsigned");
+    static_assert(std::is_unsigned<KeyType>::value, "KeyType must be unsigned");
+    using size_type = SizeType;
+    using key_type = KeyType;
+
+    using iterator = typename std::vector<size_type>::iterator;
+    using const_iterator = typename std::vector<size_type>::const_iterator;
+
+    // Partition every suffix based on SL-type. Returns the number of LMS
+    // suffixes.
+    template <class StrIt>
+    static size_type BuildSLPartition(
+        StrIt str,
+        size_type length,
+        key_type key_bound,
+        std::vector<SLType>::reverse_iterator sl_partition_it) {
+      // We will count LMS suffixes (S to L-type or last S-type).
+      size_type lms_count = 0;
+
+      // |previous_type| is initialized to L-type to avoid counting an extra
+      // LMS suffix at the end
+      SLType previous_type = LType;
+
+      // Initialized to dummy, impossible key.
+      key_type previous_key = key_bound;
+
+      // We're travelling backward to determine the partition,
+      // as if we prepend one character at a time to the string, ex:
+      // b$ is L-type because b > $.
+      // ab$ is S-type because a < b, implying ab$ < b$.
+      // bab$ is L-type because b > a, implying bab$ > ab$.
+      // bbab$ is L-type, because bab$ was also L-type, implying bbab$ > bab$.
+      for (auto str_it = std::reverse_iterator<StrIt>(str + length);
+           str_it != std::reverse_iterator<StrIt>(str);
+           ++str_it, ++sl_partition_it) {
+        key_type current_key = *str_it;
+
+        if (current_key > previous_key || previous_key == key_bound) {
+          // S[i] > S[i + 1] or S[i] is last character.
+          if (previous_type == SType)
+            // suf(S,i) is L-type and suf(S,i + 1) is S-type, therefore,
+            // suf(S,i+1) was a LMS suffix.
+            ++lms_count;
+
+          previous_type = LType;  // For next round.
+        } else if (current_key < previous_key) {
+          // S[i] < S[i + 1]
+          previous_type = SType;  // For next round.
+        }
+        // Else, S[i] == S[i + 1]:
+        // The next character that differs determines the SL-type,
+        // so we reuse the last seen type.
+
+        *sl_partition_it = previous_type;
+        previous_key = current_key;  // For next round.
+      }
+
+      return lms_count;
+    }
+
+    // Find indices of LMS suffixes and write result to |lms_indices|.
+    static void FindLmsSuffixes(const std::vector<SLType>& sl_partition,
+                                iterator lms_indices) {
+      // |previous_type| is initialized to S-type to avoid counting an extra
+      // LMS suffix at the beginning
+      SLType previous_type = SType;
+      for (size_type i = 0; i < sl_partition.size(); ++i) {
+        if (sl_partition[i] == SType && previous_type == LType)
+          *lms_indices++ = i;
+        previous_type = sl_partition[i];
+      }
+    }
+
+    template <class StrIt>
+    static std::vector<size_type> MakeBucketCount(StrIt str,
+                                                  size_type length,
+                                                  key_type key_bound) {
+      // Occurrence of every unique character is counted in |buckets|
+      std::vector<size_type> buckets(static_cast<size_type>(key_bound));
+
+      for (auto it = str; it != str + length; ++it)
+        ++buckets[*it];
+      return buckets;
+    }
+
+    // Apply induced sort from |lms_indices| to |suffix_array| associated with
+    // the string |str|.
+    template <class StrIt, class SAIt>
+    static void InducedSort(StrIt str,
+                            size_type length,
+                            const std::vector<SLType>& sl_partition,
+                            const std::vector<size_type>& lms_indices,
+                            const std::vector<size_type>& buckets,
+                            SAIt suffix_array) {
+      // All indices are first marked as unset with the illegal value |length|.
+      std::fill(suffix_array, suffix_array + length, length);
+
+      // Used to mark bucket boundaries (head or end) as indices in str.
+      DCHECK(!buckets.empty());
+      std::vector<size_type> bucket_bounds(buckets.size());
+
+      // Step 1: Assign indices for LMS suffixes, populating the end of
+      // respective buckets but keeping relative order.
+
+      // Find the end of each bucket and write it to |bucket_bounds|.
+      std::partial_sum(buckets.begin(), buckets.end(), bucket_bounds.begin());
+
+      // Process each |lms_indices| backward, and assign them to the end of
+      // their respective buckets, so relative order is preserved.
+      for (auto it = lms_indices.crbegin(); it != lms_indices.crend(); ++it) {
+        key_type key = str[*it];
+        suffix_array[--bucket_bounds[key]] = *it;
+      }
+
+      // Step 2
+      // Scan forward |suffix_array|; for each modified suf(S,i) for which
+      // suf(S,SA(i) - 1) is L-type, place suf(S,SA(i) - 1) to the current
+      // head of the corresponding bucket and forward the bucket head to the
+      // right.
+
+      // Find the head of each bucket and write it to |bucket_bounds|. Since
+      // only LMS suffixes where inserted in |suffix_array| during Step 1,
+      // |bucket_bounds| does not contains the head of each bucket and needs to
+      // be updated.
+      bucket_bounds[0] = 0;
+      std::partial_sum(buckets.begin(), buckets.end() - 1,
+                       bucket_bounds.begin() + 1);
+
+      // From Step 1, the sentinel $, which we treat implicitly, would have
+      // been placed at the beginning of |suffix_array|, since $ is always
+      // considered as the smallest character. We then have to deal with the
+      // previous (last) suffix.
+      if (sl_partition[length - 1] == LType) {
+        key_type key = str[length - 1];
+        suffix_array[bucket_bounds[key]++] = length - 1;
+      }
+      for (auto it = suffix_array; it != suffix_array + length; ++it) {
+        size_type suffix_index = *it;
+
+        // While the original algorithm marks unset suffixes with -1,
+        // we found that marking them with |length| is also possible and more
+        // convenient because we are working with unsigned integers.
+        if (suffix_index != length && suffix_index > 0 &&
+            sl_partition[--suffix_index] == LType) {
+          key_type key = str[suffix_index];
+          suffix_array[bucket_bounds[key]++] = suffix_index;
+        }
+      }
+
+      // Step 3
+      // Scan backward |suffix_array|; for each modified suf(S, i) for which
+      // suf(S,SA(i) - 1) is S-type, place suf(S,SA(i) - 1) to the current
+      // end of the corresponding bucket and forward the bucket head to the
+      // left.
+
+      // Find the end of each bucket and write it to |bucket_bounds|. Since
+      // only L-type suffixes where inserted in |suffix_array| during Step 2,
+      // |bucket_bounds| does not contain the end of each bucket and needs to
+      // be updated.
+      std::partial_sum(buckets.begin(), buckets.end(), bucket_bounds.begin());
+
+      for (auto it = std::reverse_iterator<SAIt>(suffix_array + length);
+           it != std::reverse_iterator<SAIt>(suffix_array); ++it) {
+        size_type suffix_index = *it;
+        if (suffix_index != length && suffix_index > 0 &&
+            sl_partition[--suffix_index] == SType) {
+          key_type key = str[suffix_index];
+          suffix_array[--bucket_bounds[key]] = suffix_index;
+        }
+      }
+      // Deals with the last suffix, because of the sentinel.
+      if (sl_partition[length - 1] == SType) {
+        key_type key = str[length - 1];
+        suffix_array[--bucket_bounds[key]] = length - 1;
+      }
+    }
+
+    // Given a string S starting at |str| with length |length|, an array
+    // starting at |substring_array| containing lexicographically ordered LMS
+    // terminated substring indices of S and an SL-Type partition |sl_partition|
+    // of S, assigns a unique label to every unique LMS substring. The sorted
+    // labels for all LMS substrings are written to |lms_str|, while the indices
+    // of LMS suffixes are written to |lms_indices|. In addition, returns the
+    // total number of unique labels.
+    template <class StrIt, class SAIt>
+    static size_type LabelLmsSubstrings(StrIt str,
+                                        size_type length,
+                                        const std::vector<SLType>& sl_partition,
+                                        SAIt suffix_array,
+                                        iterator lms_indices,
+                                        iterator lms_str) {
+      // Labelling starts at 0.
+      size_type label = 0;
+
+      // |previous_lms| is initialized to 0 to indicate it is unset.
+      // Note that suf(S,0) is never a LMS suffix. Substrings will be visited in
+      // lexicographical order.
+      size_type previous_lms = 0;
+      for (auto it = suffix_array; it != suffix_array + length; ++it) {
+        if (*it > 0 && sl_partition[*it] == SType &&
+            sl_partition[*it - 1] == LType) {
+          // suf(S, *it) is a LMS suffix.
+
+          size_type current_lms = *it;
+          if (previous_lms != 0) {
+            // There was a previous LMS suffix. Check if the current LMS
+            // substring is equal to the previous one.
+            SLType current_lms_type = SType;
+            SLType previous_lms_type = SType;
+            for (size_type k = 0;; ++k) {
+              // |current_lms_end| and |previous_lms_end| denote whether we have
+              // reached the end of the current and previous LMS substring,
+              // respectively
+              bool current_lms_end = false;
+              bool previous_lms_end = false;
+
+              // Check for both previous and current substring ends.
+              // Note that it is more convenient to check if
+              // suf(S,current_lms + k) is an LMS suffix than to retrieve it
+              // from lms_indices.
+              if (current_lms + k >= length ||
+                  (current_lms_type == LType &&
+                   sl_partition[current_lms + k] == SType)) {
+                current_lms_end = true;
+              }
+              if (previous_lms + k >= length ||
+                  (previous_lms_type == LType &&
+                   sl_partition[previous_lms + k] == SType)) {
+                previous_lms_end = true;
+              }
+
+              if (current_lms_end && previous_lms_end) {
+                break;  // Previous and current substrings are identical.
+              } else if (current_lms_end != previous_lms_end ||
+                         str[current_lms + k] != str[previous_lms + k]) {
+                // Previous and current substrings differ, a new label is used.
+                ++label;
+                break;
+              }
+
+              current_lms_type = sl_partition[current_lms + k];
+              previous_lms_type = sl_partition[previous_lms + k];
+            }
+          }
+          *lms_indices++ = *it;
+          *lms_str++ = label;
+          previous_lms = current_lms;
+        }
+      }
+
+      return label + 1;
+    }
+
+    // Implementation of the SA-IS algorithm. |str| must be a random access
+    // iterator pointing at the beginning of S with length |length|. The result
+    // is writtend in |suffix_array|, a random access iterator.
+    template <class StrIt, class SAIt>
+    static void SuffixSort(StrIt str,
+                           size_type length,
+                           key_type key_bound,
+                           SAIt suffix_array) {
+      if (length == 1)
+        *suffix_array = 0;
+      if (length < 2)
+        return;
+
+      std::vector<SLType> sl_partition(length);
+      size_type lms_count =
+          BuildSLPartition(str, length, key_bound, sl_partition.rbegin());
+      std::vector<size_type> lms_indices(lms_count);
+      FindLmsSuffixes(sl_partition, lms_indices.begin());
+      std::vector<size_type> buckets = MakeBucketCount(str, length, key_bound);
+
+      if (lms_indices.size() > 1) {
+        // Given |lms_indices| in the same order they appear in |str|, induce
+        // LMS substrings relative order and write result to |suffix_array|.
+        InducedSort(str, length, sl_partition, lms_indices, buckets,
+                    suffix_array);
+        std::vector<size_type> lms_str(lms_indices.size());
+
+        // Given LMS substrings in relative order found in |suffix_array|,
+        // map LMS substrings to unique labels to form a new string, |lms_str|.
+        size_type label_count =
+            LabelLmsSubstrings(str, length, sl_partition, suffix_array,
+                               lms_indices.begin(), lms_str.begin());
+
+        if (label_count < lms_str.size()) {
+          // Reorder |lms_str| to have LMS suffixes in the same order they
+          // appear in |str|.
+          for (size_type i = 0; i < lms_indices.size(); ++i)
+            suffix_array[lms_indices[i]] = lms_str[i];
+
+          SLType previous_type = SType;
+          for (size_type i = 0, j = 0; i < sl_partition.size(); ++i) {
+            if (sl_partition[i] == SType && previous_type == LType) {
+              lms_str[j] = suffix_array[i];
+              lms_indices[j++] = i;
+            }
+            previous_type = sl_partition[i];
+          }
+
+          // Recursively apply SuffixSort on |lms_str|, which is formed from
+          // labeled LMS suffixes in the same order they appear in |str|.
+          // Note that |KeyType| will be size_type because |lms_str| contains
+          // indices. |lms_str| is at most half the length of |str|.
+          Implementation<size_type, size_type>::SuffixSort(
+              lms_str.begin(), static_cast<size_type>(lms_str.size()),
+              label_count, suffix_array);
+
+          // Map LMS labels back to indices in |str| and write result to
+          // |lms_indices|. We're using |suffix_array| as a temporary buffer.
+          for (size_type i = 0; i < lms_indices.size(); ++i)
+            suffix_array[i] = lms_indices[suffix_array[i]];
+          std::copy_n(suffix_array, lms_indices.size(), lms_indices.begin());
+
+          // At this point, |lms_indices| contains sorted LMS suffixes of |str|.
+        }
+      }
+      // Given |lms_indices| where LMS suffixes are sorted, induce the full
+      // order of suffixes in |str|.
+      InducedSort(str, length, sl_partition, lms_indices, buckets,
+                  suffix_array);
+    }
+
+    Implementation() = delete;
+    Implementation(const Implementation&) = delete;
+    const Implementation& operator=(const Implementation&) = delete;
+  };
+};
+
+// Generates a sorted suffix array for the input string |str| using the functor
+// |Algorithm| which provides an interface equivalent to NaiveSuffixSort.
+/// Characters found in |str| are assumed to be in range [0, |key_bound|).
+// Returns the suffix array as a vector.
+// |StrRng| is an input random access range.
+// |KeyType| is an unsigned integer type.
+template <class Algorithm, class StrRng, class KeyType>
+std::vector<typename StrRng::size_type> MakeSuffixArray(const StrRng& str,
+                                                        KeyType key_bound) {
+  Algorithm sort;
+  std::vector<typename StrRng::size_type> suffix_array(str.end() - str.begin());
+  sort(str, key_bound, suffix_array.begin());
+  return suffix_array;
+}
+
+// Type requirements:
+// |SARng| is an input random access range.
+// |StrIt1| is a random access iterator.
+// |StrIt2| is a forward iterator.
+template <class SARng, class StrIt1, class StrIt2>
+// Lexicographical lower bound using binary search for
+// [|str2_first|, |str2_last|) in the suffix array |suffix_array| of a string
+// starting at |str1_first|. This does not necessarily return the index of
+// the longest matching substring.
+auto SuffixLowerBound(const SARng& suffix_array,
+                      StrIt1 str1_first,
+                      StrIt2 str2_first,
+                      StrIt2 str2_last) -> decltype(std::begin(suffix_array)) {
+  using size_type = typename SARng::value_type;
+
+  size_t n = std::end(suffix_array) - std::begin(suffix_array);
+  auto it = std::lower_bound(
+      std::begin(suffix_array), std::end(suffix_array), str2_first,
+      [str1_first, str2_last, n](size_type a, StrIt2 b) {
+        return std::lexicographical_compare(str1_first + a, str1_first + n, b,
+                                            str2_last);
+      });
+  return it;
+}
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_SUFFIX_ARRAY_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/target_pool.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/target_pool.h
new file mode 100644
index 0000000..fb462b2
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/target_pool.h
@@ -0,0 +1,81 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_TARGET_POOL_H_
+#define COMPONENTS_ZUCCHINI_TARGET_POOL_H_
+
+#include <stddef.h>
+
+#include <deque>
+#include <vector>
+
+#include "components/zucchini/image_utils.h"
+#include "components/zucchini/patch_reader.h"
+
+namespace zucchini {
+
+class OffsetMapper;
+class TargetSource;
+
+// Ordered container of distinct targets that have the same semantics, along
+// with a list of associated reference types, only used during patch generation.
+class TargetPool {
+ public:
+  using const_iterator = std::deque<offset_t>::const_iterator;
+
+  TargetPool();
+  // Initializes the object with given sorted and unique |targets|.
+  explicit TargetPool(std::deque<offset_t>&& targets);
+  TargetPool(TargetPool&&);
+  TargetPool(const TargetPool&);
+  ~TargetPool();
+
+  // Insert new targets from various sources. These invalidate all previous key
+  // lookups.
+  // - From a list of targets, useful for adding extra targets in Zucchini-gen:
+  void InsertTargets(const std::vector<offset_t>& targets);
+  // - From TargetSource, useful for adding extra targets in Zucchini-apply:
+  void InsertTargets(TargetSource* targets);
+  // - From list of References, useful for listing targets in Zucchini-gen:
+  void InsertTargets(const std::vector<Reference>& references);
+  // - From ReferenceReader, useful for listing targets in Zucchini-apply:
+  void InsertTargets(ReferenceReader&& references);
+
+  // Adds |type| as a reference type associated with the pool of targets.
+  void AddType(TypeTag type) { types_.push_back(type); }
+
+  // Returns a canonical key associated with a valid target at |offset|.
+  key_t KeyForOffset(offset_t offset) const;
+
+  // Returns a canonical key associated with the target nearest to |offset|.
+  key_t KeyForNearestOffset(offset_t offset) const;
+
+  // Returns the target for a |key|, which is assumed to be valid and held by
+  // this class.
+  offset_t OffsetForKey(key_t key) const { return targets_[key]; }
+
+  // Returns whether a particular key is valid.
+  bool KeyIsValid(key_t key) const { return key < targets_.size(); }
+
+  // Uses |offset_mapper| to transform "old" |targets_| to "new" |targets_|,
+  // resulting in sorted and unique targets.
+  void FilterAndProject(const OffsetMapper& offset_mapper);
+
+  // Accessors for testing.
+  const std::deque<offset_t>& targets() const { return targets_; }
+  const std::vector<TypeTag>& types() const { return types_; }
+
+  // Returns the number of targets.
+  size_t size() const { return targets_.size(); }
+  const_iterator begin() const { return targets_.cbegin(); }
+  const_iterator end() const { return targets_.cend(); }
+
+ private:
+  std::vector<TypeTag> types_;     // Enumerates type_tag for this pool.
+  std::deque<offset_t> targets_;   // Targets for pool in ascending order.
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_TARGET_POOL_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/targets_affinity.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/targets_affinity.h
new file mode 100644
index 0000000..163b015
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/targets_affinity.h
@@ -0,0 +1,74 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_TARGETS_AFFINITY_H_
+#define COMPONENTS_ZUCCHINI_TARGETS_AFFINITY_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <deque>
+#include <vector>
+
+#include "components/zucchini/image_utils.h"
+
+namespace zucchini {
+
+class EquivalenceMap;
+
+// Computes and stores affinity between old and new targets for a single target
+// pool. This is only used during patch generation.
+class TargetsAffinity {
+ public:
+  TargetsAffinity();
+  TargetsAffinity(const TargetsAffinity&) = delete;
+  const TargetsAffinity& operator=(const TargetsAffinity&) = delete;
+  ~TargetsAffinity();
+
+  // Infers affinity between |old_targets| and |new_targets| using similarities
+  // described by |equivalence_map|, and updates internal state for retrieval of
+  // affinity scores. Both |old_targets| and |new_targets| are targets in the
+  // same pool and are sorted in ascending order.
+  void InferFromSimilarities(const EquivalenceMap& equivalence_map,
+                             const std::deque<offset_t>& old_targets,
+                             const std::deque<offset_t>& new_targets);
+
+  // Assigns labels to targets based on associations previously inferred, using
+  // |min_affinity| to reject associations with weak |affinity|. Label 0 is
+  // assigned to unassociated targets. Labels for old targets are written to
+  // |old_labels| and labels for new targets are written to |new_labels|.
+  // Returns the upper bound on assigned labels (>= 1 since 0 is used).
+  uint32_t AssignLabels(double min_affinity,
+                        std::vector<uint32_t>* old_labels,
+                        std::vector<uint32_t>* new_labels);
+
+  // Returns the affinity score between targets identified by |old_key| and
+  // |new_keys|. Affinity > 0 means an association is likely, < 0 means
+  // incompatible association, and 0 means neither targets have been associated.
+  double AffinityBetween(key_t old_key, key_t new_key) const;
+
+ private:
+  struct Association {
+    key_t other = 0;
+    double affinity = 0.0;
+  };
+
+  // Forward and backward associations between old and new targets. For each
+  // Association element, if |affinity == 0.0| then no association is defined
+  // (and |other| is meaningless|. Otherwise |affinity > 0.0|, and the
+  // association between |old_labels[old_key]| and |new_labels[new_key]| is
+  // represented by:
+  //   forward_association_[old_key].other == new_key;
+  //   backward_association_[new_key].other == old_key;
+  //   forward_association_[old_key].affinity ==
+  //       backward_association_[new_key].affinity;
+  // The two lists contain the same information, but having both enables quick
+  // lookup, given |old_key| or |new_key|.
+  std::vector<Association> forward_association_;
+  std::vector<Association> backward_association_;
+};
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_TARGETS_AFFINITY_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_dex.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_dex.h
new file mode 100644
index 0000000..ee61ecd
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_dex.h
@@ -0,0 +1,332 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_TYPE_DEX_H_
+#define COMPONENTS_ZUCCHINI_TYPE_DEX_H_
+
+#include <stdint.h>
+
+namespace zucchini {
+namespace dex {
+// Contains types that models DEX executable format data structures.
+// See https://source.android.com/devices/tech/dalvik/dex-format
+
+// The supported versions are 035, 037, 038, and 039.
+
+enum class FormatId : uint8_t {
+  b,  // 22b.
+  c,  // 21c, 22c, 31c, 35c, 3rc, 45cc, 4rcc.
+  h,  // 21h.
+  i,  // 31i.
+  l,  // 51l.
+  n,  // 11n.
+  s,  // 21s, 22s.
+  t,  // 10t, 20t, 21t, 22t, 30t, 31t.
+  x,  // 10x, 11x, 12x, 22x, 23x, 32x.
+};
+
+struct Instruction {
+  Instruction() = default;
+  constexpr Instruction(uint8_t opcode_in,
+                        uint8_t layout_in,
+                        FormatId format_in,
+                        uint8_t variant_in = 1)
+      : opcode(opcode_in),
+        layout(layout_in),
+        format(format_in),
+        variant(variant_in) {}
+
+  // The opcode that identifies the instruction.
+  uint8_t opcode;
+  // Number of uint16_t units for the instruction.
+  uint8_t layout;
+  // Identifier that groups similar instructions, as quick filter.
+  FormatId format;
+  // Number of successive opcodes that have the same format.
+  uint8_t variant = 1;
+};
+
+constexpr Instruction kByteCode[] = {
+    {0x00, 1, FormatId::x},
+    {0x01, 1, FormatId::x},
+    {0x02, 2, FormatId::x},
+    {0x03, 3, FormatId::x},
+    {0x04, 1, FormatId::x},
+    {0x05, 2, FormatId::x},
+    {0x06, 3, FormatId::x},
+    {0x07, 1, FormatId::x},
+    {0x08, 2, FormatId::x},
+    {0x09, 3, FormatId::x},
+    {0x0A, 1, FormatId::x},
+    {0x0B, 1, FormatId::x},
+    {0x0C, 1, FormatId::x},
+    {0x0D, 1, FormatId::x},
+    {0x0E, 1, FormatId::x},
+    {0x0F, 1, FormatId::x},
+    {0x10, 1, FormatId::x},
+    {0x11, 1, FormatId::x},
+    {0x12, 1, FormatId::n},
+    {0x13, 2, FormatId::s},
+    {0x14, 3, FormatId::i},
+    {0x15, 2, FormatId::h},
+    {0x16, 2, FormatId::s},
+    {0x17, 3, FormatId::i},
+    {0x18, 5, FormatId::l},
+    {0x19, 2, FormatId::h},
+    {0x1A, 2, FormatId::c},
+    {0x1B, 3, FormatId::c},
+    {0x1C, 2, FormatId::c},
+    {0x1D, 1, FormatId::x},
+    {0x1E, 1, FormatId::x},
+    {0x1F, 2, FormatId::c},
+    {0x20, 2, FormatId::c},
+    {0x21, 1, FormatId::x},
+    {0x22, 2, FormatId::c},
+    {0x23, 2, FormatId::c},
+    {0x24, 3, FormatId::c},
+    {0x25, 3, FormatId::c},
+    {0x26, 3, FormatId::t},
+    {0x27, 1, FormatId::x},
+    {0x28, 1, FormatId::t},
+    {0x29, 2, FormatId::t},
+    {0x2A, 3, FormatId::t},
+    {0x2B, 3, FormatId::t},
+    {0x2C, 3, FormatId::t},
+    {0x2D, 2, FormatId::x, 5},
+    {0x32, 2, FormatId::t, 6},
+    {0x38, 2, FormatId::t, 6},
+    // {0x3E, 1, FormatId::x, 6}, unused
+    {0x44, 2, FormatId::x, 14},
+    {0x52, 2, FormatId::c, 14},
+    {0x60, 2, FormatId::c, 14},
+    {0x6E, 3, FormatId::c, 5},
+    // {0x73, 1, FormatId::x}, unused
+    {0x74, 3, FormatId::c, 5},
+    // {0x79, 1, FormatId::x, 2}, unused
+    {0x7B, 1, FormatId::x, 21},
+    {0x90, 2, FormatId::x, 32},
+    {0xB0, 1, FormatId::x, 32},
+    {0xD0, 2, FormatId::s, 8},
+    {0xD8, 2, FormatId::b, 11},
+    // {0xE3, 1, FormatId::x, 29}, unused
+    {0xFA, 4, FormatId::c},
+    {0xFB, 4, FormatId::c},
+    {0xFC, 3, FormatId::c},
+    {0xFD, 3, FormatId::c},
+    {0xFE, 2, FormatId::c},
+    {0xFF, 2, FormatId::c},
+};
+
+// Supported by MSVC, g++, and clang++. Ensures no gaps in packing.
+#pragma pack(push, 1)
+
+// header_item: Appears in the header section.
+struct HeaderItem {
+  uint8_t magic[8];
+  uint32_t checksum;
+  uint8_t signature[20];
+  uint32_t file_size;
+  uint32_t header_size;
+  uint32_t endian_tag;
+  uint32_t link_size;
+  uint32_t link_off;
+  uint32_t map_off;
+  uint32_t string_ids_size;
+  uint32_t string_ids_off;
+  uint32_t type_ids_size;
+  uint32_t type_ids_off;
+  uint32_t proto_ids_size;
+  uint32_t proto_ids_off;
+  uint32_t field_ids_size;
+  uint32_t field_ids_off;
+  uint32_t method_ids_size;
+  uint32_t method_ids_off;
+  uint32_t class_defs_size;
+  uint32_t class_defs_off;
+  uint32_t data_size;
+  uint32_t data_off;
+};
+
+// string_id_item: String identifiers list.
+struct StringIdItem {
+  uint32_t string_data_off;
+};
+
+// type_id_item: Type identifiers list.
+struct TypeIdItem {
+  uint32_t descriptor_idx;
+};
+
+// proto_id_item: Method prototype identifiers list.
+struct ProtoIdItem {
+  uint32_t shorty_idx;
+  uint32_t return_type_idx;
+  uint32_t parameters_off;
+};
+
+// field_id_item: Field identifiers list.
+struct FieldIdItem {
+  uint16_t class_idx;
+  uint16_t type_idx;
+  uint32_t name_idx;
+};
+
+// method_id_item: Method identifiers list.
+struct MethodIdItem {
+  uint16_t class_idx;
+  uint16_t proto_idx;
+  uint32_t name_idx;
+};
+
+// class_def_item: Class definitions list.
+struct ClassDefItem {
+  uint32_t class_idx;
+  uint32_t access_flags;
+  uint32_t superclass_idx;
+  uint32_t interfaces_off;
+  uint32_t source_file_idx;
+  uint32_t annotations_off;
+  uint32_t class_data_off;
+  uint32_t static_values_off;
+};
+
+// call_site_id_item: Call site identifiers list.
+struct CallSiteIdItem {
+  uint32_t call_site_off;
+};
+
+// method_handle_type: Determines the behavior of the MethodHandleItem.
+enum class MethodHandleType : uint16_t {
+  // FieldId
+  kStaticPut = 0x00,
+  kStaticGet = 0x01,
+  kInstancePut = 0x02,
+  kInstanceGet = 0x03,
+  // MethodId
+  kInvokeStatic = 0x04,
+  kInvokeInstance = 0x05,
+  kInvokeConstructor = 0x06,
+  kInvokeDirect = 0x07,
+  kInvokeInterface = 0x08,
+  // Sentinel. If new types are added put them before this and increment.
+  kMaxMethodHandleType = 0x09
+};
+
+// method_handle_item: Method handles referred within the Dex file.
+struct MethodHandleItem {
+  uint16_t method_handle_type;
+  uint16_t unused_1;
+  uint16_t field_or_method_id;
+  uint16_t unused_2;
+};
+
+// code_item: Header of a code item.
+struct CodeItem {
+  uint16_t registers_size;
+  uint16_t ins_size;
+  uint16_t outs_size;
+  uint16_t tries_size;
+  uint32_t debug_info_off;
+  uint32_t insns_size;
+  // Variable length data follow for complete code item.
+};
+
+// Number of valid type codes for map_item elements in map_list.
+// See: https://source.android.com/devices/tech/dalvik/dex-format#type-codes
+constexpr uint32_t kMaxItemListSize = 21;
+
+constexpr uint16_t kTypeHeaderItem = 0x0000;
+constexpr uint16_t kTypeStringIdItem = 0x0001;
+constexpr uint16_t kTypeTypeIdItem = 0x0002;
+constexpr uint16_t kTypeProtoIdItem = 0x0003;
+constexpr uint16_t kTypeFieldIdItem = 0x0004;
+constexpr uint16_t kTypeMethodIdItem = 0x0005;
+constexpr uint16_t kTypeClassDefItem = 0x0006;
+constexpr uint16_t kTypeCallSiteIdItem = 0x0007;
+constexpr uint16_t kTypeMethodHandleItem = 0x0008;
+constexpr uint16_t kTypeMapList = 0x1000;
+constexpr uint16_t kTypeTypeList = 0x1001;
+constexpr uint16_t kTypeAnnotationSetRefList = 0x1002;
+constexpr uint16_t kTypeAnnotationSetItem = 0x1003;
+constexpr uint16_t kTypeClassDataItem = 0x2000;
+constexpr uint16_t kTypeCodeItem = 0x2001;
+constexpr uint16_t kTypeStringDataItem = 0x2002;
+constexpr uint16_t kTypeDebugInfoItem = 0x2003;
+constexpr uint16_t kTypeAnnotationItem = 0x2004;
+constexpr uint16_t kTypeEncodedArrayItem = 0x2005;
+constexpr uint16_t kTypeAnnotationsDirectoryItem = 0x2006;
+constexpr uint16_t kTypeHiddenApiClassDataItem = 0xF000;
+
+// map_item
+struct MapItem {
+  uint16_t type;
+  uint16_t unused;
+  uint32_t size;
+  uint32_t offset;
+};
+
+// map_list
+struct MapList {
+  uint32_t size;
+  MapItem list[kMaxItemListSize];
+};
+
+// type_item
+struct TypeItem {
+  uint16_t type_idx;
+};
+
+// annotation_set_ref_item
+struct AnnotationSetRefItem {
+  uint32_t annotations_off;
+};
+
+// annotation_off_item
+struct AnnotationOffItem {
+  uint32_t annotation_off;
+};
+
+// field_annotation
+struct FieldAnnotation {
+  uint32_t field_idx;
+  uint32_t annotations_off;
+};
+
+// method_annotation
+struct MethodAnnotation {
+  uint32_t method_idx;
+  uint32_t annotations_off;
+};
+
+// parameter_annotation
+struct ParameterAnnotation {
+  uint32_t method_idx;
+  uint32_t annotations_off;
+};
+
+// annotations_directory_item
+struct AnnotationsDirectoryItem {
+  uint32_t class_annotations_off;
+  uint32_t fields_size;
+  uint32_t annotated_methods_size;
+  uint32_t annotated_parameters_size;
+  // FieldAnnotation field_annotations[fields_size];
+  // MethodAnnotation method_annotations[annotated_methods_size];
+  // ParameterAnnotation parameter_annotations[annotated_parameters_size];
+  // All *Annotation are 8 bytes each.
+};
+
+// try_item
+struct TryItem {
+  uint32_t start_addr;
+  uint16_t insn_count;
+  uint16_t handler_off;
+};
+
+#pragma pack(pop)
+
+}  // namespace dex
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_TYPE_DEX_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_elf.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_elf.h
new file mode 100644
index 0000000..2a522b1
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_elf.h
@@ -0,0 +1,283 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_TYPE_ELF_H_
+#define COMPONENTS_ZUCCHINI_TYPE_ELF_H_
+
+#include <stdint.h>
+
+namespace zucchini {
+
+// Structures and constants taken from linux/elf.h and following identical
+// layout. This is used for parsing of Executable and Linkable Format (ELF).
+namespace elf {
+// Supported by MSVC, g++, and clang++. Ensures no gaps in packing.
+#pragma pack(push, 1)
+
+// This header defines various types from the ELF file spec, but no code
+// related to using them.
+
+typedef uint32_t Elf32_Addr;  // Unsigned program address.
+typedef uint16_t Elf32_Half;  // Unsigned medium integer.
+typedef uint32_t Elf32_Off;   // Unsigned file offset.
+typedef int32_t Elf32_Sword;  // Signed large integer.
+typedef uint32_t Elf32_Word;  // Unsigned large integer.
+
+typedef uint64_t Elf64_Addr;   // Unsigned program address.
+typedef uint16_t Elf64_Half;   // Unsigned medium integer.
+typedef uint64_t Elf64_Off;    // Unsigned file offset.
+typedef int32_t Elf64_Sword;   // Signed large integer.
+typedef uint32_t Elf64_Word;   // Unsigned large integer.
+typedef int64_t Elf64_Sxword;  // Signed extra large integer.
+typedef uint64_t Elf64_Xword;  // Unsigned extra large integer.
+
+// The header at the top of the file.
+struct Elf32_Ehdr {
+  unsigned char e_ident[16];
+  Elf32_Half e_type;
+  Elf32_Half e_machine;
+  Elf32_Word e_version;
+  Elf32_Addr e_entry;
+  Elf32_Off e_phoff;
+  Elf32_Off e_shoff;
+  Elf32_Word e_flags;
+  Elf32_Half e_ehsize;
+  Elf32_Half e_phentsize;
+  Elf32_Half e_phnum;
+  Elf32_Half e_shentsize;
+  Elf32_Half e_shnum;
+  Elf32_Half e_shstrndx;
+};
+
+struct Elf64_Ehdr {
+  unsigned char e_ident[16];
+  Elf64_Half e_type;
+  Elf64_Half e_machine;
+  Elf64_Word e_version;
+  Elf64_Addr e_entry;
+  Elf64_Off e_phoff;
+  Elf64_Off e_shoff;
+  Elf64_Word e_flags;
+  Elf64_Half e_ehsize;
+  Elf64_Half e_phentsize;
+  Elf64_Half e_phnum;
+  Elf64_Half e_shentsize;
+  Elf64_Half e_shnum;
+  Elf64_Half e_shstrndx;
+};
+
+// Identification Indexes in header->e_ident.
+enum IdentificationIndex {
+  EI_MAG0 = 0,        // File identification.
+  EI_MAG1 = 1,        // File identification.
+  EI_MAG2 = 2,        // File identification.
+  EI_MAG3 = 3,        // File identification.
+  EI_CLASS = 4,       // File class.
+  EI_DATA = 5,        // Data encoding.
+  EI_VERSION = 6,     // File version.
+  EI_OSABI = 7,       // Operating system/ABI identification.
+  EI_ABIVERSION = 8,  // ABI version.
+  EI_PAD = 9,         // Start of padding bytes.
+  EI_NIDENT = 16      // Size of e_ident[].
+};
+
+// Values for header->e_ident[EI_CLASS].
+enum FileClass {
+  ELFCLASSNONE = 0,  // Invalid class.
+  ELFCLASS32 = 1,    // 32-bit objects.
+  ELFCLASS64 = 2     // 64-bit objects.
+};
+
+// Values for header->e_type.
+enum FileType {
+  ET_NONE = 0,         // No file type
+  ET_REL = 1,          // Relocatable file
+  ET_EXEC = 2,         // Executable file
+  ET_DYN = 3,          // Shared object file
+  ET_CORE = 4,         // Core file
+  ET_LOPROC = 0xFF00,  // Processor-specific
+  ET_HIPROC = 0xFFFF   // Processor-specific
+};
+
+// Values for header->e_machine.
+enum MachineArchitecture {
+  EM_NONE = 0,       // No machine.
+  EM_386 = 3,        // Intel Architecture.
+  EM_ARM = 40,       // ARM Architecture.
+  EM_X86_64 = 62,    // Intel x86-64 Architecture.
+  EM_AARCH64 = 183,  // ARM Architecture, 64-bit.
+  // Other values skipped.
+};
+
+// A section header in the section header table.
+struct Elf32_Shdr {
+  Elf32_Word sh_name;
+  Elf32_Word sh_type;
+  Elf32_Word sh_flags;
+  Elf32_Addr sh_addr;
+  Elf32_Off sh_offset;
+  Elf32_Word sh_size;
+  Elf32_Word sh_link;
+  Elf32_Word sh_info;
+  Elf32_Word sh_addralign;
+  Elf32_Word sh_entsize;
+};
+
+struct Elf64_Shdr {
+  Elf64_Word sh_name;
+  Elf64_Word sh_type;
+  Elf64_Xword sh_flags;
+  Elf64_Addr sh_addr;
+  Elf64_Off sh_offset;
+  Elf64_Xword sh_size;
+  Elf64_Word sh_link;
+  Elf64_Word sh_info;
+  Elf64_Xword sh_addralign;
+  Elf64_Xword sh_entsize;
+};
+
+// Values for the section type field in a section header.
+enum sh_type_values {
+  SHT_NULL = 0,
+  SHT_PROGBITS = 1,
+  SHT_SYMTAB = 2,
+  SHT_STRTAB = 3,
+  SHT_RELA = 4,
+  SHT_HASH = 5,
+  SHT_DYNAMIC = 6,
+  SHT_NOTE = 7,
+  SHT_NOBITS = 8,
+  SHT_REL = 9,
+  SHT_SHLIB = 10,
+  SHT_DYNSYM = 11,
+  SHT_INIT_ARRAY = 14,
+  SHT_FINI_ARRAY = 15,
+  SHT_LOPROC = 0x70000000,
+  SHT_HIPROC = 0x7FFFFFFF,
+  SHT_LOUSER = 0x80000000,
+  SHT_HIUSER = 0xFFFFFFFF
+};
+
+enum sh_flag_masks {
+  SHF_WRITE = 1 << 0,
+  SHF_ALLOC = 1 << 1,
+  SHF_EXECINSTR = 1 << 2,
+  // 1 << 3 is reserved.
+  SHF_MERGE = 1 << 4,
+  SHF_STRINGS = 1 << 5,
+  SHF_INFO_LINK = 1 << 6,
+  SHF_LINK_ORDER = 1 << 7,
+  SHF_OS_NONCONFORMING = 1 << 8,
+  SHF_GROUP = 1 << 9,
+  SHF_TLS = 1 << 10,
+  SHF_COMPRESSED = 1 << 11,
+};
+
+struct Elf32_Phdr {
+  Elf32_Word p_type;
+  Elf32_Off p_offset;
+  Elf32_Addr p_vaddr;
+  Elf32_Addr p_paddr;
+  Elf32_Word p_filesz;
+  Elf32_Word p_memsz;
+  Elf32_Word p_flags;
+  Elf32_Word p_align;
+};
+
+struct Elf64_Phdr {
+  Elf64_Word p_type;
+  Elf64_Word p_flags;
+  Elf64_Off p_offset;
+  Elf64_Addr p_vaddr;
+  Elf64_Addr p_paddr;
+  Elf64_Xword p_filesz;
+  Elf64_Xword p_memsz;
+  Elf64_Xword p_align;
+};
+
+// Values for the segment type field in a program segment header.
+enum ph_type_values {
+  PT_NULL = 0,
+  PT_LOAD = 1,
+  PT_DYNAMIC = 2,
+  PT_INTERP = 3,
+  PT_NOTE = 4,
+  PT_SHLIB = 5,
+  PT_PHDR = 6,
+  PT_LOPROC = 0x70000000,
+  PT_HIPROC = 0x7FFFFFFF
+};
+
+struct Elf32_Rel {
+  Elf32_Addr r_offset;
+  Elf32_Word r_info;
+};
+
+struct Elf64_Rel {
+  Elf64_Addr r_offset;
+  Elf64_Xword r_info;
+};
+
+struct Elf32_Rela {
+  Elf32_Addr r_offset;
+  Elf32_Word r_info;
+  Elf32_Sword r_addend;
+};
+
+struct Elf64_Rela {
+  Elf64_Addr r_offset;
+  Elf64_Xword r_info;
+  Elf64_Sxword r_addend;
+};
+
+enum elf32_rel_386_type_values {
+  R_386_NONE = 0,
+  R_386_32 = 1,
+  R_386_PC32 = 2,
+  R_386_GOT32 = 3,
+  R_386_PLT32 = 4,
+  R_386_COPY = 5,
+  R_386_GLOB_DAT = 6,
+  R_386_JMP_SLOT = 7,
+  R_386_RELATIVE = 8,
+  R_386_GOTOFF = 9,
+  R_386_GOTPC = 10,
+  R_386_TLS_TPOFF = 14,
+};
+
+enum elf32_rel_x86_64_type_values {
+  R_X86_64_NONE = 0,
+  R_X86_64_64 = 1,
+  R_X86_64_PC32 = 2,
+  R_X86_64_GOT32 = 3,
+  R_X86_64_PLT32 = 4,
+  R_X86_64_COPY = 5,
+  R_X86_64_GLOB_DAT = 6,
+  R_X86_64_JUMP_SLOT = 7,
+  R_X86_64_RELATIVE = 8,
+  R_X86_64_GOTPCREL = 9,
+  R_X86_64_32 = 10,
+  R_X86_64_32S = 11,
+  R_X86_64_16 = 12,
+  R_X86_64_PC16 = 13,
+  R_X86_64_8 = 14,
+  R_X86_64_PC8 = 15,
+};
+
+enum elf32_rel_arm_type_values {
+  R_ARM_RELATIVE = 23,
+};
+
+enum elf64_rel_aarch64_type_values {
+  R_AARCH64_GLOB_DAT = 0x401,
+  R_AARCH64_JUMP_SLOT = 0x402,
+  R_AARCH64_RELATIVE = 0x403,
+};
+
+#pragma pack(pop)
+
+}  // namespace elf
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_TYPE_ELF_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/typed_value.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/typed_value.h
new file mode 100644
index 0000000..868397c
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/typed_value.h
@@ -0,0 +1,57 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_TYPED_VALUE_H_
+#define COMPONENTS_ZUCCHINI_TYPED_VALUE_H_
+
+#include <ostream>
+
+namespace zucchini {
+
+// Strong typed values, with compare and convert functions for underlying data.
+// Typically one would use strongly typed enums for this. However, for Zucchini,
+// the number of bytes is not fixed, and must be represented as an integer for
+// iteration.
+// |Tag| is a type tag used to uniquely identify TypedValue.
+// |T| is an integral type used to hold values.
+// Example:
+//    struct Foo : TypedValue<Foo, int> {
+//      using Foo::TypedValue::TypedValue; // inheriting constructor.
+//    };
+// Foo will be used to hold values of type |int|, but with a distinct type from
+// any other TypedValue.
+template <class Tag, class T>
+class TypedValue {
+ public:
+  constexpr TypedValue() = default;
+  explicit constexpr TypedValue(const T& value) : value_(value) {}
+
+  explicit operator T() const { return value_; }
+  const T value() const { return value_; }
+
+  friend bool operator==(const TypedValue& a, const TypedValue& b) {
+    return a.value_ == b.value_;
+  }
+  friend bool operator!=(const TypedValue& a, const TypedValue& b) {
+    return !(a == b);
+  }
+  friend bool operator<(const TypedValue& a, const TypedValue& b) {
+    return a.value_ < b.value_;
+  }
+  friend bool operator>(const TypedValue& a, const TypedValue& b) {
+    return b < a;
+  }
+
+ private:
+  T value_ = {};
+};
+
+template <class Tag, class T>
+std::ostream& operator<<(std::ostream& os, const TypedValue<Tag, T>& tag) {
+  return os << tag.value();
+}
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_TYPED_VALUE_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/version_info.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/version_info.h
new file mode 100644
index 0000000..c6d2fac
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/version_info.h
@@ -0,0 +1,30 @@
+// Copyright 2021 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_VERSION_INFO_H_
+#define COMPONENTS_ZUCCHINI_VERSION_INFO_H_
+
+// This file serves as a stable location for main Zucchini version constants,
+// whose names and types should also be stable. These allow external tools to
+// determine Zucchini version at compile time by inclusion or parsing.
+
+namespace zucchini {
+
+// A change in major version indicates breaking changes such that a patch
+// definitely cannot be applied by a zucchini binary whose major version doesn't
+// match.
+enum : uint16_t { kMajorVersion = 1 };
+
+// A change in minor version indicates possibly breaking changes at the element
+// level, such that it may not be possible to apply a patch whose minor version
+// doesn't match this version. To determine if a given patch may be applied with
+// this version, VerifyPatch() should be called.
+enum : uint16_t { kMinorVersion = 0 };
+
+// A empty or error value for major or minor version numbers.
+enum : uint16_t { kInvalidVersion = 0xffff };
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_VERSION_INFO_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini.h
new file mode 100644
index 0000000..9847440
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini.h
@@ -0,0 +1,72 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_ZUCCHINI_H_
+#define COMPONENTS_ZUCCHINI_ZUCCHINI_H_
+
+#include <string>
+
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/patch_reader.h"
+#include "components/zucchini/patch_writer.h"
+
+// Core Zucchini library, consisting of:
+// - Global constants.
+// - Patch gen and apply functions, where "old" and "new" data are represented
+//   as buffers, and patch data represented as EnsemblePatchWriter or
+//   EnsemblePatchReader.
+
+namespace zucchini {
+
+namespace status {
+
+// Zucchini status code, which can also be used as process exit code. Therefore
+// success is explicitly 0.
+enum Code {
+  kStatusSuccess = 0,
+  kStatusInvalidParam = 1,
+  kStatusFileReadError = 2,
+  kStatusFileWriteError = 3,
+  kStatusPatchReadError = 4,
+  kStatusPatchWriteError = 5,
+  kStatusInvalidOldImage = 6,
+  kStatusInvalidNewImage = 7,
+  kStatusFatal = 8,
+};
+
+}  // namespace status
+
+// Generates ensemble patch from |old_image| to |new_image| using the default
+// element detection and matching heuristics, writes the results to
+// |patch_writer|, and returns a status::Code.
+status::Code GenerateBuffer(ConstBufferView old_image,
+                            ConstBufferView new_image,
+                            EnsemblePatchWriter* patch_writer);
+
+// Same as GenerateEnsemble(), but if |imposed_matches| is non-empty, then
+// overrides default element detection and matching heuristics with custom
+// element matching encoded in |imposed_matches|, which should be formatted as:
+//   "#+#=#+#,#+#=#+#,..."  (e.g., "1+2=3+4", "1+2=3+4,5+6=7+8"),
+// where "#+#=#+#" encodes a match as 4 unsigned integers:
+//   [offset in "old", size in "old", offset in "new", size in "new"].
+status::Code GenerateBufferImposed(ConstBufferView old_image,
+                                   ConstBufferView new_image,
+                                   std::string imposed_matches,
+                                   EnsemblePatchWriter* patch_writer);
+
+// Generates raw patch from |old_image| to |new_image|, and writes it to
+// |patch_writer|.
+status::Code GenerateBufferRaw(ConstBufferView old_image,
+                               ConstBufferView new_image,
+                               EnsemblePatchWriter* patch_writer);
+
+// Applies |patch_reader| to |old_image| to build |new_image|, which refers to
+// preallocated memory of sufficient size.
+status::Code ApplyBuffer(ConstBufferView old_image,
+                         const EnsemblePatchReader& patch_reader,
+                         MutableBufferView new_image);
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_ZUCCHINI_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini_apply.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini_apply.h
new file mode 100644
index 0000000..abab384
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini_apply.h
@@ -0,0 +1,41 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_ZUCCHINI_ZUCCHINI_APPLY_H_
+#define COMPONENTS_ZUCCHINI_ZUCCHINI_APPLY_H_
+
+#include "components/zucchini/image_utils.h"
+#include "components/zucchini/patch_reader.h"
+#include "components/zucchini/zucchini.h"
+
+namespace zucchini {
+
+// Reads equivalences from |patch_reader| to form preliminary |new_image|,
+// copying regions from |old_image| and writing extra data from |patch_reader|.
+bool ApplyEquivalenceAndExtraData(ConstBufferView old_image,
+                                  const PatchElementReader& patch_reader,
+                                  MutableBufferView new_image);
+
+// Reads raw delta from |patch_reader| and applies corrections to |new_image|.
+bool ApplyRawDelta(const PatchElementReader& patch_reader,
+                   MutableBufferView new_image);
+
+// Corrects references in |new_image| by projecting references from |old_image|
+// and applying corrections from |patch_reader|. Both |old_image| and
+// |new_image| are matching elements associated with |exe_type|.
+bool ApplyReferencesCorrection(ExecutableType exe_type,
+                               ConstBufferView old_image,
+                               const PatchElementReader& patch_reader,
+                               MutableBufferView new_image);
+
+// Applies patch element with type |exe_type| from |patch_reader| on |old_image|
+// to produce |new_image|.
+bool ApplyElement(ExecutableType exe_type,
+                  ConstBufferView old_image,
+                  const PatchElementReader& patch_reader,
+                  MutableBufferView new_image);
+
+}  // namespace zucchini
+
+#endif  // COMPONENTS_ZUCCHINI_ZUCCHINI_APPLY_H_
diff --git a/native/zucchini/vendor/zucchini/arm_utils.cc b/native/zucchini/vendor/zucchini/arm_utils.cc
new file mode 100644
index 0000000..2a915a8
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/arm_utils.cc
@@ -0,0 +1,597 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/arm_utils.h"
+
+#include "components/zucchini/algorithm.h"
+
+namespace zucchini {
+
+namespace {
+
+inline bool IsMisaligned(rva_t rva, ArmAlign align) {
+  return (rva & (align - 1)) != 0;
+}
+
+}  // namespace
+
+/******** AArch32Rel32Translator ********/
+
+AArch32Rel32Translator::AArch32Rel32Translator() = default;
+
+// The mapping between ARM instruction "Code" to "Displacement" involves complex
+// bit manipulation. The comments below annotate bits mappings using a string.
+// * Bits are listed from highest-order to lowerst-order (like in the manual).
+// * '0' and '1' denote literals.
+// * Uppercase letters denote a single bit in "Code". For example, 'S' denotes
+//   a sign bit that gets extended in "Displacement". To follow naming in the
+//   manual, these may enumerated, and written as "(I1)", "(I2)", etc.
+// * Lowercase letters denote bit fields with orders preserved.
+
+// static
+ArmAlign AArch32Rel32Translator::DecodeA24(uint32_t code32, arm_disp_t* disp) {
+  // Handle multiple instructions. Let cccc != 1111:
+  // B encoding A1:
+  //   Code:         cccc1010 Siiiiiii iiiiiiii iiiiiiii
+  //   Displacement: SSSSSSSi iiiiiiii iiiiiiii iiiiii00
+  // BL encoding A1:
+  //   Code:         cccc1011 Siiiiiii iiiiiiii iiiiiiii
+  //   Displacement: SSSSSSSi iiiiiiii iiiiiiii iiiiii00
+  // BLX encoding A2:
+  //   Code:         1111101H Siiiiiii iiiiiiii iiiiiiii
+  //   Displacement: SSSSSSSi iiiiiiii iiiiiiii iiiiiiH0
+  uint8_t bits = GetUnsignedBits<24, 27>(code32);
+  if (bits == 0xA || bits == 0xB) {  // B, BL, or BLX.
+    *disp = GetSignedBits<0, 23>(code32) << 2;
+    uint8_t cond = GetUnsignedBits<28, 31>(code32);
+    if (cond == 0xF) {  // BLX.
+      uint32_t H = GetBit<24>(code32);
+      *disp |= H << 1;
+      return kArmAlign2;
+    }
+    return kArmAlign4;
+  }
+  return kArmAlignFail;
+}
+
+// static
+bool AArch32Rel32Translator::EncodeA24(arm_disp_t disp, uint32_t* code32) {
+  uint32_t t = *code32;
+  uint8_t bits = GetUnsignedBits<24, 27>(t);
+  if (bits == 0xA || bits == 0xB) {
+    // B, BL, or BLX.
+    if (!SignedFit<26>(disp))  // Detect overflow.
+      return false;
+    uint8_t cond = GetUnsignedBits<28, 31>(t);
+    if (cond == 0xF) {
+      if (disp % 2)  // BLX (encoding A2) requires 2-byte alignment.
+        return false;
+      uint32_t H = GetBit<1>(disp);
+      t = (t & 0xFEFFFFFF) | (H << 24);
+    } else {
+      if (disp % 4)  // B and BL require 4-byte alignment.
+        return false;
+    }
+    t = (t & 0xFF000000) | ((disp >> 2) & 0x00FFFFFF);
+    *code32 = t;
+    return true;
+  }
+  return false;
+}
+
+// static
+bool AArch32Rel32Translator::ReadA24(rva_t instr_rva,
+                                     uint32_t code32,
+                                     rva_t* target_rva) {
+  constexpr ArmAlign kInstrAlign = kArmAlign4;
+  if (IsMisaligned(instr_rva, kInstrAlign))
+    return false;
+  arm_disp_t disp;
+  ArmAlign target_align = DecodeA24(code32, &disp);
+  if (target_align == kArmAlignFail)
+    return false;
+  *target_rva = GetArmTargetRvaFromDisp(instr_rva, disp, target_align);
+  return true;
+}
+
+// static
+bool AArch32Rel32Translator::WriteA24(rva_t instr_rva,
+                                      rva_t target_rva,
+                                      uint32_t* code32) {
+  constexpr ArmAlign kInstrAlign = kArmAlign4;
+  if (IsMisaligned(instr_rva, kInstrAlign))
+    return false;
+  // Dummy decode to get |target_align|.
+  arm_disp_t dummy_disp;
+  ArmAlign target_align = DecodeA24(*code32, &dummy_disp);
+  if (target_align == kArmAlignFail || IsMisaligned(target_rva, target_align))
+    return false;
+  arm_disp_t disp =
+      GetArmDispFromTargetRva(instr_rva, target_rva, target_align);
+  return EncodeA24(disp, code32);
+}
+
+// static
+ArmAlign AArch32Rel32Translator::DecodeT8(uint16_t code16, arm_disp_t* disp) {
+  if ((code16 & 0xF000) == 0xD000 && (code16 & 0x0F00) != 0x0F00) {
+    // B encoding T1:
+    //   Code:         1101cccc Siiiiiii
+    //   Displacement: SSSSSSSS SSSSSSSS SSSSSSSS iiiiiii0
+    *disp = GetSignedBits<0, 7>(code16) << 1;
+    return kArmAlign2;
+  }
+  return kArmAlignFail;
+}
+
+// static
+bool AArch32Rel32Translator::EncodeT8(arm_disp_t disp, uint16_t* code16) {
+  uint16_t t = *code16;
+  if ((t & 0xF000) == 0xD000 && (t & 0x0F00) != 0x0F00) {
+    if (disp % 2)  // Require 2-byte alignment.
+      return false;
+    if (!SignedFit<9>(disp))  // Detect overflow.
+      return false;
+    t = (t & 0xFF00) | ((disp >> 1) & 0x00FF);
+    *code16 = t;
+    return true;
+  }
+  return false;
+}
+
+// static
+bool AArch32Rel32Translator::ReadT8(rva_t instr_rva,
+                                    uint16_t code16,
+                                    rva_t* target_rva) {
+  constexpr ArmAlign kInstrAlign = kArmAlign2;
+  if (IsMisaligned(instr_rva, kInstrAlign))
+    return false;
+  arm_disp_t disp;
+  ArmAlign target_align = DecodeT8(code16, &disp);
+  if (target_align == kArmAlignFail)
+    return false;
+  *target_rva = GetThumb2TargetRvaFromDisp(instr_rva, disp, target_align);
+  return true;
+}
+
+// static
+bool AArch32Rel32Translator::WriteT8(rva_t instr_rva,
+                                     rva_t target_rva,
+                                     uint16_t* code16) {
+  constexpr ArmAlign kInstrAlign = kArmAlign2;
+  constexpr ArmAlign kTargetAlign = kArmAlign2;
+  if (IsMisaligned(instr_rva, kInstrAlign) ||
+      IsMisaligned(target_rva, kTargetAlign)) {
+    return false;
+  }
+  arm_disp_t disp =
+      GetThumb2DispFromTargetRva(instr_rva, target_rva, kTargetAlign);
+  return EncodeT8(disp, code16);
+}
+
+// static
+ArmAlign AArch32Rel32Translator::DecodeT11(uint16_t code16, arm_disp_t* disp) {
+  if ((code16 & 0xF800) == 0xE000) {
+    // B encoding T2:
+    //   Code:         11100Sii iiiiiiii
+    //   Displacement: SSSSSSSS SSSSSSSS SSSSSiii iiiiiii0
+    *disp = GetSignedBits<0, 10>(code16) << 1;
+    return kArmAlign2;
+  }
+  return kArmAlignFail;
+}
+
+// static
+bool AArch32Rel32Translator::EncodeT11(arm_disp_t disp, uint16_t* code16) {
+  uint16_t t = *code16;
+  if ((t & 0xF800) == 0xE000) {
+    if (disp % 2)  // Require 2-byte alignment.
+      return false;
+    if (!SignedFit<12>(disp))  // Detect overflow.
+      return false;
+    t = (t & 0xF800) | ((disp >> 1) & 0x07FF);
+    *code16 = t;
+    return true;
+  }
+  return false;
+}
+
+// static
+bool AArch32Rel32Translator::ReadT11(rva_t instr_rva,
+                                     uint16_t code16,
+                                     rva_t* target_rva) {
+  constexpr ArmAlign kInstrAlign = kArmAlign2;
+  if (IsMisaligned(instr_rva, kInstrAlign))
+    return false;
+  arm_disp_t disp;
+  ArmAlign target_align = DecodeT11(code16, &disp);
+  if (target_align == kArmAlignFail)
+    return false;
+  *target_rva = GetThumb2TargetRvaFromDisp(instr_rva, disp, target_align);
+  return true;
+}
+
+// static
+bool AArch32Rel32Translator::WriteT11(rva_t instr_rva,
+                                      rva_t target_rva,
+                                      uint16_t* code16) {
+  constexpr ArmAlign kInstrAlign = kArmAlign2;
+  constexpr ArmAlign kTargetAlign = kArmAlign2;
+  if (IsMisaligned(instr_rva, kInstrAlign) ||
+      IsMisaligned(target_rva, kTargetAlign)) {
+    return false;
+  }
+  arm_disp_t disp =
+      GetThumb2DispFromTargetRva(instr_rva, target_rva, kTargetAlign);
+  return EncodeT11(disp, code16);
+}
+
+// static
+ArmAlign AArch32Rel32Translator::DecodeT20(uint32_t code32, arm_disp_t* disp) {
+  if ((code32 & 0xF800D000) == 0xF0008000 &&
+      (code32 & 0x03C00000) != 0x03C00000) {
+    // B encoding T3. Note the reversal of "(J1)" and "(J2)".
+    //   Code:         11110Scc cciiiiii 10(J1)0(J2)jjj jjjjjjjj
+    //   Displacement: SSSSSSSS SSSS(J2)(J1)ii iiiijjjj jjjjjjj0
+    uint32_t imm11 = GetUnsignedBits<0, 10>(code32);  // jj...j.
+    uint32_t J2 = GetBit<11>(code32);
+    uint32_t J1 = GetBit<13>(code32);
+    uint32_t imm6 = GetUnsignedBits<16, 21>(code32);  // ii...i.
+    uint32_t S = GetBit<26>(code32);
+    uint32_t t = (imm6 << 12) | (imm11 << 1);
+    t |= (S << 20) | (J2 << 19) | (J1 << 18);
+    *disp = SignExtend<20, int32_t>(t);
+    return kArmAlign2;
+  }
+  return kArmAlignFail;
+}
+
+// static
+bool AArch32Rel32Translator::EncodeT20(arm_disp_t disp, uint32_t* code32) {
+  uint32_t t = *code32;
+  if ((t & 0xF800D000) == 0xF0008000 && (t & 0x03C00000) != 0x03C00000) {
+    if (disp % 2)  // Require 2-byte alignment.
+      return false;
+    if (!SignedFit<21>(disp))  // Detect overflow.
+      return false;
+    uint32_t S = GetBit<20>(disp);
+    uint32_t J2 = GetBit<19>(disp);
+    uint32_t J1 = GetBit<18>(disp);
+    uint32_t imm6 = GetUnsignedBits<12, 17>(disp);  // ii...i.
+    uint32_t imm11 = GetUnsignedBits<1, 11>(disp);  // jj...j.
+    t &= 0xFBC0D000;
+    t |= (S << 26) | (imm6 << 16) | (J1 << 13) | (J2 << 11) | imm11;
+    *code32 = t;
+    return true;
+  }
+  return false;
+}
+
+// static
+bool AArch32Rel32Translator::ReadT20(rva_t instr_rva,
+                                     uint32_t code32,
+                                     rva_t* target_rva) {
+  constexpr ArmAlign kInstrAlign = kArmAlign2;
+  if (IsMisaligned(instr_rva, kInstrAlign))
+    return false;
+  arm_disp_t disp;
+  ArmAlign target_align = DecodeT20(code32, &disp);
+  if (target_align == kArmAlignFail)
+    return false;
+  *target_rva = GetThumb2TargetRvaFromDisp(instr_rva, disp, target_align);
+  return true;
+}
+
+// static
+bool AArch32Rel32Translator::WriteT20(rva_t instr_rva,
+                                      rva_t target_rva,
+                                      uint32_t* code32) {
+  constexpr ArmAlign kInstrAlign = kArmAlign2;
+  constexpr ArmAlign kTargetAlign = kArmAlign2;
+  if (IsMisaligned(instr_rva, kInstrAlign) ||
+      IsMisaligned(target_rva, kTargetAlign)) {
+    return false;
+  }
+  arm_disp_t disp =
+      GetThumb2DispFromTargetRva(instr_rva, target_rva, kTargetAlign);
+  return EncodeT20(disp, code32);
+}
+
+// static
+ArmAlign AArch32Rel32Translator::DecodeT24(uint32_t code32, arm_disp_t* disp) {
+  uint32_t bits = code32 & 0xF800D000;
+  if (bits == 0xF0009000 || bits == 0xF000D000 || bits == 0xF000C000) {
+    // Let I1 = J1 ^ S ^ 1, I2 = J2 ^ S ^ 1.
+    // B encoding T4:
+    //   Code:         11110Sii iiiiiiii 10(J1)1(J2)jjj jjjjjjjj
+    //   Displacement: SSSSSSSS (I1)(I2)iiiiii iiiijjjj jjjjjjj0
+    // BL encoding T1:
+    //   Code:         11110Sii iiiiiiii 11(J1)1(J2)jjj jjjjjjjj
+    //   Displacement: SSSSSSSS (I1)(I2)iiiiii iiiijjjj jjjjjjj0
+    // BLX encoding T2: H should be 0:
+    //   Code:         11110Sii iiiiiiii 11(J1)0(J2)jjj jjjjjjjH
+    //   Displacement: SSSSSSSS (I1)(I2)iiiiii iiiijjjj jjjjjjH0
+    uint32_t imm11 = GetUnsignedBits<0, 10>(code32);  // jj...j.
+    uint32_t J2 = GetBit<11>(code32);
+    uint32_t J1 = GetBit<13>(code32);
+    uint32_t imm10 = GetUnsignedBits<16, 25>(code32);  // ii...i.
+    uint32_t S = GetBit<26>(code32);
+    uint32_t t = (imm10 << 12) | (imm11 << 1);
+    t |= (S << 24) | ((J1 ^ S ^ 1) << 23) | ((J2 ^ S ^ 1) << 22);
+    t = SignExtend<24, int32_t>(t);
+    // BLX encoding T2 requires final target to be 4-byte aligned by rounding
+    // downward. This is applied to |t| *after* clipping.
+    ArmAlign target_align = kArmAlign2;
+    if (bits == 0xF000C000) {
+      uint32_t H = GetBit<0>(code32);
+      if (H)
+        return kArmAlignFail;  // Illegal instruction: H must be 0.
+      target_align = kArmAlign4;
+    }
+    *disp = static_cast<int32_t>(t);
+    return target_align;
+  }
+  return kArmAlignFail;
+}
+
+// static
+bool AArch32Rel32Translator::EncodeT24(arm_disp_t disp, uint32_t* code32) {
+  uint32_t t = *code32;
+  uint32_t bits = t & 0xF800D000;
+  if (bits == 0xF0009000 || bits == 0xF000D000 || bits == 0xF000C000) {
+    if (disp % 2)  // Require 2-byte alignment.
+      return false;
+    // BLX encoding T2 requires H == 0, and that |disp| results in |target_rva|
+    // with a 4-byte aligned address.
+    if (bits == 0xF000C000) {
+      uint32_t H = GetBit<1>(disp);
+      if (H)
+        return false;  // Illegal |disp|: H must be 0.
+    }
+    if (!SignedFit<25>(disp))  // Detect overflow.
+      return false;
+    uint32_t imm11 = GetUnsignedBits<1, 11>(disp);   // jj...j.
+    uint32_t imm10 = GetUnsignedBits<12, 21>(disp);  // ii...i.
+    uint32_t I2 = GetBit<22>(disp);
+    uint32_t I1 = GetBit<23>(disp);
+    uint32_t S = GetBit<24>(disp);
+    t &= 0xF800D000;
+    t |= (S << 26) | (imm10 << 16) | ((I1 ^ S ^ 1) << 13) |
+         ((I2 ^ S ^ 1) << 11) | imm11;
+    *code32 = t;
+    return true;
+  }
+  return false;
+}
+
+// static
+bool AArch32Rel32Translator::ReadT24(rva_t instr_rva,
+                                     uint32_t code32,
+                                     rva_t* target_rva) {
+  constexpr ArmAlign kInstrAlign = kArmAlign2;
+  if (IsMisaligned(instr_rva, kInstrAlign))
+    return false;
+  arm_disp_t disp;
+  ArmAlign target_align = DecodeT24(code32, &disp);
+  if (target_align == kArmAlignFail)
+    return false;
+  *target_rva = GetThumb2TargetRvaFromDisp(instr_rva, disp, target_align);
+  return true;
+}
+
+// static
+bool AArch32Rel32Translator::WriteT24(rva_t instr_rva,
+                                      rva_t target_rva,
+                                      uint32_t* code32) {
+  constexpr ArmAlign kInstrAlign = kArmAlign2;
+  if (IsMisaligned(instr_rva, kInstrAlign))
+    return false;
+  // Dummy decode to get |target_align|.
+  arm_disp_t dummy_disp;
+  ArmAlign target_align = DecodeT24(*code32, &dummy_disp);
+  if (target_align == kArmAlignFail || IsMisaligned(target_rva, target_align))
+    return false;
+  arm_disp_t disp =
+      GetThumb2DispFromTargetRva(instr_rva, target_rva, target_align);
+  return EncodeT24(disp, code32);
+}
+
+/******** AArch64Rel32Translator ********/
+
+AArch64Rel32Translator::AArch64Rel32Translator() = default;
+
+// static
+ArmAlign AArch64Rel32Translator::DecodeImmd14(uint32_t code32,
+                                              arm_disp_t* disp) {
+  // TBZ:
+  //   Code:         b0110110 bbbbbSii iiiiiiii iiittttt
+  //   Displacement: SSSSSSSS SSSSSSSS Siiiiiii iiiiii00
+  // TBNZ:
+  //   Code:         b0110111 bbbbbSii iiiiiiii iiittttt
+  //   Displacement: SSSSSSSS SSSSSSSS Siiiiiii iiiiii00
+  uint32_t bits = code32 & 0x7F000000;
+  if (bits == 0x36000000 || bits == 0x37000000) {
+    *disp = GetSignedBits<5, 18>(code32) << 2;
+    return kArmAlign4;
+  }
+  return kArmAlignFail;
+}
+
+// static
+bool AArch64Rel32Translator::EncodeImmd14(arm_disp_t disp, uint32_t* code32) {
+  uint32_t t = *code32;
+  uint32_t bits = t & 0x7F000000;
+  if (bits == 0x36000000 || bits == 0x37000000) {
+    if (disp % 4)  // Require 4-byte alignment.
+      return false;
+    if (!SignedFit<16>(disp))  // Detect overflow.
+      return false;
+    uint32_t imm14 = GetUnsignedBits<2, 15>(disp);  // ii...i.
+    t &= 0xFFF8001F;
+    t |= imm14 << 5;
+    *code32 = t;
+    return true;
+  }
+  return false;
+}
+
+// static
+bool AArch64Rel32Translator::ReadImmd14(rva_t instr_rva,
+                                        uint32_t code32,
+                                        rva_t* target_rva) {
+  constexpr ArmAlign kInstrAlign = kArmAlign4;
+  if (IsMisaligned(instr_rva, kInstrAlign))
+    return false;
+  arm_disp_t disp;
+  if (DecodeImmd14(code32, &disp) == kArmAlignFail)
+    return false;
+  *target_rva = GetTargetRvaFromDisp(instr_rva, disp);
+  return true;
+}
+
+// static
+bool AArch64Rel32Translator::WriteImmd14(rva_t instr_rva,
+                                         rva_t target_rva,
+                                         uint32_t* code32) {
+  constexpr ArmAlign kInstrAlign = kArmAlign4;
+  constexpr ArmAlign kTargetAlign = kArmAlign4;
+  if (IsMisaligned(instr_rva, kInstrAlign) ||
+      IsMisaligned(target_rva, kTargetAlign)) {
+    return false;
+  }
+  arm_disp_t disp = GetDispFromTargetRva(instr_rva, target_rva);
+  return EncodeImmd14(disp, code32);
+}
+
+// static
+ArmAlign AArch64Rel32Translator::DecodeImmd19(uint32_t code32,
+                                              arm_disp_t* disp) {
+  // B.cond:
+  //   Code:         01010100 Siiiiiii iiiiiiii iii0cccc
+  //   Displacement: SSSSSSSS SSSSiiii iiiiiiii iiiiii00
+  // CBZ:
+  //   Code:         z0110100 Siiiiiii iiiiiiii iiittttt
+  //   Displacement: SSSSSSSS SSSSiiii iiiiiiii iiiiii00
+  // CBNZ:
+  //   Code:         z0110101 Siiiiiii iiiiiiii iiittttt
+  //   Displacement: SSSSSSSS SSSSiiii iiiiiiii iiiiii00
+  uint32_t bits1 = code32 & 0xFF000010;
+  uint32_t bits2 = code32 & 0x7F000000;
+  if (bits1 == 0x54000000 || bits2 == 0x34000000 || bits2 == 0x35000000) {
+    *disp = GetSignedBits<5, 23>(code32) << 2;
+    return kArmAlign4;
+  }
+  return kArmAlignFail;
+}
+
+// static
+bool AArch64Rel32Translator::EncodeImmd19(arm_disp_t disp, uint32_t* code32) {
+  uint32_t t = *code32;
+  uint32_t bits1 = t & 0xFF000010;
+  uint32_t bits2 = t & 0x7F000000;
+  if (bits1 == 0x54000000 || bits2 == 0x34000000 || bits2 == 0x35000000) {
+    if (disp % 4)  // Require 4-byte alignment.
+      return false;
+    if (!SignedFit<21>(disp))  // Detect overflow.
+      return false;
+    uint32_t imm19 = GetUnsignedBits<2, 20>(disp);  // ii...i.
+    t &= 0xFF00001F;
+    t |= imm19 << 5;
+    *code32 = t;
+    return true;
+  }
+  return false;
+}
+
+// static
+bool AArch64Rel32Translator::ReadImmd19(rva_t instr_rva,
+                                        uint32_t code32,
+                                        rva_t* target_rva) {
+  constexpr ArmAlign kInstrAlign = kArmAlign4;
+  if (IsMisaligned(instr_rva, kInstrAlign))
+    return false;
+  arm_disp_t disp;
+  if (DecodeImmd19(code32, &disp) == kArmAlignFail)
+    return false;
+  *target_rva = GetTargetRvaFromDisp(instr_rva, disp);
+  return true;
+}
+
+// static
+bool AArch64Rel32Translator::WriteImmd19(rva_t instr_rva,
+                                         rva_t target_rva,
+                                         uint32_t* code32) {
+  constexpr ArmAlign kInstrAlign = kArmAlign4;
+  constexpr ArmAlign kTargetAlign = kArmAlign4;
+  if (IsMisaligned(instr_rva, kInstrAlign) ||
+      IsMisaligned(target_rva, kTargetAlign)) {
+    return false;
+  }
+  arm_disp_t disp = GetDispFromTargetRva(instr_rva, target_rva);
+  return EncodeImmd19(disp, code32);
+}
+
+// static
+ArmAlign AArch64Rel32Translator::DecodeImmd26(uint32_t code32,
+                                              arm_disp_t* disp) {
+  // B:
+  //   Code:         000101Si iiiiiiii iiiiiiii iiiiiiii
+  //   Displacement: SSSSSiii iiiiiiii iiiiiiii iiiiii00
+  // BL:
+  //   Code:         100101Si iiiiiiii iiiiiiii iiiiiiii
+  //   Displacement: SSSSSiii iiiiiiii iiiiiiii iiiiii00
+  uint32_t bits = code32 & 0xFC000000;
+  if (bits == 0x14000000 || bits == 0x94000000) {
+    *disp = GetSignedBits<0, 25>(code32) << 2;
+    return kArmAlign4;
+  }
+  return kArmAlignFail;
+}
+
+// static
+bool AArch64Rel32Translator::EncodeImmd26(arm_disp_t disp, uint32_t* code32) {
+  uint32_t t = *code32;
+  uint32_t bits = t & 0xFC000000;
+  if (bits == 0x14000000 || bits == 0x94000000) {
+    if (disp % 4)  // Require 4-byte alignment.
+      return false;
+    if (!SignedFit<28>(disp))  // Detect overflow.
+      return false;
+    uint32_t imm26 = GetUnsignedBits<2, 27>(disp);  // ii...i.
+    t &= 0xFC000000;
+    t |= imm26;
+    *code32 = t;
+    return true;
+  }
+  return false;
+}
+
+// static
+bool AArch64Rel32Translator::ReadImmd26(rva_t instr_rva,
+                                        uint32_t code32,
+                                        rva_t* target_rva) {
+  constexpr ArmAlign kInstrAlign = kArmAlign4;
+  if (IsMisaligned(instr_rva, kInstrAlign))
+    return false;
+  arm_disp_t disp;
+  if (DecodeImmd26(code32, &disp) == kArmAlignFail)
+    return false;
+  *target_rva = GetTargetRvaFromDisp(instr_rva, disp);
+  return true;
+}
+
+// static
+bool AArch64Rel32Translator::WriteImmd26(rva_t instr_rva,
+                                         rva_t target_rva,
+                                         uint32_t* code32) {
+  constexpr ArmAlign kInstrAlign = kArmAlign4;
+  constexpr ArmAlign kTargetAlign = kArmAlign4;
+  if (IsMisaligned(instr_rva, kInstrAlign) ||
+      IsMisaligned(target_rva, kTargetAlign)) {
+    return false;
+  }
+  arm_disp_t disp = GetDispFromTargetRva(instr_rva, target_rva);
+  return EncodeImmd26(disp, code32);
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/buffer_source.cc b/native/zucchini/vendor/zucchini/buffer_source.cc
new file mode 100644
index 0000000..d72d329
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/buffer_source.cc
@@ -0,0 +1,105 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/buffer_source.h"
+
+#include <algorithm>
+
+#include "components/zucchini/algorithm.h"
+
+namespace zucchini {
+
+BufferSource::BufferSource(ConstBufferView buffer) : ConstBufferView(buffer) {}
+
+BufferSource& BufferSource::Skip(size_type n) {
+  remove_prefix(std::min(n, Remaining()));
+  return *this;
+}
+
+bool BufferSource::CheckNextBytes(std::initializer_list<uint8_t> bytes) const {
+  if (Remaining() < bytes.size())
+    return false;
+  return std::mismatch(bytes.begin(), bytes.end(), begin()).first ==
+         bytes.end();
+}
+
+bool BufferSource::ConsumeBytes(std::initializer_list<uint8_t> bytes) {
+  if (!CheckNextBytes(bytes))
+    return false;
+  remove_prefix(bytes.size());
+  return true;
+}
+
+bool BufferSource::GetRegion(size_type count, ConstBufferView* buffer) {
+  DCHECK_NE(begin(), nullptr);
+  if (Remaining() < count)
+    return false;
+  *buffer = ConstBufferView(begin(), count);
+  remove_prefix(count);
+  return true;
+}
+
+// [0aaaaaaa] => 00000000'00000000'00000000'0aaaaaaa
+// [1aaaaaaa 0bbbbbbb] => 00000000'00000000'00bbbbbb'baaaaaaa
+// [1aaaaaaa 1bbbbbbb 0ccccccc] => 00000000'000ccccc'ccbbbbbb'baaaaaaa
+// [1aaaaaaa 1bbbbbbb 1ccccccc 0ddddddd] => 0000dddd'dddccccc'ccbbbbbb'baaaaaaa
+// [1aaaaaaa 1bbbbbbb 1ccccccc 1ddddddd 0???eeee]
+//     => eeeedddd'dddccccc'ccbbbbbb'baaaaaaa
+// Note that "???" is discarded. Meanwhile, 1???eeee is invalid.
+bool BufferSource::GetUleb128(uint32_t* ret) {
+  int shift_lim =
+      static_cast<int>(std::min<size_type>(kMaxLeb128Size, size())) * 7;
+  const_iterator cur = cbegin();
+  uint32_t value = 0U;
+  for (int shift = 0; shift < shift_lim; shift += 7, ++cur) {
+    uint32_t b = *cur;
+    // When |shift == 28|, |(b & 0x7F) << shift| discards the "???" bits.
+    value |= static_cast<uint32_t>(b & 0x7F) << shift;
+    if (!(b & 0x80)) {
+      *ret = value;
+      seek(cur + 1);
+      return true;
+    }
+  }
+  return false;
+}
+
+// [0Saaaaaa] => SSSSSSSS'SSSSSSSS'SSSSSSSS'SSaaaaaa
+// [1aaaaaaa 0Sbbbbbb] => SSSSSSSS'SSSSSSSS'SSSbbbbb'baaaaaaa
+// [1aaaaaaa 1bbbbbbb 0Scccccc] => SSSSSSSS'SSSScccc'ccbbbbbb'baaaaaaa
+// [1aaaaaaa 1bbbbbbb 1ccccccc 0Sdddddd] => SSSSSddd'dddccccc'ccbbbbbb'baaaaaaa
+// [1aaaaaaa 1bbbbbbb 1ccccccc 1ddddddd 0???Seee]
+//     => Seeedddd'dddccccc'ccbbbbbb'baaaaaaa
+// Note that "???" is discarded. Meanwhile, 1???eeee is invalid.
+bool BufferSource::GetSleb128(int32_t* ret) {
+  int shift_lim =
+      static_cast<int>(std::min<size_type>(kMaxLeb128Size, size())) * 7;
+  const_iterator cur = cbegin();
+  int32_t value = 0;
+  for (int shift = 0; shift < shift_lim; shift += 7, ++cur) {
+    uint32_t b = *cur;
+    // When |shift == 28|, |(b & 0x7F) << shift| discards the "???" bits.
+    value |= static_cast<int32_t>(static_cast<uint32_t>(b & 0x7F) << shift);
+    if (!(b & 0x80)) {
+      *ret = (shift == 28) ? value : SignExtend(shift + 6, value);
+      seek(cur + 1);
+      return true;
+    }
+  }
+  return false;
+}
+
+bool BufferSource::SkipLeb128() {
+  int lim = static_cast<int>(std::min<size_type>(kMaxLeb128Size, size()));
+  const_iterator cur = cbegin();
+  for (int i = 0; i < lim; ++i, ++cur) {
+    if (!(*cur & 0x80)) {
+      seek(cur + 1);
+      return true;
+    }
+  }
+  return false;
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/crc32.cc b/native/zucchini/vendor/zucchini/crc32.cc
new file mode 100644
index 0000000..1c45dfe
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/crc32.cc
@@ -0,0 +1,43 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/crc32.h"
+
+#include <array>
+
+#include "base/check_op.h"
+
+namespace zucchini {
+
+namespace {
+
+std::array<uint32_t, 256> MakeCrc32Table() {
+  constexpr uint32_t kCrc32Poly = 0xEDB88320;
+
+  std::array<uint32_t, 256> crc32Table;
+  for (uint32_t i = 0; i < 256; ++i) {
+    uint32_t r = i;
+    for (int j = 0; j < 8; ++j)
+      r = (r >> 1) ^ (kCrc32Poly & ~((r & 1) - 1));
+    crc32Table[i] = r;
+  }
+  return crc32Table;
+}
+
+}  // namespace
+
+// Minimalistic CRC-32 implementation for Zucchini usage. Adapted from LZMA SDK
+// (found at third_party/lzma_sdk/7zCrc.c), which is public domain.
+uint32_t CalculateCrc32(const uint8_t* first, const uint8_t* last) {
+  DCHECK_GE(last, first);
+
+  static const std::array<uint32_t, 256> kCrc32Table = MakeCrc32Table();
+
+  uint32_t ret = 0xFFFFFFFF;
+  for (; first != last; ++first)
+    ret = kCrc32Table[(ret ^ *first) & 0xFF] ^ (ret >> 8);
+  return ret ^ 0xFFFFFFFF;
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/disassembler.cc b/native/zucchini/vendor/zucchini/disassembler.cc
new file mode 100644
index 0000000..5dce221
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/disassembler.cc
@@ -0,0 +1,52 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/disassembler.h"
+
+#include "base/check_op.h"
+
+namespace zucchini {
+
+/******** EmptyReferenceReader ********/
+
+std::optional<Reference> EmptyReferenceReader::GetNext() {
+  return std::nullopt;
+}
+
+/******** EmptyReferenceWriter ********/
+
+void EmptyReferenceWriter::PutNext(Reference /* reference */) {}
+
+/******** ReferenceGroup ********/
+
+std::unique_ptr<ReferenceReader> ReferenceGroup::GetReader(
+    offset_t lower,
+    offset_t upper,
+    Disassembler* disasm) const {
+  DCHECK_LE(lower, upper);
+  DCHECK_LE(upper, disasm->size());
+  return (disasm->*reader_factory_)(lower, upper);
+}
+
+std::unique_ptr<ReferenceReader> ReferenceGroup::GetReader(
+    Disassembler* disasm) const {
+  return (disasm->*reader_factory_)(0, static_cast<offset_t>(disasm->size()));
+}
+
+std::unique_ptr<ReferenceWriter> ReferenceGroup::GetWriter(
+    MutableBufferView image,
+    Disassembler* disasm) const {
+  DCHECK_EQ(image.begin(), disasm->image().begin());
+  DCHECK_EQ(image.size(), disasm->size());
+  return (disasm->*writer_factory_)(image);
+}
+
+/******** Disassembler ********/
+
+Disassembler::Disassembler(int num_equivalence_iterations)
+    : num_equivalence_iterations_(num_equivalence_iterations) {}
+
+Disassembler::~Disassembler() = default;
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/disassembler_dex.cc b/native/zucchini/vendor/zucchini/disassembler_dex.cc
new file mode 100644
index 0000000..fe1110f
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/disassembler_dex.cc
@@ -0,0 +1,1890 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/disassembler_dex.h"
+
+#include <stddef.h>
+#include <stdlib.h>
+
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <iterator>
+#include <optional>
+#include <set>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/logging.h"
+#include "base/numerics/checked_math.h"
+#include "base/numerics/safe_conversions.h"
+#include "base/strings/stringprintf.h"
+#include "components/zucchini/buffer_source.h"
+#include "components/zucchini/buffer_view.h"
+#include "components/zucchini/io_utils.h"
+
+namespace zucchini {
+
+namespace {
+
+// A DEX item specified by an offset, if absent, has a sentinel value of 0 since
+// 0 is never a valid item offset (it points to magic at start of DEX).
+constexpr offset_t kDexSentinelOffset = 0U;
+
+// A DEX item specified by an index, if absent, has a sentinel value of
+// NO_INDEX = 0xFFFFFFFF. This is represented as an offset_t for uniformity.
+constexpr offset_t kDexSentinelIndexAsOffset = 0xFFFFFFFFU;
+
+static_assert(kDexSentinelIndexAsOffset != kInvalidOffset,
+              "Sentinel should not be confused with invalid offset.");
+
+// Size of a Dalvik instruction unit. Need to cast to signed int because
+// sizeof() gives size_t, which dominates when operated on ptrdiff_t, then
+// wrecks havoc for base::checked_cast<int16_t>().
+constexpr int kInstrUnitSize = static_cast<int>(sizeof(uint16_t));
+
+// Checks if |offset| is byte aligned to 32 bits or 4 bytes.
+bool Is32BitAligned(offset_t offset) {
+  return offset % 4 == 0;
+}
+
+// Returns a lower bound for the size of an item of type |type_item_code|.
+// - For fixed-length items (e.g., kTypeFieldIdItem) this is the exact size.
+// - For variant-length items (e.g., kTypeCodeItem), returns a value that is
+//   known to be less than the item length (e.g., header size).
+// - For items not handled by this function, returns 1 for sanity check.
+size_t GetItemBaseSize(uint16_t type_item_code) {
+  switch (type_item_code) {
+    case dex::kTypeStringIdItem:
+      return sizeof(dex::StringIdItem);
+    case dex::kTypeTypeIdItem:
+      return sizeof(dex::TypeIdItem);
+    case dex::kTypeProtoIdItem:
+      return sizeof(dex::ProtoIdItem);
+    case dex::kTypeFieldIdItem:
+      return sizeof(dex::FieldIdItem);
+    case dex::kTypeMethodIdItem:
+      return sizeof(dex::MethodIdItem);
+    case dex::kTypeClassDefItem:
+      return sizeof(dex::ClassDefItem);
+    case dex::kTypeCallSiteIdItem:
+      return sizeof(dex::CallSiteIdItem);
+    case dex::kTypeMethodHandleItem:
+      return sizeof(dex::MethodHandleItem);
+    // No need to handle dex::kTypeMapList.
+    case dex::kTypeTypeList:
+      return sizeof(uint32_t);  // Variable-length.
+    case dex::kTypeAnnotationSetRefList:
+      return sizeof(uint32_t);  // Variable-length.
+    case dex::kTypeAnnotationSetItem:
+      return sizeof(uint32_t);  // Variable-length.
+    case dex::kTypeCodeItem:
+      return sizeof(dex::CodeItem);  // Variable-length.
+    case dex::kTypeAnnotationsDirectoryItem:
+      return sizeof(dex::AnnotationsDirectoryItem);  // Variable-length.
+    default:
+      return 1U;  // Unhandled item. For sanity check assume size >= 1.
+  }
+}
+
+/******** CodeItemParser ********/
+
+// A parser to extract successive code items from a DEX image whose header has
+// been parsed.
+class CodeItemParser {
+ public:
+  using size_type = BufferSource::size_type;
+
+  explicit CodeItemParser(ConstBufferView image) : image_(image) {}
+
+  // Initializes the parser, returns true on success and false on error.
+  bool Init(const dex::MapItem& code_map_item) {
+    // Sanity check to quickly fail if |code_map_item.offset| or
+    // |code_map_item.size| is too large. This is a heuristic because code item
+    // sizes need to be parsed (sizeof(dex::CodeItem) is a lower bound).
+    if (!image_.covers_array(code_map_item.offset, code_map_item.size,
+                             sizeof(dex::CodeItem))) {
+      return false;
+    }
+    source_ = std::move(BufferSource(image_).Skip(code_map_item.offset));
+    return true;
+  }
+
+  // Extracts the header of the next code item, and skips the variable-length
+  // data. Returns the offset of the code item if successful. Otherwise returns
+  // kInvalidOffset, and thereafter the parser becomes valid. For reference,
+  // here's a pseudo-struct of a complete code item:
+  //
+  // struct code_item {
+  //   // 4-byte aligned here.
+  //   // 16-byte header defined (dex::CodeItem).
+  //   uint16_t registers_size;
+  //   uint16_t ins_size;
+  //   uint16_t outs_size;
+  //   uint16_t tries_size;
+  //   uint32_t debug_info_off;
+  //   uint32_t insns_size;
+  //
+  //   // Variable-length data follow.
+  //   uint16_t insns[insns_size];  // Instruction bytes.
+  //   uint16_t padding[(tries_size > 0 && insns_size % 2 == 1) ? 1 : 0];
+  //
+  //   if (tries_size > 0) {
+  //     // 4-byte aligned here.
+  //     struct try_item {  // dex::TryItem.
+  //       uint32_t start_addr;
+  //       uint16_t insn_count;
+  //       uint16_t handler_off;
+  //     } tries[tries_size];
+  //
+  //     struct encoded_catch_handler_list {
+  //       uleb128 handlers_size;
+  //       struct encoded_catch_handler {
+  //         sleb128 encoded_catch_handler_size;
+  //         struct encoded_type_addr_pair {
+  //           uleb128 type_idx;
+  //           uleb128 addr;
+  //         } handlers[abs(encoded_catch_handler_size)];
+  //         if (encoded_catch_handler_size <= 0) {
+  //           uleb128 catch_all_addr;
+  //         }
+  //       } handlers_list[handlers_size];
+  //     } handlers_group;  // Confusingly called "handlers" in DEX doc.
+  //   }
+  //
+  //   // Padding to 4-bytes align next code_item *only if more exist*.
+  // }
+  offset_t GetNext() {
+    // Read header CodeItem.
+    if (!source_.AlignOn(image_, 4U))
+      return kInvalidOffset;
+    const offset_t code_item_offset =
+        base::checked_cast<offset_t>(source_.begin() - image_.begin());
+    const auto* code_item = source_.GetPointer<const dex::CodeItem>();
+    if (!code_item)
+      return kInvalidOffset;
+    DCHECK(Is32BitAligned(code_item_offset));
+
+    // TODO(huangs): Fail if |code_item->insns_size == 0| (Constraint A1).
+    // Skip instruction bytes.
+    if (!source_.GetArray<uint16_t>(code_item->insns_size))
+      return kInvalidOffset;
+    // Skip padding if present.
+    if (code_item->tries_size > 0 && !source_.AlignOn(image_, 4U))
+      return kInvalidOffset;
+
+    // Skip tries[] and handlers_group to arrive at the next code item. Parsing
+    // is nontrivial due to use of uleb128 / sleb128.
+    if (code_item->tries_size > 0) {
+      // Skip (try_item) tries[].
+      if (!source_.GetArray<dex::TryItem>(code_item->tries_size))
+        return kInvalidOffset;
+
+      // Skip handlers_group.
+      uint32_t handlers_size = 0;
+      if (!source_.GetUleb128(&handlers_size))
+        return kInvalidOffset;
+      // Sanity check to quickly reject excessively large |handlers_size|.
+      if (source_.Remaining() < static_cast<size_type>(handlers_size))
+        return kInvalidOffset;
+
+      // Skip (encoded_catch_handler) handlers_list[].
+      for (uint32_t k = 0; k < handlers_size; ++k) {
+        int32_t encoded_catch_handler_size = 0;
+        if (!source_.GetSleb128(&encoded_catch_handler_size))
+          return kInvalidOffset;
+        const size_type abs_size = std::abs(encoded_catch_handler_size);
+        if (source_.Remaining() < abs_size)  // Sanity check.
+          return kInvalidOffset;
+        // Skip (encoded_type_addr_pair) handlers[].
+        for (size_type j = 0; j < abs_size; ++j) {
+          if (!source_.SkipLeb128() || !source_.SkipLeb128())
+            return kInvalidOffset;
+        }
+        // Skip catch_all_addr.
+        if (encoded_catch_handler_size <= 0) {
+          if (!source_.SkipLeb128())
+            return kInvalidOffset;
+        }
+      }
+    }
+    // Success! |code_item->insns_size| is validated, but its content is still
+    // considered unsafe and requires validation.
+    return code_item_offset;
+  }
+
+  // Given |code_item_offset| that points to the start of a valid code item in
+  // |image|, returns |insns| bytes as ConstBufferView.
+  static ConstBufferView GetCodeItemInsns(ConstBufferView image,
+                                          offset_t code_item_offset) {
+    BufferSource source(BufferSource(image).Skip(code_item_offset));
+    const auto* code_item = source.GetPointer<const dex::CodeItem>();
+    DCHECK(code_item);
+    BufferRegion insns{0, code_item->insns_size * kInstrUnitSize};
+    DCHECK(source.covers(insns));
+    return source[insns];
+  }
+
+ private:
+  ConstBufferView image_;
+  BufferSource source_;
+};
+
+/******** InstructionParser ********/
+
+// A class that successively reads |code_item| for Dalvik instructions, which
+// are found at |insns|, spanning |insns_size| uint16_t "units". These units
+// store instructions followed by optional non-instruction "payload". Finding
+// payload boundary requires parsing: On finding an instruction that uses (and
+// points to) payload, the boundary is updated.
+class InstructionParser {
+ public:
+  struct Value {
+    offset_t instr_offset;
+    const dex::Instruction* instr = nullptr;  // null for unknown instructions.
+  };
+
+  // Returns pointer to DEX Instruction data for |opcode|, or null if |opcode|
+  // is unknown. An internal initialize-on-first-use table is used for fast
+  // lookup.
+  const dex::Instruction* FindDalvikInstruction(uint8_t opcode) {
+    static bool is_init = false;
+    static const dex::Instruction* instruction_table[256];
+    if (!is_init) {
+      is_init = true;
+      std::fill(std::begin(instruction_table), std::end(instruction_table),
+                nullptr);
+      for (const dex::Instruction& instr : dex::kByteCode) {
+        std::fill(instruction_table + instr.opcode,
+                  instruction_table + instr.opcode + instr.variant, &instr);
+      }
+    }
+    return instruction_table[opcode];
+  }
+
+  InstructionParser() = default;
+
+  InstructionParser(ConstBufferView image, offset_t base_offset)
+      : image_begin_(image.begin()),
+        insns_(CodeItemParser::GetCodeItemInsns(image, base_offset)),
+        payload_boundary_(insns_.end()) {}
+
+  // Reads the next instruction. On success, makes the data read available via
+  // value() and returns true. Otherwise (done or found error) returns false.
+  bool ReadNext() {
+    // Do not scan past payload boundary.
+    if (insns_.begin() >= payload_boundary_)
+      return false;
+
+    const offset_t instr_offset =
+        base::checked_cast<offset_t>(insns_.begin() - image_begin_);
+    const uint8_t op = insns_.read<uint8_t>(0);
+    const dex::Instruction* instr = FindDalvikInstruction(op);
+
+    // Stop on finding unknown instructions. ODEX files might trigger this.
+    if (!instr) {
+      LOG(WARNING) << "Unknown Dalvik instruction detected at "
+                   << AsHex<8>(instr_offset) << ".";
+      return false;
+    }
+
+    const int instr_length_units = instr->layout;
+    const size_t instr_length_bytes = instr_length_units * kInstrUnitSize;
+    if (insns_.size() < instr_length_bytes)
+      return false;
+
+    // Handle instructions with variable-length data payload (31t).
+    if (instr->opcode == 0x26 ||  // fill-array-data
+        instr->opcode == 0x2B ||  // packed-switch
+        instr->opcode == 0x2C) {  // sparse-switch
+      const int32_t unsafe_payload_rel_units = insns_.read<int32_t>(2);
+      // Payload must be in current code item, after current instruction.
+      if (unsafe_payload_rel_units < instr_length_units ||
+          static_cast<uint32_t>(unsafe_payload_rel_units) >=
+              insns_.size() / kInstrUnitSize) {
+        LOG(WARNING) << "Invalid payload found.";
+        return false;
+      }
+      // Update boundary between instructions and payload.
+      const ConstBufferView::const_iterator payload_it =
+          insns_.begin() + unsafe_payload_rel_units * kInstrUnitSize;
+      payload_boundary_ = std::min(payload_boundary_, payload_it);
+    }
+
+    insns_.remove_prefix(instr_length_bytes);
+    value_ = {instr_offset, instr};
+    return true;
+  }
+
+  const Value& value() const { return value_; }
+
+ private:
+  ConstBufferView::const_iterator image_begin_;
+  ConstBufferView insns_;
+  ConstBufferView::const_iterator payload_boundary_;
+  Value value_;
+};
+
+/******** InstructionReferenceReader ********/
+
+// A class to visit |code_items|, parse instructions, and emit embedded
+// References of a type determined by |filter_| and |mapper_|. Only References
+// located in |[lo, hi)| are emitted. |lo| and |hi| are assumed to never
+// straddle the body of a Reference.
+class InstructionReferenceReader : public ReferenceReader {
+ public:
+  // A function that takes a parsed Dalvik instruction and decides whether it
+  // contains a specific type of Reference. If true, then returns the Reference
+  // location. Otherwise returns kInvalidOffset.
+  using Filter =
+      base::RepeatingCallback<offset_t(const InstructionParser::Value&)>;
+  // A function that takes Reference location from |filter_| to extract the
+  // stored target. If valid, returns it. Otherwise returns kInvalidOffset.
+  using Mapper = base::RepeatingCallback<offset_t(offset_t)>;
+
+  InstructionReferenceReader(ConstBufferView image,
+                             offset_t lo,
+                             offset_t hi,
+                             const std::vector<offset_t>& code_item_offsets,
+                             Filter&& filter,
+                             Mapper&& mapper)
+      : image_(image),
+        lo_(lo),
+        hi_(hi),
+        end_it_(code_item_offsets.end()),
+        filter_(std::move(filter)),
+        mapper_(std::move(mapper)) {
+    const auto begin_it = code_item_offsets.begin();
+    // Use binary search to find the code item that contains |lo_|.
+    auto comp = [](offset_t test_offset, offset_t code_item_offset) {
+      return test_offset < code_item_offset;
+    };
+    cur_it_ = std::upper_bound(begin_it, end_it_, lo_, comp);
+    if (cur_it_ != begin_it)
+      --cur_it_;
+    parser_ = InstructionParser(image_, *cur_it_);
+  }
+
+  // ReferenceReader:
+  std::optional<Reference> GetNext() override {
+    while (true) {
+      while (parser_.ReadNext()) {
+        const auto& v = parser_.value();
+        DCHECK_NE(v.instr, nullptr);
+        if (v.instr_offset >= hi_)
+          return std::nullopt;
+        const offset_t location = filter_.Run(v);
+        if (location == kInvalidOffset || location < lo_)
+          continue;
+        // The general check is |location + reference_width > hi_|. However, by
+        // assumption |hi_| and |lo_| do not straddle the body of a Reference.
+        // So |reference_width| is unneeded.
+        if (location >= hi_)
+          return std::nullopt;
+        offset_t target = mapper_.Run(location);
+        if (target != kInvalidOffset)
+          return Reference{location, target};
+        else
+          LOG(WARNING) << "Invalid target at " << AsHex<8>(location) << ".";
+      }
+      ++cur_it_;
+      if (cur_it_ == end_it_)
+        return std::nullopt;
+      parser_ = InstructionParser(image_, *cur_it_);
+    }
+  }
+
+ private:
+  const ConstBufferView image_;
+  const offset_t lo_;
+  const offset_t hi_;
+  const std::vector<offset_t>::const_iterator end_it_;
+  const Filter filter_;
+  const Mapper mapper_;
+  std::vector<offset_t>::const_iterator cur_it_;
+  InstructionParser parser_;
+};
+
+/******** ItemReferenceReader ********/
+
+// A class to visit fixed-size item elements (determined by |item_size|) and
+// emit a "member variable of interest" (MVI, determined by |rel_location| and
+// |mapper|) as Reference. Only MVIs lying in |[lo, hi)| are emitted. |lo| and
+// |hi| are assumed to never straddle the body of a Reference.
+class ItemReferenceReader : public ReferenceReader {
+ public:
+  // A function that takes an MVI's location and emit its target offset.
+  using Mapper = base::RepeatingCallback<offset_t(offset_t)>;
+
+  // |item_size| is the size of a fixed-size item. |rel_location| is the
+  // relative location of MVI from the start of the item containing it.
+  // |rel_item_offset| is the offset to use relative to |item_offset| in cases
+  // where a value other than |rel_location| is required. For an example of this
+  // see ReadMethodHandleFieldOrMethodId.
+  ItemReferenceReader(offset_t lo,
+                      offset_t hi,
+                      const dex::MapItem& map_item,
+                      size_t item_size,
+                      size_t rel_location,
+                      Mapper&& mapper,
+                      bool mapper_wants_item = false)
+      : hi_(hi),
+        item_base_offset_(base::checked_cast<offset_t>(map_item.offset)),
+        num_items_(base::checked_cast<uint32_t>(map_item.size)),
+        item_size_(base::checked_cast<uint32_t>(item_size)),
+        rel_location_(base::checked_cast<uint32_t>(rel_location)),
+        mapper_input_delta_(
+            mapper_wants_item ? 0 : base::checked_cast<uint32_t>(rel_location)),
+        mapper_(std::move(mapper)) {
+    static_assert(sizeof(decltype(map_item.offset)) <= sizeof(offset_t),
+                  "map_item.offset too large.");
+    static_assert(sizeof(decltype(map_item.size)) <= sizeof(offset_t),
+                  "map_item.size too large.");
+    if (!item_base_offset_) {
+      // Empty item: Assign |cur_idx| to |num_items_| to skip everything.
+      cur_idx_ = num_items_;
+    } else if (lo < item_base_offset_) {
+      cur_idx_ = 0;
+    } else if (lo < OffsetOfIndex(num_items_)) {
+      cur_idx_ = (lo - item_base_offset_) / item_size_;
+      // Fine-tune: Advance if |lo| lies beyond the MVI.
+      if (lo > OffsetOfIndex(cur_idx_) + rel_location_)
+        ++cur_idx_;
+    } else {
+      cur_idx_ = num_items_;
+    }
+  }
+
+  // ReferenceReader:
+  std::optional<Reference> GetNext() override {
+    while (cur_idx_ < num_items_) {
+      const offset_t item_offset = OffsetOfIndex(cur_idx_);
+      const offset_t location = item_offset + rel_location_;
+      // The general check is |location + reference_width > hi_|. However, by
+      // assumption |hi_| and |lo_| do not straddle the body of a Reference. So
+      // |reference_width| is unneeded.
+      if (location >= hi_)
+        break;
+
+      // |location == item_offset + mapper_input_delta_| in the majority of
+      // cases. The exception is when |mapper_| wants an item aligned location
+      // instead e.g. ReadMethodHandleFieldOrMethodId.
+      const offset_t target = mapper_.Run(item_offset + mapper_input_delta_);
+
+      // kDexSentinelOffset (0) may appear for the following:
+      // - ProtoIdItem: parameters_off.
+      // - ClassDefItem: interfaces_off, annotations_off, class_data_off,
+      //   static_values_off.
+      // - AnnotationsDirectoryItem: class_annotations_off.
+      // - AnnotationSetRefItem: annotations_off.
+      // kDexSentinelIndexAsOffset (0xFFFFFFFF) may appear for the following:
+      // - ClassDefItem: superclass_idx, source_file_idx.
+      // - MethodHandleItem: |mapper_| uses ReadMethodHandleFieldOrMethodId and
+      //   determines the item at |cur_idx_| is not of the required reference
+      //   type.
+      if (target == kDexSentinelOffset || target == kDexSentinelIndexAsOffset) {
+        ++cur_idx_;
+        continue;
+      }
+
+      if (target == kInvalidOffset) {
+        LOG(WARNING) << "Invalid item target at " << AsHex<8>(location) << ".";
+        break;
+      }
+      ++cur_idx_;
+      return Reference{location, target};
+    }
+    return std::nullopt;
+  }
+
+ private:
+  offset_t OffsetOfIndex(uint32_t idx) {
+    return base::checked_cast<uint32_t>(item_base_offset_ + idx * item_size_);
+  }
+
+  const offset_t hi_;
+  const offset_t item_base_offset_;
+  const uint32_t num_items_;
+  const uint32_t item_size_;
+  const uint32_t rel_location_;
+  const uint32_t mapper_input_delta_;
+  const Mapper mapper_;
+  offset_t cur_idx_ = 0;
+};
+
+// Parses a flattened jagged list of lists of items that looks like:
+//   NTTT|NTT|NTTTT|N|NTT...
+// where |N| is an uint32_t representing the number of items in each sub-list,
+// and "T" is a fixed-size item (|item_width|) of type "T". On success, stores
+// the offset of each |T| into |item_offsets|, and returns true. Otherwise
+// (e.g., on finding any structural problem) returns false.
+bool ParseItemOffsets(ConstBufferView image,
+                      const dex::MapItem& map_item,
+                      size_t item_width,
+                      std::vector<offset_t>* item_offsets) {
+  // Sanity check: |image| should at least fit |map_item.size| copies of "N".
+  if (!image.covers_array(map_item.offset, map_item.size, sizeof(uint32_t)))
+    return false;
+  BufferSource source = std::move(BufferSource(image).Skip(map_item.offset));
+  item_offsets->clear();
+  for (uint32_t i = 0; i < map_item.size; ++i) {
+    if (!source.AlignOn(image, 4U))
+      return false;
+    uint32_t unsafe_size;
+    if (!source.GetValue<uint32_t>(&unsafe_size))
+      return false;
+    DCHECK(Is32BitAligned(
+        base::checked_cast<offset_t>(source.begin() - image.begin())));
+    if (!source.covers_array(0, unsafe_size, item_width))
+      return false;
+    for (uint32_t j = 0; j < unsafe_size; ++j) {
+      item_offsets->push_back(
+          base::checked_cast<offset_t>(source.begin() - image.begin()));
+      source.Skip(item_width);
+    }
+  }
+  return true;
+}
+
+// Parses AnnotationDirectoryItems of the format (using RegEx) "(AF*M*P*)*",
+// where:
+//   A = AnnotationsDirectoryItem (contains class annotation),
+//   F = FieldAnnotation,
+//   M = MethodAnnotation,
+//   P = ParameterAnnotation.
+// On success, stores the offsets of each class, field, method and parameter
+// annotation for each item into |*_annotation_offsets|. Otherwise on finding
+// structural issues returns false.
+bool ParseAnnotationsDirectoryItems(
+    ConstBufferView image,
+    const dex::MapItem& annotations_directory_map_item,
+    std::vector<offset_t>* annotations_directory_item_offsets,
+    std::vector<offset_t>* field_annotation_offsets,
+    std::vector<offset_t>* method_annotation_offsets,
+    std::vector<offset_t>* parameter_annotation_offsets) {
+  // Sanity check: |image| should at least fit
+  // |annotations_directory_map_item.size| copies of "A".
+  if (!image.covers_array(annotations_directory_map_item.offset,
+                          annotations_directory_map_item.size,
+                          sizeof(dex::AnnotationsDirectoryItem))) {
+    return false;
+  }
+  BufferSource source = std::move(
+      BufferSource(image).Skip(annotations_directory_map_item.offset));
+  annotations_directory_item_offsets->clear();
+  field_annotation_offsets->clear();
+  method_annotation_offsets->clear();
+  parameter_annotation_offsets->clear();
+
+  // Helper to process sublists.
+  auto parse_list = [&source, image](uint32_t unsafe_size, size_t item_width,
+                                     std::vector<offset_t>* item_offsets) {
+    DCHECK(Is32BitAligned(
+        base::checked_cast<offset_t>(source.begin() - image.begin())));
+    if (!source.covers_array(0, unsafe_size, item_width))
+      return false;
+    item_offsets->reserve(item_offsets->size() + unsafe_size);
+    for (uint32_t i = 0; i < unsafe_size; ++i) {
+      item_offsets->push_back(
+          base::checked_cast<offset_t>(source.begin() - image.begin()));
+      source.Skip(item_width);
+    }
+    return true;
+  };
+
+  annotations_directory_item_offsets->reserve(
+      annotations_directory_map_item.size);
+  for (uint32_t i = 0; i < annotations_directory_map_item.size; ++i) {
+    if (!source.AlignOn(image, 4U))
+      return false;
+    // Parse header.
+    annotations_directory_item_offsets->push_back(
+        base::checked_cast<offset_t>(source.begin() - image.begin()));
+    dex::AnnotationsDirectoryItem unsafe_annotations_directory_item;
+    if (!source.GetValue(&unsafe_annotations_directory_item))
+      return false;
+    // Parse sublists.
+    if (!(parse_list(unsafe_annotations_directory_item.fields_size,
+                     sizeof(dex::FieldAnnotation), field_annotation_offsets) &&
+          parse_list(unsafe_annotations_directory_item.annotated_methods_size,
+                     sizeof(dex::MethodAnnotation),
+                     method_annotation_offsets) &&
+          parse_list(
+              unsafe_annotations_directory_item.annotated_parameters_size,
+              sizeof(dex::ParameterAnnotation),
+              parameter_annotation_offsets))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/******** CachedItemListReferenceReader ********/
+
+// A class that takes sorted |item_offsets|, and emits all member variable of
+// interest (MVIs) that fall inside |[lo, hi)|. The MVI of each item has
+// location of |rel_location| from item offset, and has target extracted with
+// |mapper| (which performs validation). By the "atomicity assumption",
+// [|lo, hi)| never cut across an MVI.
+class CachedItemListReferenceReader : public ReferenceReader {
+ public:
+  // A function that takes an MVI's location and emit its target offset.
+  using Mapper = base::RepeatingCallback<offset_t(offset_t)>;
+
+  CachedItemListReferenceReader(offset_t lo,
+                                offset_t hi,
+                                uint32_t rel_location,
+                                const std::vector<offset_t>& item_offsets,
+                                Mapper&& mapper)
+      : hi_(hi),
+        rel_location_(rel_location),
+        end_it_(item_offsets.cend()),
+        mapper_(mapper) {
+    cur_it_ = std::upper_bound(item_offsets.cbegin(), item_offsets.cend(), lo);
+    // Adding |rel_location_| is necessary as references can be offset from the
+    // start of the item.
+    if (cur_it_ != item_offsets.begin() && *(cur_it_ - 1) + rel_location_ >= lo)
+      --cur_it_;
+  }
+  CachedItemListReferenceReader(const CachedItemListReferenceReader&) = delete;
+  const CachedItemListReferenceReader& operator=(
+      const CachedItemListReferenceReader&) = delete;
+
+  // ReferenceReader:
+  std::optional<Reference> GetNext() override {
+    while (cur_it_ < end_it_) {
+      const offset_t location = *cur_it_ + rel_location_;
+      if (location >= hi_)  // Check is simplified by atomicity assumption.
+        break;
+      const offset_t target = mapper_.Run(location);
+      if (target == kInvalidOffset) {
+        LOG(WARNING) << "Invalid item target at " << AsHex<8>(location) << ".";
+        break;
+      }
+      ++cur_it_;
+
+      // kDexSentinelOffset is a sentinel for;
+      // - AnnotationsDirectoryItem: class_annotations_off
+      if (target == kDexSentinelOffset)
+        continue;
+      return Reference{location, target};
+    }
+    return std::nullopt;
+  }
+
+ private:
+  const offset_t hi_;
+  const uint32_t rel_location_;
+  const std::vector<offset_t>::const_iterator end_it_;
+  const Mapper mapper_;
+  std::vector<offset_t>::const_iterator cur_it_;
+};
+
+// Reads an INT index at |location| in |image| and translates the index to the
+// offset of a fixed-size item specified by |target_map_item| and
+// |target_item_size|. Returns the target offset if valid, or kInvalidOffset
+// otherwise. This is compatible with
+// CachedReferenceListReferenceReader::Mapper,
+// InstructionReferenceReader::Mapper, and ItemReferenceReader::Mapper.
+template <typename INT>
+static offset_t ReadTargetIndex(ConstBufferView image,
+                                const dex::MapItem& target_map_item,
+                                size_t target_item_size,
+                                offset_t location) {
+  static_assert(sizeof(INT) <= sizeof(offset_t),
+                "INT may not fit into offset_t.");
+  const offset_t unsafe_idx = image.read<INT>(location);
+  // kDexSentinalIndexAsOffset (0xFFFFFFFF) is a sentinel for
+  // - ClassDefItem: superclass_idx, source_file_idx.
+  if (unsafe_idx == kDexSentinelIndexAsOffset)
+    return unsafe_idx;
+  if (unsafe_idx >= target_map_item.size)
+    return kInvalidOffset;
+  return target_map_item.offset +
+         base::checked_cast<offset_t>(unsafe_idx * target_item_size);
+}
+
+// Reads a field or method index of the MethodHandleItem located at |location|
+// in |image| and translates |method_handle_item.field_or_method_id| to the
+// offset of a fixed-size item specified by |target_map_item| and
+// |target_item_size|. The index is deemed to be of the correct target type if
+// |method_handle_item.method_handle_type| falls within the range [|min_type|,
+// |max_type|]. If the target type is correct ReadTargetIndex is called.
+// Returns the target offset if valid, or kDexSentinelIndexAsOffset if
+// |method_handle_item.method_handle_type| is of the wrong type, or
+// kInvalidOffset otherwise.
+//
+// As of DEX version 39 MethodHandleType values for FieldId and MethodId each
+// form one consecutive block of values. If this changes, then the interface to
+// this function will need to be redesigned.
+static offset_t ReadMethodHandleFieldOrMethodId(
+    ConstBufferView image,
+    const dex::MapItem& target_map_item,
+    size_t target_item_size,
+    dex::MethodHandleType min_type,
+    dex::MethodHandleType max_type,
+    offset_t location) {
+  dex::MethodHandleItem method_handle_item =
+      image.read<dex::MethodHandleItem>(location);
+
+  // Cannot use base::checked_cast as dex::MethodHandleType is an enum class so
+  // static_assert on the size instead.
+  static_assert(sizeof(decltype(dex::MethodHandleItem::method_handle_type)) <=
+                    sizeof(dex::MethodHandleType),
+                "dex::MethodHandleItem::method_handle_type may not fit into "
+                "dex::MethodHandleType.");
+  dex::MethodHandleType method_handle_type =
+      static_cast<dex::MethodHandleType>(method_handle_item.method_handle_type);
+
+  if (method_handle_type >= dex::MethodHandleType::kMaxMethodHandleType) {
+    return kInvalidOffset;
+  }
+
+  // Use DexSentinelIndexAsOffset to skip the item as it isn't of the
+  // corresponding method handle type.
+  if (method_handle_type < min_type || method_handle_type > max_type) {
+    return kDexSentinelIndexAsOffset;
+  }
+
+  return ReadTargetIndex<decltype(dex::MethodHandleItem::field_or_method_id)>(
+      image, target_map_item, target_item_size,
+      location + offsetof(dex::MethodHandleItem, field_or_method_id));
+}
+
+// Reads uint32_t value in |image| at (valid) |location| and checks whether it
+// is a safe offset of a fixed-size item. Returns the target offset (possibly a
+// sentinel) if valid, or kInvalidOffset otherwise. This is compatible with
+// CachedReferenceListReferenceReader::Mapper,
+// InstructionReferenceReader::Mapper, and ItemReferenceReader::Mapper.
+static offset_t ReadTargetOffset32(ConstBufferView image, offset_t location) {
+  const offset_t unsafe_target =
+      static_cast<offset_t>(image.read<uint32_t>(location));
+  // Skip and don't validate kDexSentinelOffset as it is indicative of an
+  // empty reference.
+  if (unsafe_target == kDexSentinelOffset)
+    return unsafe_target;
+
+  // TODO(huangs): Check that |unsafe_target| is within the correct data
+  // section.
+  if (unsafe_target >= image.size())
+    return kInvalidOffset;
+  return unsafe_target;
+}
+
+/******** ReferenceWriterAdaptor ********/
+
+// A ReferenceWriter that adapts a callback that performs type-specific
+// Reference writes.
+class ReferenceWriterAdaptor : public ReferenceWriter {
+ public:
+  using Writer = base::RepeatingCallback<void(Reference, MutableBufferView)>;
+
+  ReferenceWriterAdaptor(MutableBufferView image, Writer&& writer)
+      : image_(image), writer_(std::move(writer)) {}
+
+  // ReferenceWriter:
+  void PutNext(Reference ref) override { writer_.Run(ref, image_); }
+
+ private:
+  MutableBufferView image_;
+  Writer writer_;
+};
+
+// Helper that's compatible with ReferenceWriterAdaptor::Writer.
+// Given that |ref.target| points to the start of a fixed size DEX item (e.g.,
+// FieldIdItem), translates |ref.target| to item index, and writes the result to
+// |ref.location| as |INT|.
+template <typename INT>
+static void WriteTargetIndex(const dex::MapItem& target_map_item,
+                             size_t target_item_size,
+                             Reference ref,
+                             MutableBufferView image) {
+  const size_t unsafe_idx =
+      (ref.target - target_map_item.offset) / target_item_size;
+  // Verify that index is within bound.
+  if (unsafe_idx >= target_map_item.size) {
+    LOG(ERROR) << "Target index out of bounds at: " << AsHex<8>(ref.location)
+               << ".";
+    return;
+  }
+  // Verify that |ref.target| points to start of item.
+  DCHECK_EQ(ref.target, target_map_item.offset + unsafe_idx * target_item_size);
+  image.write<INT>(ref.location, base::checked_cast<INT>(unsafe_idx));
+}
+
+// Buffer for ReadDexHeader() to optionally return results.
+struct ReadDexHeaderResults {
+  BufferSource source;
+  const dex::HeaderItem* header;
+  int dex_version;
+};
+
+// Returns whether |image| points to a DEX file. If this is a possibility and
+// |opt_results| is not null, then uses it to pass extracted data to enable
+// further parsing.
+bool ReadDexHeader(ConstBufferView image, ReadDexHeaderResults* opt_results) {
+  // This part needs to be fairly efficient since it may be called many times.
+  BufferSource source(image);
+  const dex::HeaderItem* header = source.GetPointer<dex::HeaderItem>();
+  if (!header)
+    return false;
+  if (header->magic[0] != 'd' || header->magic[1] != 'e' ||
+      header->magic[2] != 'x' || header->magic[3] != '\n' ||
+      header->magic[7] != '\0') {
+    return false;
+  }
+
+  // Magic matches: More detailed tests can be conducted.
+  int dex_version = 0;
+  for (int i = 4; i < 7; ++i) {
+    if (!isdigit(header->magic[i]))
+      return false;
+    dex_version = dex_version * 10 + (header->magic[i] - '0');
+  }
+
+  // Only support DEX versions 35, 37, 38, and 39
+  if (dex_version != 35 && dex_version != 37 && dex_version != 38 &&
+      dex_version != 39) {
+    return false;
+  }
+
+  if (header->file_size > image.size() ||
+      header->file_size < sizeof(dex::HeaderItem) ||
+      header->map_off < sizeof(dex::HeaderItem)) {
+    return false;
+  }
+
+  if (opt_results)
+    *opt_results = {source, header, dex_version};
+  return true;
+}
+
+}  // namespace
+
+/******** DisassemblerDex ********/
+
+DisassemblerDex::DisassemblerDex() : Disassembler(4) {}
+
+DisassemblerDex::~DisassemblerDex() = default;
+
+// static.
+bool DisassemblerDex::QuickDetect(ConstBufferView image) {
+  return ReadDexHeader(image, nullptr);
+}
+
+ExecutableType DisassemblerDex::GetExeType() const {
+  return kExeTypeDex;
+}
+
+std::string DisassemblerDex::GetExeTypeString() const {
+  return base::StringPrintf("DEX (version %d)", dex_version_);
+}
+
+std::vector<ReferenceGroup> DisassemblerDex::MakeReferenceGroups() const {
+  // Must follow DisassemblerDex::ReferenceType order. Initialized on first use.
+  return {
+      {{4, TypeTag(kTypeIdToDescriptorStringId), PoolTag(kStringId)},
+       &DisassemblerDex::MakeReadTypeIdToDescriptorStringId32,
+       &DisassemblerDex::MakeWriteStringId32},
+      {{4, TypeTag(kProtoIdToShortyStringId), PoolTag(kStringId)},
+       &DisassemblerDex::MakeReadProtoIdToShortyStringId32,
+       &DisassemblerDex::MakeWriteStringId32},
+      {{4, TypeTag(kFieldIdToNameStringId), PoolTag(kStringId)},
+       &DisassemblerDex::MakeReadFieldToNameStringId32,
+       &DisassemblerDex::MakeWriteStringId32},
+      {{4, TypeTag(kMethodIdToNameStringId), PoolTag(kStringId)},
+       &DisassemblerDex::MakeReadMethodIdToNameStringId32,
+       &DisassemblerDex::MakeWriteStringId32},
+      {{4, TypeTag(kClassDefToSourceFileStringId), PoolTag(kStringId)},
+       &DisassemblerDex::MakeReadClassDefToSourceFileStringId32,
+       &DisassemblerDex::MakeWriteStringId32},
+      {{2, TypeTag(kCodeToStringId16), PoolTag(kStringId)},
+       &DisassemblerDex::MakeReadCodeToStringId16,
+       &DisassemblerDex::MakeWriteStringId16},
+      {{4, TypeTag(kCodeToStringId32), PoolTag(kStringId)},
+       &DisassemblerDex::MakeReadCodeToStringId32,
+       &DisassemblerDex::MakeWriteStringId32},
+      {{4, TypeTag(kProtoIdToReturnTypeId), PoolTag(kTypeId)},
+       &DisassemblerDex::MakeReadProtoIdToReturnTypeId32,
+       &DisassemblerDex::MakeWriteTypeId32},
+      {{2, TypeTag(kFieldIdToClassTypeId), PoolTag(kTypeId)},
+       &DisassemblerDex::MakeReadFieldToClassTypeId16,
+       &DisassemblerDex::MakeWriteTypeId16},
+      {{2, TypeTag(kFieldIdToTypeId), PoolTag(kTypeId)},
+       &DisassemblerDex::MakeReadFieldToTypeId16,
+       &DisassemblerDex::MakeWriteTypeId16},
+      {{2, TypeTag(kMethodIdToClassTypeId), PoolTag(kTypeId)},
+       &DisassemblerDex::MakeReadMethodIdToClassTypeId16,
+       &DisassemblerDex::MakeWriteTypeId16},
+      {{4, TypeTag(kClassDefToClassTypeId), PoolTag(kTypeId)},
+       &DisassemblerDex::MakeReadClassDefToClassTypeId32,
+       &DisassemblerDex::MakeWriteTypeId32},
+      {{4, TypeTag(kClassDefToSuperClassTypeId), PoolTag(kTypeId)},
+       &DisassemblerDex::MakeReadClassDefToSuperClassTypeId32,
+       &DisassemblerDex::MakeWriteTypeId32},
+      {{2, TypeTag(kTypeListToTypeId), PoolTag(kTypeId)},
+       &DisassemblerDex::MakeReadTypeListToTypeId16,
+       &DisassemblerDex::MakeWriteTypeId16},
+      {{2, TypeTag(kCodeToTypeId), PoolTag(kTypeId)},
+       &DisassemblerDex::MakeReadCodeToTypeId16,
+       &DisassemblerDex::MakeWriteTypeId16},
+      {{2, TypeTag(kCodeToProtoId), PoolTag(kProtoId)},
+       &DisassemblerDex::MakeReadCodeToProtoId16,
+       &DisassemblerDex::MakeWriteProtoId16},
+      {{2, TypeTag(kMethodIdToProtoId), PoolTag(kProtoId)},
+       &DisassemblerDex::MakeReadMethodIdToProtoId16,
+       &DisassemblerDex::MakeWriteProtoId16},
+      {{2, TypeTag(kCodeToFieldId), PoolTag(kFieldId)},
+       &DisassemblerDex::MakeReadCodeToFieldId16,
+       &DisassemblerDex::MakeWriteFieldId16},
+      {{2, TypeTag(kMethodHandleToFieldId), PoolTag(kFieldId)},
+       &DisassemblerDex::MakeReadMethodHandleToFieldId16,
+       &DisassemblerDex::MakeWriteFieldId16},
+      {{4, TypeTag(kAnnotationsDirectoryToFieldId), PoolTag(kFieldId)},
+       &DisassemblerDex::MakeReadAnnotationsDirectoryToFieldId32,
+       &DisassemblerDex::MakeWriteFieldId32},
+      {{2, TypeTag(kCodeToMethodId), PoolTag(kMethodId)},
+       &DisassemblerDex::MakeReadCodeToMethodId16,
+       &DisassemblerDex::MakeWriteMethodId16},
+      {{2, TypeTag(kMethodHandleToMethodId), PoolTag(kMethodId)},
+       &DisassemblerDex::MakeReadMethodHandleToMethodId16,
+       &DisassemblerDex::MakeWriteMethodId16},
+      {{4, TypeTag(kAnnotationsDirectoryToMethodId), PoolTag(kMethodId)},
+       &DisassemblerDex::MakeReadAnnotationsDirectoryToMethodId32,
+       &DisassemblerDex::MakeWriteMethodId32},
+      {{4, TypeTag(kAnnotationsDirectoryToParameterMethodId),
+        PoolTag(kMethodId)},
+       &DisassemblerDex::MakeReadAnnotationsDirectoryToParameterMethodId32,
+       &DisassemblerDex::MakeWriteMethodId32},
+      {{2, TypeTag(kCodeToCallSiteId), PoolTag(kCallSiteId)},
+       &DisassemblerDex::MakeReadCodeToCallSiteId16,
+       &DisassemblerDex::MakeWriteCallSiteId16},
+      {{2, TypeTag(kCodeToMethodHandle), PoolTag(kMethodHandle)},
+       &DisassemblerDex::MakeReadCodeToMethodHandle16,
+       &DisassemblerDex::MakeWriteMethodHandle16},
+      {{4, TypeTag(kProtoIdToParametersTypeList), PoolTag(kTypeList)},
+       &DisassemblerDex::MakeReadProtoIdToParametersTypeList,
+       &DisassemblerDex::MakeWriteAbs32},
+      {{4, TypeTag(kClassDefToInterfacesTypeList), PoolTag(kTypeList)},
+       &DisassemblerDex::MakeReadClassDefToInterfacesTypeList,
+       &DisassemblerDex::MakeWriteAbs32},
+      {{4, TypeTag(kAnnotationsDirectoryToParameterAnnotationSetRef),
+        PoolTag(kAnnotationSetRefList)},
+       &DisassemblerDex::
+           MakeReadAnnotationsDirectoryToParameterAnnotationSetRef,
+       &DisassemblerDex::MakeWriteAbs32},
+      {{4, TypeTag(kAnnotationSetRefListToAnnotationSet),
+        PoolTag(kAnnotionSet)},
+       &DisassemblerDex::MakeReadAnnotationSetRefListToAnnotationSet,
+       &DisassemblerDex::MakeWriteAbs32},
+      {{4, TypeTag(kAnnotationsDirectoryToClassAnnotationSet),
+        PoolTag(kAnnotionSet)},
+       &DisassemblerDex::MakeReadAnnotationsDirectoryToClassAnnotationSet,
+       &DisassemblerDex::MakeWriteAbs32},
+      {{4, TypeTag(kAnnotationsDirectoryToFieldAnnotationSet),
+        PoolTag(kAnnotionSet)},
+       &DisassemblerDex::MakeReadAnnotationsDirectoryToFieldAnnotationSet,
+       &DisassemblerDex::MakeWriteAbs32},
+      {{4, TypeTag(kAnnotationsDirectoryToMethodAnnotationSet),
+        PoolTag(kAnnotionSet)},
+       &DisassemblerDex::MakeReadAnnotationsDirectoryToMethodAnnotationSet,
+       &DisassemblerDex::MakeWriteAbs32},
+      {{4, TypeTag(kClassDefToClassData), PoolTag(kClassData)},
+       &DisassemblerDex::MakeReadClassDefToClassData,
+       &DisassemblerDex::MakeWriteAbs32},
+      {{1, TypeTag(kCodeToRelCode8), PoolTag(kCode)},
+       &DisassemblerDex::MakeReadCodeToRelCode8,
+       &DisassemblerDex::MakeWriteRelCode8},
+      {{2, TypeTag(kCodeToRelCode16), PoolTag(kCode)},
+       &DisassemblerDex::MakeReadCodeToRelCode16,
+       &DisassemblerDex::MakeWriteRelCode16},
+      {{4, TypeTag(kCodeToRelCode32), PoolTag(kCode)},
+       &DisassemblerDex::MakeReadCodeToRelCode32,
+       &DisassemblerDex::MakeWriteRelCode32},
+      {{4, TypeTag(kStringIdToStringData), PoolTag(kStringData)},
+       &DisassemblerDex::MakeReadStringIdToStringData,
+       &DisassemblerDex::MakeWriteAbs32},
+      {{4, TypeTag(kAnnotationSetToAnnotation), PoolTag(kAnnotation)},
+       &DisassemblerDex::MakeReadAnnotationSetToAnnotation,
+       &DisassemblerDex::MakeWriteAbs32},
+      {{4, TypeTag(kClassDefToStaticValuesEncodedArray),
+        PoolTag(kEncodedArray)},
+       &DisassemblerDex::MakeReadClassDefToStaticValuesEncodedArray,
+       &DisassemblerDex::MakeWriteAbs32},
+      {{4, TypeTag(kClassDefToAnnotationDirectory),
+        PoolTag(kAnnotationsDirectory)},
+       &DisassemblerDex::MakeReadClassDefToAnnotationDirectory,
+       &DisassemblerDex::MakeWriteAbs32},
+      {{4, TypeTag(kCallSiteIdToCallSite), PoolTag(kCallSite)},
+       &DisassemblerDex::MakeReadCallSiteIdToCallSite32,
+       &DisassemblerDex::MakeWriteAbs32},
+  };
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadStringIdToStringData(
+    offset_t lo,
+    offset_t hi) {
+  // dex::StringIdItem::string_data_off mapper.
+  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, string_map_item_, sizeof(dex::StringIdItem),
+      offsetof(dex::StringIdItem, string_data_off), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadTypeIdToDescriptorStringId32(offset_t lo,
+                                                      offset_t hi) {
+  auto mapper = base::BindRepeating(
+      ReadTargetIndex<decltype(dex::TypeIdItem::descriptor_idx)>, image_,
+      string_map_item_, sizeof(dex::StringIdItem));
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, type_map_item_, sizeof(dex::TypeIdItem),
+      offsetof(dex::TypeIdItem, descriptor_idx), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadProtoIdToShortyStringId32(offset_t lo, offset_t hi) {
+  auto mapper = base::BindRepeating(
+      ReadTargetIndex<decltype(dex::ProtoIdItem::shorty_idx)>, image_,
+      string_map_item_, sizeof(dex::StringIdItem));
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, proto_map_item_, sizeof(dex::ProtoIdItem),
+      offsetof(dex::ProtoIdItem, shorty_idx), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadProtoIdToReturnTypeId32(offset_t lo, offset_t hi) {
+  auto mapper = base::BindRepeating(
+      ReadTargetIndex<decltype(dex::ProtoIdItem::return_type_idx)>, image_,
+      type_map_item_, sizeof(dex::TypeIdItem));
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, proto_map_item_, sizeof(dex::ProtoIdItem),
+      offsetof(dex::ProtoIdItem, return_type_idx), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadProtoIdToParametersTypeList(offset_t lo, offset_t hi) {
+  // dex::ProtoIdItem::parameters_off mapper.
+  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, proto_map_item_, sizeof(dex::ProtoIdItem),
+      offsetof(dex::ProtoIdItem, parameters_off), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadFieldToClassTypeId16(
+    offset_t lo,
+    offset_t hi) {
+  auto mapper = base::BindRepeating(
+      ReadTargetIndex<decltype(dex::FieldIdItem::class_idx)>, image_,
+      type_map_item_, sizeof(dex::TypeIdItem));
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, field_map_item_, sizeof(dex::FieldIdItem),
+      offsetof(dex::FieldIdItem, class_idx), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadFieldToTypeId16(
+    offset_t lo,
+    offset_t hi) {
+  auto mapper =
+      base::BindRepeating(ReadTargetIndex<decltype(dex::FieldIdItem::type_idx)>,
+                          image_, type_map_item_, sizeof(dex::TypeIdItem));
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, field_map_item_, sizeof(dex::FieldIdItem),
+      offsetof(dex::FieldIdItem, type_idx), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadFieldToNameStringId32(
+    offset_t lo,
+    offset_t hi) {
+  auto mapper =
+      base::BindRepeating(ReadTargetIndex<decltype(dex::FieldIdItem::name_idx)>,
+                          image_, string_map_item_, sizeof(dex::StringIdItem));
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, field_map_item_, sizeof(dex::FieldIdItem),
+      offsetof(dex::FieldIdItem, name_idx), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadMethodIdToClassTypeId16(offset_t lo, offset_t hi) {
+  auto mapper = base::BindRepeating(
+      ReadTargetIndex<decltype(dex::MethodIdItem::class_idx)>, image_,
+      type_map_item_, sizeof(dex::TypeIdItem));
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, method_map_item_, sizeof(dex::MethodIdItem),
+      offsetof(dex::MethodIdItem, class_idx), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadMethodIdToProtoId16(
+    offset_t lo,
+    offset_t hi) {
+  auto mapper = base::BindRepeating(
+      ReadTargetIndex<decltype(dex::MethodIdItem::proto_idx)>, image_,
+      proto_map_item_, sizeof(dex::ProtoIdItem));
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, method_map_item_, sizeof(dex::MethodIdItem),
+      offsetof(dex::MethodIdItem, proto_idx), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadMethodIdToNameStringId32(offset_t lo, offset_t hi) {
+  auto mapper = base::BindRepeating(
+      ReadTargetIndex<decltype(dex::MethodIdItem::name_idx)>, image_,
+      string_map_item_, sizeof(dex::StringIdItem));
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, method_map_item_, sizeof(dex::MethodIdItem),
+      offsetof(dex::MethodIdItem, name_idx), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadClassDefToClassTypeId32(offset_t lo, offset_t hi) {
+  auto mapper = base::BindRepeating(
+      ReadTargetIndex<decltype(dex::ClassDefItem::superclass_idx)>, image_,
+      type_map_item_, sizeof(dex::TypeIdItem));
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
+      offsetof(dex::ClassDefItem, class_idx), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadClassDefToSuperClassTypeId32(offset_t lo,
+                                                      offset_t hi) {
+  auto mapper = base::BindRepeating(
+      ReadTargetIndex<decltype(dex::ClassDefItem::superclass_idx)>, image_,
+      type_map_item_, sizeof(dex::TypeIdItem));
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
+      offsetof(dex::ClassDefItem, superclass_idx), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadClassDefToInterfacesTypeList(offset_t lo,
+                                                      offset_t hi) {
+  // dex::ClassDefItem::interfaces_off mapper.
+  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
+      offsetof(dex::ClassDefItem, interfaces_off), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadClassDefToSourceFileStringId32(offset_t lo,
+                                                        offset_t hi) {
+  auto mapper = base::BindRepeating(
+      ReadTargetIndex<decltype(dex::ClassDefItem::source_file_idx)>, image_,
+      string_map_item_, sizeof(dex::StringIdItem));
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
+      offsetof(dex::ClassDefItem, source_file_idx), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadClassDefToAnnotationDirectory(offset_t lo,
+                                                       offset_t hi) {
+  // dex::ClassDefItem::annotations_off mapper.
+  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
+      offsetof(dex::ClassDefItem, annotations_off), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadClassDefToClassData(
+    offset_t lo,
+    offset_t hi) {
+  // dex::ClassDefItem::class_data_off mapper.
+  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
+      offsetof(dex::ClassDefItem, class_data_off), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadClassDefToStaticValuesEncodedArray(offset_t lo,
+                                                            offset_t hi) {
+  // dex::ClassDefItem::static_values_off mapper.
+  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
+      offsetof(dex::ClassDefItem, static_values_off), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadCallSiteIdToCallSite32(offset_t lo, offset_t hi) {
+  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, call_site_map_item_, sizeof(dex::CallSiteIdItem),
+      offsetof(dex::CallSiteIdItem, call_site_off), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadMethodHandleToFieldId16(offset_t lo, offset_t hi) {
+  auto mapper = base::BindRepeating(ReadMethodHandleFieldOrMethodId, image_,
+                                    field_map_item_, sizeof(dex::FieldIdItem),
+                                    dex::MethodHandleType::kStaticPut,
+                                    dex::MethodHandleType::kInstanceGet);
+  // Use |mapper_wants_item == true| for ItemReferenceReader such that
+  // |location| is aligned with MethodHandleItem when passed to |mapper|. This
+  // allows ReadMethodHandleFieldOrMethodId to safely determine whether the
+  // reference in the MethodHandleItem is of the correct type to be emitted.
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, method_handle_map_item_, sizeof(dex::MethodHandleItem),
+      offsetof(dex::MethodHandleItem, field_or_method_id), std::move(mapper),
+      /*mapper_wants_item=*/true);
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadMethodHandleToMethodId16(offset_t lo, offset_t hi) {
+  auto mapper = base::BindRepeating(ReadMethodHandleFieldOrMethodId, image_,
+                                    method_map_item_, sizeof(dex::MethodIdItem),
+                                    dex::MethodHandleType::kInvokeStatic,
+                                    dex::MethodHandleType::kInvokeInterface);
+  // Use |mapper_wants_item == true| for ItemReferenceReader such that
+  // |location| is aligned with MethodHandleItem when passed to |mapper|. This
+  // allows ReadMethodHandleFieldOrMethodId to safely determine whether the
+  // reference in the MethodHandleItem is of the correct type to be emitted.
+  return std::make_unique<ItemReferenceReader>(
+      lo, hi, method_handle_map_item_, sizeof(dex::MethodHandleItem),
+      offsetof(dex::MethodHandleItem, field_or_method_id), std::move(mapper),
+      /*mapper_wants_item=*/true);
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadTypeListToTypeId16(
+    offset_t lo,
+    offset_t hi) {
+  auto mapper =
+      base::BindRepeating(ReadTargetIndex<decltype(dex::TypeItem::type_idx)>,
+                          image_, type_map_item_, sizeof(dex::TypeIdItem));
+  return std::make_unique<CachedItemListReferenceReader>(
+      lo, hi, offsetof(dex::TypeItem, type_idx), type_list_offsets_,
+      std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadAnnotationSetToAnnotation(offset_t lo, offset_t hi) {
+  // dex::AnnotationOffItem::annotation_off mapper.
+  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
+  return std::make_unique<CachedItemListReferenceReader>(
+      lo, hi, offsetof(dex::AnnotationOffItem, annotation_off),
+      annotation_set_offsets_, std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadAnnotationSetRefListToAnnotationSet(offset_t lo,
+                                                             offset_t hi) {
+  // dex::AnnotationSetRefItem::annotations_off mapper.
+  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
+  return std::make_unique<CachedItemListReferenceReader>(
+      lo, hi, offsetof(dex::AnnotationSetRefItem, annotations_off),
+      annotation_set_ref_list_offsets_, std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadAnnotationsDirectoryToClassAnnotationSet(offset_t lo,
+                                                                  offset_t hi) {
+  // dex::AnnotationsDirectoryItem::class_annotations_off mapper.
+  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
+  return std::make_unique<CachedItemListReferenceReader>(
+      lo, hi, offsetof(dex::AnnotationsDirectoryItem, class_annotations_off),
+      annotations_directory_item_offsets_, std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadAnnotationsDirectoryToFieldId32(offset_t lo,
+                                                         offset_t hi) {
+  auto mapper = base::BindRepeating(
+      ReadTargetIndex<decltype(dex::FieldAnnotation::field_idx)>, image_,
+      field_map_item_, sizeof(dex::FieldIdItem));
+  return std::make_unique<CachedItemListReferenceReader>(
+      lo, hi, offsetof(dex::FieldAnnotation, field_idx),
+      annotations_directory_item_field_annotation_offsets_, std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadAnnotationsDirectoryToFieldAnnotationSet(offset_t lo,
+                                                                  offset_t hi) {
+  // dex::FieldAnnotation::annotations_off mapper.
+  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
+  return std::make_unique<CachedItemListReferenceReader>(
+      lo, hi, offsetof(dex::FieldAnnotation, annotations_off),
+      annotations_directory_item_field_annotation_offsets_, std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadAnnotationsDirectoryToMethodId32(offset_t lo,
+                                                          offset_t hi) {
+  auto mapper = base::BindRepeating(
+      ReadTargetIndex<decltype(dex::MethodAnnotation::method_idx)>, image_,
+      method_map_item_, sizeof(dex::MethodIdItem));
+  return std::make_unique<CachedItemListReferenceReader>(
+      lo, hi, offsetof(dex::MethodAnnotation, method_idx),
+      annotations_directory_item_method_annotation_offsets_, std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadAnnotationsDirectoryToMethodAnnotationSet(
+    offset_t lo,
+    offset_t hi) {
+  // dex::MethodAnnotation::annotations_off mapper.
+  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
+  return std::make_unique<CachedItemListReferenceReader>(
+      lo, hi, offsetof(dex::MethodAnnotation, annotations_off),
+      annotations_directory_item_method_annotation_offsets_, std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadAnnotationsDirectoryToParameterMethodId32(
+    offset_t lo,
+    offset_t hi) {
+  auto mapper = base::BindRepeating(
+      ReadTargetIndex<decltype(dex::ParameterAnnotation::method_idx)>, image_,
+      method_map_item_, sizeof(dex::MethodIdItem));
+  return std::make_unique<CachedItemListReferenceReader>(
+      lo, hi, offsetof(dex::ParameterAnnotation, method_idx),
+      annotations_directory_item_parameter_annotation_offsets_,
+      std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader>
+DisassemblerDex::MakeReadAnnotationsDirectoryToParameterAnnotationSetRef(
+    offset_t lo,
+    offset_t hi) {
+  // dex::ParameterAnnotation::annotations_off mapper.
+  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
+  return std::make_unique<CachedItemListReferenceReader>(
+      lo, hi, offsetof(dex::ParameterAnnotation, annotations_off),
+      annotations_directory_item_parameter_annotation_offsets_,
+      std::move(mapper));
+}
+
+// MakeReadCode* readers use offset relative to the instruction beginning based
+// on the instruction format ID.
+// See https://source.android.com/devices/tech/dalvik/instruction-formats
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToStringId16(
+    offset_t lo,
+    offset_t hi) {
+  auto filter = base::BindRepeating(
+      [](const InstructionParser::Value& value) -> offset_t {
+        if (value.instr->format == dex::FormatId::c &&
+            (value.instr->opcode == 0x1A)) {  // const-string
+          // BBBB from e.g., const-string vAA, string@BBBB.
+          return value.instr_offset + 2;
+        }
+        return kInvalidOffset;
+      });
+  auto mapper =
+      base::BindRepeating(ReadTargetIndex<uint16_t>, image_, string_map_item_,
+                          sizeof(dex::StringIdItem));
+  return std::make_unique<InstructionReferenceReader>(
+      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToStringId32(
+    offset_t lo,
+    offset_t hi) {
+  auto filter = base::BindRepeating(
+      [](const InstructionParser::Value& value) -> offset_t {
+        if (value.instr->format == dex::FormatId::c &&
+            (value.instr->opcode == 0x1B)) {  // const-string/jumbo
+          // BBBBBBBB from e.g., const-string/jumbo vAA, string@BBBBBBBB.
+          return value.instr_offset + 2;
+        }
+        return kInvalidOffset;
+      });
+  auto mapper =
+      base::BindRepeating(ReadTargetIndex<uint32_t>, image_, string_map_item_,
+                          sizeof(dex::StringIdItem));
+  return std::make_unique<InstructionReferenceReader>(
+      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToTypeId16(
+    offset_t lo,
+    offset_t hi) {
+  auto filter = base::BindRepeating(
+      [](const InstructionParser::Value& value) -> offset_t {
+        if (value.instr->format == dex::FormatId::c &&
+            (value.instr->opcode == 0x1C ||   // const-class
+             value.instr->opcode == 0x1F ||   // check-cast
+             value.instr->opcode == 0x20 ||   // instance-of
+             value.instr->opcode == 0x22 ||   // new-instance
+             value.instr->opcode == 0x23 ||   // new-array
+             value.instr->opcode == 0x24 ||   // filled-new-array
+             value.instr->opcode == 0x25)) {  // filled-new-array/range
+          // BBBB from e.g., const-class vAA, type@BBBB.
+          return value.instr_offset + 2;
+        }
+        return kInvalidOffset;
+      });
+  auto mapper = base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
+                                    type_map_item_, sizeof(dex::TypeIdItem));
+  return std::make_unique<InstructionReferenceReader>(
+      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToProtoId16(
+    offset_t lo,
+    offset_t hi) {
+  auto filter = base::BindRepeating(
+      [](const InstructionParser::Value& value) -> offset_t {
+        if (value.instr->format == dex::FormatId::c) {
+          if (value.instr->opcode == 0xFA ||  // invoke-polymorphic
+              value.instr->opcode == 0xFB) {  // invoke-polymorphic/range
+            // HHHH from e.g, invoke-polymorphic {vC, vD, vE, vF, vG},
+            //   meth@BBBB, proto@HHHH
+            return value.instr_offset + 6;
+          }
+          if (value.instr->opcode == 0xFF) {  // const-method-type
+            // BBBB from e.g., const-method-type vAA, proto@BBBB
+            return value.instr_offset + 2;
+          }
+        }
+        return kInvalidOffset;
+      });
+  auto mapper = base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
+                                    proto_map_item_, sizeof(dex::ProtoIdItem));
+  return std::make_unique<InstructionReferenceReader>(
+      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToCallSiteId16(
+    offset_t lo,
+    offset_t hi) {
+  auto filter = base::BindRepeating(
+      [](const InstructionParser::Value& value) -> offset_t {
+        if (value.instr->format == dex::FormatId::c &&
+            (value.instr->opcode == 0xFC ||   // invoke-custom
+             value.instr->opcode == 0xFD)) {  // invoke-custom/range
+          // BBBB from e.g, invoke-custom {vC, vD, vE, vF, vG},
+          //   call_site@BBBB
+          return value.instr_offset + 2;
+        }
+        return kInvalidOffset;
+      });
+  auto mapper =
+      base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
+                          call_site_map_item_, sizeof(dex::CallSiteIdItem));
+  return std::make_unique<InstructionReferenceReader>(
+      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToMethodHandle16(
+    offset_t lo,
+    offset_t hi) {
+  auto filter = base::BindRepeating(
+      [](const InstructionParser::Value& value) -> offset_t {
+        if (value.instr->format == dex::FormatId::c &&
+            value.instr->opcode == 0xFE) {  // const-method-handle
+          // BBBB from e.g, const-method-handle vAA, method_handle@BBBB
+          return value.instr_offset + 2;
+        }
+        return kInvalidOffset;
+      });
+  auto mapper = base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
+                                    method_handle_map_item_,
+                                    sizeof(dex::MethodHandleItem));
+  return std::make_unique<InstructionReferenceReader>(
+      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToFieldId16(
+    offset_t lo,
+    offset_t hi) {
+  auto filter = base::BindRepeating(
+      [](const InstructionParser::Value& value) -> offset_t {
+        if (value.instr->format == dex::FormatId::c &&
+            (value.instr->opcode == 0x52 ||   // iinstanceop (iget-*, iput-*)
+             value.instr->opcode == 0x60)) {  // sstaticop (sget-*, sput-*)
+          // CCCC from e.g., iget vA, vB, field@CCCC.
+          return value.instr_offset + 2;
+        }
+        return kInvalidOffset;
+      });
+  auto mapper = base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
+                                    field_map_item_, sizeof(dex::FieldIdItem));
+  return std::make_unique<InstructionReferenceReader>(
+      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToMethodId16(
+    offset_t lo,
+    offset_t hi) {
+  auto filter = base::BindRepeating(
+      [](const InstructionParser::Value& value) -> offset_t {
+        if (value.instr->format == dex::FormatId::c &&
+            (value.instr->opcode == 0x6E ||   // invoke-kind
+             value.instr->opcode == 0x74 ||   // invoke-kind/range
+             value.instr->opcode == 0xFA ||   // invoke-polymorphic
+             value.instr->opcode == 0xFB)) {  // invoke-polymorphic/range
+          // BBBB from e.g., invoke-virtual {vC, vD, vE, vF, vG}, meth@BBBB.
+          return value.instr_offset + 2;
+        }
+        return kInvalidOffset;
+      });
+  auto mapper =
+      base::BindRepeating(ReadTargetIndex<uint16_t>, image_, method_map_item_,
+                          sizeof(dex::MethodIdItem));
+  return std::make_unique<InstructionReferenceReader>(
+      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToRelCode8(
+    offset_t lo,
+    offset_t hi) {
+  auto filter = base::BindRepeating(
+      [](const InstructionParser::Value& value) -> offset_t {
+        if (value.instr->format == dex::FormatId::t &&
+            value.instr->opcode == 0x28) {  // goto
+          // +AA from e.g., goto +AA.
+          return value.instr_offset + 1;
+        }
+        return kInvalidOffset;
+      });
+  auto mapper = base::BindRepeating(
+      [](DisassemblerDex* dis, offset_t location) {
+        // Address is relative to the current instruction, which begins 1 unit
+        // before |location|. This needs to be subtracted out. Also, store as
+        // int32_t so |unsafe_delta - 1| won't underflow!
+        int32_t unsafe_delta = dis->image_.read<int8_t>(location);
+        offset_t unsafe_target = static_cast<offset_t>(
+            location + (unsafe_delta - 1) * kInstrUnitSize);
+        // TODO(huangs): Check that |unsafe_target| stays within code item.
+        return unsafe_target;
+      },
+      base::Unretained(this));
+  return std::make_unique<InstructionReferenceReader>(
+      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToRelCode16(
+    offset_t lo,
+    offset_t hi) {
+  auto filter = base::BindRepeating(
+      [](const InstructionParser::Value& value) -> offset_t {
+        if (value.instr->format == dex::FormatId::t &&
+            (value.instr->opcode == 0x29 ||   // goto/16
+             value.instr->opcode == 0x32 ||   // if-test
+             value.instr->opcode == 0x38)) {  // if-testz
+          // +AAAA from e.g., goto/16 +AAAA.
+          return value.instr_offset + 2;
+        }
+        return kInvalidOffset;
+      });
+  auto mapper = base::BindRepeating(
+      [](DisassemblerDex* dis, offset_t location) {
+        // Address is relative to the current instruction, which begins 1 unit
+        // before |location|. This needs to be subtracted out. Also, store as
+        // int32_t so |unsafe_delta - 1| won't underflow!
+        int32_t unsafe_delta = dis->image_.read<int16_t>(location);
+        offset_t unsafe_target = static_cast<offset_t>(
+            location + (unsafe_delta - 1) * kInstrUnitSize);
+        // TODO(huangs): Check that |unsafe_target| stays within code item.
+        return unsafe_target;
+      },
+      base::Unretained(this));
+  return std::make_unique<InstructionReferenceReader>(
+      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToRelCode32(
+    offset_t lo,
+    offset_t hi) {
+  auto filter = base::BindRepeating(
+      [](const InstructionParser::Value& value) -> offset_t {
+        if (value.instr->format == dex::FormatId::t &&
+            (value.instr->opcode == 0x26 ||   // fill-array-data
+             value.instr->opcode == 0x2A ||   // goto/32
+             value.instr->opcode == 0x2B ||   // packed-switch
+             value.instr->opcode == 0x2C)) {  // sparse-switch
+          // +BBBBBBBB from e.g., fill-array-data vAA, +BBBBBBBB.
+          // +AAAAAAAA from e.g., goto/32 +AAAAAAAA.
+          return value.instr_offset + 2;
+        }
+        return kInvalidOffset;
+      });
+  auto mapper = base::BindRepeating(
+      [](DisassemblerDex* dis, offset_t location) {
+        // Address is relative to the current instruction, which begins 1 unit
+        // before |location|. This needs to be subtracted out. Use int64_t to
+        // avoid underflow and overflow.
+        int64_t unsafe_delta = dis->image_.read<int32_t>(location);
+        int64_t unsafe_target = location + (unsafe_delta - 1) * kInstrUnitSize;
+
+        // TODO(huangs): Check that |unsafe_target| stays within code item.
+        offset_t checked_unsafe_target =
+            static_cast<offset_t>(base::CheckedNumeric<offset_t>(unsafe_target)
+                                      .ValueOrDefault(kInvalidOffset));
+        return checked_unsafe_target < kOffsetBound ? checked_unsafe_target
+                                                    : kInvalidOffset;
+      },
+      base::Unretained(this));
+  return std::make_unique<InstructionReferenceReader>(
+      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteStringId16(
+    MutableBufferView image) {
+  auto writer = base::BindRepeating(
+      WriteTargetIndex<uint16_t>, string_map_item_, sizeof(dex::StringIdItem));
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteStringId32(
+    MutableBufferView image) {
+  auto writer = base::BindRepeating(
+      WriteTargetIndex<uint32_t>, string_map_item_, sizeof(dex::StringIdItem));
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteTypeId16(
+    MutableBufferView image) {
+  auto writer = base::BindRepeating(WriteTargetIndex<uint16_t>, type_map_item_,
+                                    sizeof(dex::TypeIdItem));
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteTypeId32(
+    MutableBufferView image) {
+  auto writer = base::BindRepeating(WriteTargetIndex<uint32_t>, type_map_item_,
+                                    sizeof(dex::TypeIdItem));
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteProtoId16(
+    MutableBufferView image) {
+  auto writer = base::BindRepeating(WriteTargetIndex<uint16_t>, proto_map_item_,
+                                    sizeof(dex::ProtoIdItem));
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteFieldId16(
+    MutableBufferView image) {
+  auto writer = base::BindRepeating(WriteTargetIndex<uint16_t>, field_map_item_,
+                                    sizeof(dex::FieldIdItem));
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteFieldId32(
+    MutableBufferView image) {
+  auto writer = base::BindRepeating(WriteTargetIndex<uint32_t>, field_map_item_,
+                                    sizeof(dex::FieldIdItem));
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteMethodId16(
+    MutableBufferView image) {
+  auto writer = base::BindRepeating(
+      WriteTargetIndex<uint16_t>, method_map_item_, sizeof(dex::MethodIdItem));
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteMethodId32(
+    MutableBufferView image) {
+  auto writer = base::BindRepeating(
+      WriteTargetIndex<uint32_t>, method_map_item_, sizeof(dex::MethodIdItem));
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteCallSiteId16(
+    MutableBufferView image) {
+  auto writer =
+      base::BindRepeating(WriteTargetIndex<uint16_t>, call_site_map_item_,
+                          sizeof(dex::CallSiteIdItem));
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteMethodHandle16(
+    MutableBufferView image) {
+  auto writer =
+      base::BindRepeating(WriteTargetIndex<uint16_t>, method_handle_map_item_,
+                          sizeof(dex::MethodHandleItem));
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteRelCode8(
+    MutableBufferView image) {
+  auto writer = base::BindRepeating([](Reference ref, MutableBufferView image) {
+    ptrdiff_t unsafe_byte_diff =
+        static_cast<ptrdiff_t>(ref.target) - ref.location;
+    DCHECK_EQ(0, unsafe_byte_diff % kInstrUnitSize);
+    // |delta| is relative to start of instruction, which is 1 unit before
+    // |ref.location|. The subtraction above removed too much, so +1 to fix.
+    base::CheckedNumeric<int8_t> delta((unsafe_byte_diff / kInstrUnitSize) + 1);
+    if (!delta.IsValid()) {
+      LOG(ERROR) << "Invalid reference at: " << AsHex<8>(ref.location) << ".";
+      return;
+    }
+    image.write<int8_t>(ref.location, delta.ValueOrDie());
+  });
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteRelCode16(
+    MutableBufferView image) {
+  auto writer = base::BindRepeating([](Reference ref, MutableBufferView image) {
+    ptrdiff_t unsafe_byte_diff =
+        static_cast<ptrdiff_t>(ref.target) - ref.location;
+    DCHECK_EQ(0, unsafe_byte_diff % kInstrUnitSize);
+    // |delta| is relative to start of instruction, which is 1 unit before
+    // |ref.location|. The subtraction above removed too much, so +1 to fix.
+    base::CheckedNumeric<int16_t> delta((unsafe_byte_diff / kInstrUnitSize) +
+                                        1);
+    if (!delta.IsValid()) {
+      LOG(ERROR) << "Invalid reference at: " << AsHex<8>(ref.location) << ".";
+      return;
+    }
+    image.write<int16_t>(ref.location, delta.ValueOrDie());
+  });
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteRelCode32(
+    MutableBufferView image) {
+  auto writer = base::BindRepeating([](Reference ref, MutableBufferView image) {
+    ptrdiff_t unsafe_byte_diff =
+        static_cast<ptrdiff_t>(ref.target) - ref.location;
+    DCHECK_EQ(0, unsafe_byte_diff % kInstrUnitSize);
+    // |delta| is relative to start of instruction, which is 1 unit before
+    // |ref.location|. The subtraction above removed too much, so +1 to fix.
+    base::CheckedNumeric<int32_t> delta((unsafe_byte_diff / kInstrUnitSize) +
+                                        1);
+    if (!delta.IsValid()) {
+      LOG(ERROR) << "Invalid reference at: " << AsHex<8>(ref.location) << ".";
+      return;
+    }
+    image.write<int32_t>(ref.location, delta.ValueOrDie());
+  });
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteAbs32(
+    MutableBufferView image) {
+  auto writer = base::BindRepeating([](Reference ref, MutableBufferView image) {
+    image.write<uint32_t>(ref.location, ref.target);
+  });
+  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
+}
+
+bool DisassemblerDex::Parse(ConstBufferView image) {
+  image_ = image;
+  return ParseHeader();
+}
+
+bool DisassemblerDex::ParseHeader() {
+  ReadDexHeaderResults results;
+  if (!ReadDexHeader(image_, &results))
+    return false;
+
+  header_ = results.header;
+  dex_version_ = results.dex_version;
+  BufferSource source = results.source;
+
+  // DEX header contains file size, so use it to resize |image_| right away.
+  image_.shrink(header_->file_size);
+
+  // Read map list. This is not a fixed-size array, so instead of reading
+  // MapList directly, read |MapList::size| first, then visit elements in
+  // |MapList::list|.
+  static_assert(
+      offsetof(dex::MapList, list) == sizeof(decltype(dex::MapList::size)),
+      "MapList size error.");
+  source = std::move(BufferSource(image_).Skip(header_->map_off));
+  decltype(dex::MapList::size) list_size = 0;
+  if (!source.GetValue(&list_size) || list_size > dex::kMaxItemListSize)
+    return false;
+  const auto* item_list = source.GetArray<const dex::MapItem>(list_size);
+  if (!item_list)
+    return false;
+
+  // Read and validate map list, ensuring that required item types are present.
+  // GetItemBaseSize() should have an entry for each item.
+  for (offset_t i = 0; i < list_size; ++i) {
+    const dex::MapItem* item = &item_list[i];
+    // Reject unreasonably large |item->size|.
+    size_t item_size = GetItemBaseSize(item->type);
+    // Confusing name: |item->size| is actually the number of items.
+    if (!image_.covers_array(item->offset, item->size, item_size))
+      return false;
+    if (!map_item_map_.insert(std::make_pair(item->type, item)).second)
+      return false;  // A given type must appear at most once.
+  }
+
+  // Make local copies of main map items.
+  if (map_item_map_.count(dex::kTypeStringIdItem)) {
+    string_map_item_ = *map_item_map_[dex::kTypeStringIdItem];
+  }
+  if (map_item_map_.count(dex::kTypeTypeIdItem)) {
+    type_map_item_ = *map_item_map_[dex::kTypeTypeIdItem];
+  }
+  if (map_item_map_.count(dex::kTypeProtoIdItem)) {
+    proto_map_item_ = *map_item_map_[dex::kTypeProtoIdItem];
+  }
+  if (map_item_map_.count(dex::kTypeFieldIdItem)) {
+    field_map_item_ = *map_item_map_[dex::kTypeFieldIdItem];
+  }
+  if (map_item_map_.count(dex::kTypeMethodIdItem)) {
+    method_map_item_ = *map_item_map_[dex::kTypeMethodIdItem];
+  }
+  if (map_item_map_.count(dex::kTypeClassDefItem)) {
+    class_def_map_item_ = *map_item_map_[dex::kTypeClassDefItem];
+  }
+  if (map_item_map_.count(dex::kTypeCallSiteIdItem)) {
+    call_site_map_item_ = *map_item_map_[dex::kTypeCallSiteIdItem];
+  }
+  if (map_item_map_.count(dex::kTypeMethodHandleItem)) {
+    method_handle_map_item_ = *map_item_map_[dex::kTypeMethodHandleItem];
+  }
+  if (map_item_map_.count(dex::kTypeTypeList)) {
+    type_list_map_item_ = *map_item_map_[dex::kTypeTypeList];
+  }
+  if (map_item_map_.count(dex::kTypeAnnotationSetRefList)) {
+    annotation_set_ref_list_map_item_ =
+        *map_item_map_[dex::kTypeAnnotationSetRefList];
+  }
+  if (map_item_map_.count(dex::kTypeAnnotationSetItem)) {
+    annotation_set_map_item_ = *map_item_map_[dex::kTypeAnnotationSetItem];
+  }
+  if (map_item_map_.count(dex::kTypeCodeItem)) {
+    code_map_item_ = *map_item_map_[dex::kTypeCodeItem];
+  }
+  if (map_item_map_.count(dex::kTypeAnnotationsDirectoryItem)) {
+    annotations_directory_map_item_ =
+        *map_item_map_[dex::kTypeAnnotationsDirectoryItem];
+  }
+
+  // Iteratively parse variable length lists, annotations directory items, and
+  // code items blocks. Any failure would indicate invalid DEX. Success
+  // indicates that no structural problem is found. However, contained
+  // references data read from parsed items still require validation.
+  if (!(ParseItemOffsets(image_, type_list_map_item_, sizeof(dex::TypeItem),
+                         &type_list_offsets_) &&
+        ParseItemOffsets(image_, annotation_set_ref_list_map_item_,
+                         sizeof(dex::AnnotationSetRefItem),
+                         &annotation_set_ref_list_offsets_) &&
+        ParseItemOffsets(image_, annotation_set_map_item_,
+                         sizeof(dex::AnnotationOffItem),
+                         &annotation_set_offsets_) &&
+        ParseAnnotationsDirectoryItems(
+            image_, annotations_directory_map_item_,
+            &annotations_directory_item_offsets_,
+            &annotations_directory_item_field_annotation_offsets_,
+            &annotations_directory_item_method_annotation_offsets_,
+            &annotations_directory_item_parameter_annotation_offsets_))) {
+    return false;
+  }
+  CodeItemParser code_item_parser(image_);
+  if (!code_item_parser.Init(code_map_item_))
+    return false;
+  code_item_offsets_.resize(code_map_item_.size);
+  for (size_t i = 0; i < code_map_item_.size; ++i) {
+    const offset_t code_item_offset = code_item_parser.GetNext();
+    if (code_item_offset == kInvalidOffset)
+      return false;
+    code_item_offsets_[i] = code_item_offset;
+  }
+  // DEX files are required to have parsable code items.
+  return !code_item_offsets_.empty();
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/disassembler_elf.cc b/native/zucchini/vendor/zucchini/disassembler_elf.cc
new file mode 100644
index 0000000..22a29ba
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/disassembler_elf.cc
@@ -0,0 +1,758 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/disassembler_elf.h"
+
+#include <stddef.h>
+
+#include <utility>
+
+#include "base/logging.h"
+#include "base/numerics/checked_math.h"
+#include "base/numerics/safe_conversions.h"
+#include "components/zucchini/abs32_utils.h"
+#include "components/zucchini/algorithm.h"
+#include "components/zucchini/arm_utils.h"
+#include "components/zucchini/buffer_source.h"
+
+namespace zucchini {
+
+namespace {
+
+constexpr uint64_t kElfImageBase = 0;
+constexpr size_t kSizeBound = 0x7FFF0000;
+
+// Threshold value for heuristics to detect THUMB2 code.
+constexpr double kAArch32BitCondAlwaysDensityThreshold = 0.4;
+
+// Bit fields for JudgeSection() return value.
+enum SectionJudgement : int {
+  // Bit: Section does not invalidate ELF, but may or may not be useful.
+  SECTION_BIT_SAFE = 1 << 0,
+  // Bit: Section useful for AddressTranslator, to map between offsets and RVAs.
+  SECTION_BIT_USEFUL_FOR_ADDRESS_TRANSLATOR = 1 << 1,
+  // Bit: Section useful for |offset_bound|, to estimate ELF size.
+  SECTION_BIT_USEFUL_FOR_OFFSET_BOUND = 1 << 2,
+  // Bit: Section potentially useful for pointer extraction.
+  SECTION_BIT_MAYBE_USEFUL_FOR_POINTERS = 1 << 3,
+
+  // The following are verdicts from combining bits, to improve semantics.
+  // Default value: A section is malformed and invalidates ELF.
+  SECTION_IS_MALFORMED = 0,
+  // Section does not invalidate ELF, but is also not used for anything.
+  SECTION_IS_USELESS = SECTION_BIT_SAFE,
+};
+
+// Decides how a section affects ELF parsing, and returns a bit field composed
+// from SectionJudgement values.
+template <class TRAITS>
+int JudgeSection(size_t image_size, const typename TRAITS::Elf_Shdr* section) {
+  // BufferRegion uses |size_t| this can be 32-bit in some cases. For Elf64
+  // |sh_addr|, |sh_offset| and |sh_size| are 64-bit this can result in
+  // overflows in the subsequent validation steps.
+  if (!base::IsValueInRangeForNumericType<size_t>(section->sh_addr) ||
+      !base::IsValueInRangeForNumericType<size_t>(section->sh_offset) ||
+      !base::IsValueInRangeForNumericType<size_t>(section->sh_size)) {
+    return SECTION_IS_MALFORMED;
+  }
+
+  // Examine RVA range: Reject if numerical overflow may happen.
+  if (!BufferRegion{static_cast<size_t>(section->sh_addr),
+                    static_cast<size_t>(section->sh_size)}
+           .FitsIn(kSizeBound))
+    return SECTION_IS_MALFORMED;
+
+  // Examine offset range: If section takes up |image| data then be stricter.
+  size_t offset_bound =
+      (section->sh_type == elf::SHT_NOBITS) ? kSizeBound : image_size;
+  if (!BufferRegion{static_cast<size_t>(section->sh_offset),
+                    static_cast<size_t>(section->sh_size)}
+           .FitsIn(offset_bound))
+    return SECTION_IS_MALFORMED;
+
+  // Empty sections don't contribute to offset-RVA mapping. For consistency, it
+  // should also not affect |offset_bounds|.
+  if (section->sh_size == 0)
+    return SECTION_IS_USELESS;
+
+  // Sections with |sh_addr == 0| are ignored because these tend to duplicates
+  // (can cause problems for lookup) and uninteresting. For consistency, it
+  // should also not affect |offset_bounds|.
+  if (section->sh_addr == 0)
+    return SECTION_IS_USELESS;
+
+  if (section->sh_type == elf::SHT_NOBITS) {
+    // Special case for .tbss sections: These should be ignored because they may
+    // have offset-RVA map that don't match other sections.
+    if (section->sh_flags & elf::SHF_TLS)
+      return SECTION_IS_USELESS;
+
+    // Section is useful for offset-RVA translation, but does not affect
+    // |offset_bounds| since it can have large virtual size (e.g., .bss).
+    return SECTION_BIT_SAFE | SECTION_BIT_USEFUL_FOR_ADDRESS_TRANSLATOR;
+  }
+
+  return SECTION_BIT_SAFE | SECTION_BIT_USEFUL_FOR_ADDRESS_TRANSLATOR |
+         SECTION_BIT_USEFUL_FOR_OFFSET_BOUND |
+         SECTION_BIT_MAYBE_USEFUL_FOR_POINTERS;
+}
+
+// Determines whether |section| is a reloc section.
+template <class TRAITS>
+bool IsRelocSection(const typename TRAITS::Elf_Shdr& section) {
+  DCHECK_GT(section.sh_size, 0U);
+  if (section.sh_type == elf::SHT_REL) {
+    // Also validate |section.sh_entsize|, which gets used later.
+    return section.sh_entsize == sizeof(typename TRAITS::Elf_Rel);
+  }
+  if (section.sh_type == elf::SHT_RELA)
+    return section.sh_entsize == sizeof(typename TRAITS::Elf_Rela);
+  return false;
+}
+
+// Determines whether |section| is a section with executable code.
+template <class TRAITS>
+bool IsExecSection(const typename TRAITS::Elf_Shdr& section) {
+  DCHECK_GT(section.sh_size, 0U);
+  return section.sh_type == elf::SHT_PROGBITS &&
+         (section.sh_flags & elf::SHF_EXECINSTR) != 0;
+}
+
+}  // namespace
+
+/******** Elf32Traits ********/
+
+// static
+constexpr Bitness Elf32Traits::kBitness;
+constexpr elf::FileClass Elf32Traits::kIdentificationClass;
+
+/******** Elf32IntelTraits ********/
+
+// static
+constexpr ExecutableType Elf32IntelTraits::kExeType;
+const char Elf32IntelTraits::kExeTypeString[] = "ELF x86";
+constexpr elf::MachineArchitecture Elf32IntelTraits::kMachineValue;
+constexpr uint32_t Elf32IntelTraits::kRelType;
+
+/******** ElfAArch32Traits ********/
+
+// static
+constexpr ExecutableType ElfAArch32Traits::kExeType;
+const char ElfAArch32Traits::kExeTypeString[] = "ELF ARM";
+constexpr elf::MachineArchitecture ElfAArch32Traits::kMachineValue;
+constexpr uint32_t ElfAArch32Traits::kRelType;
+
+/******** Elf64Traits ********/
+
+// static
+constexpr Bitness Elf64Traits::kBitness;
+constexpr elf::FileClass Elf64Traits::kIdentificationClass;
+
+/******** Elf64IntelTraits ********/
+
+// static
+constexpr ExecutableType Elf64IntelTraits::kExeType;
+const char Elf64IntelTraits::kExeTypeString[] = "ELF x64";
+constexpr elf::MachineArchitecture Elf64IntelTraits::kMachineValue;
+constexpr uint32_t Elf64IntelTraits::kRelType;
+
+/******** ElfAArch64Traits ********/
+
+// static
+constexpr ExecutableType ElfAArch64Traits::kExeType;
+const char ElfAArch64Traits::kExeTypeString[] = "ELF ARM64";
+constexpr elf::MachineArchitecture ElfAArch64Traits::kMachineValue;
+constexpr uint32_t ElfAArch64Traits::kRelType;
+
+/******** DisassemblerElf ********/
+
+// static.
+template <class TRAITS>
+bool DisassemblerElf<TRAITS>::QuickDetect(ConstBufferView image) {
+  BufferSource source(image);
+
+  // Do not consume the bytes for the magic value, as they are part of the
+  // header.
+  if (!source.CheckNextBytes({0x7F, 'E', 'L', 'F'}))
+    return false;
+
+  auto* header = source.GetPointer<typename Traits::Elf_Ehdr>();
+  if (!header)
+    return false;
+
+  if (header->e_ident[elf::EI_CLASS] != Traits::kIdentificationClass)
+    return false;
+
+  if (header->e_ident[elf::EI_DATA] != 1)  // Only ELFDATA2LSB is supported.
+    return false;
+
+  if (header->e_type != elf::ET_EXEC && header->e_type != elf::ET_DYN)
+    return false;
+
+  if (header->e_version != 1 || header->e_ident[elf::EI_VERSION] != 1)
+    return false;
+
+  if (header->e_machine != supported_architecture())
+    return false;
+
+  if (header->e_shentsize != sizeof(typename Traits::Elf_Shdr))
+    return false;
+
+  return true;
+}
+
+template <class TRAITS>
+DisassemblerElf<TRAITS>::~DisassemblerElf() = default;
+
+template <class TRAITS>
+ExecutableType DisassemblerElf<TRAITS>::GetExeType() const {
+  return Traits::kExeType;
+}
+
+template <class TRAITS>
+std::string DisassemblerElf<TRAITS>::GetExeTypeString() const {
+  return Traits::kExeTypeString;
+}
+
+// |num_equivalence_iterations_| = 2 for reloc -> abs32.
+template <class TRAITS>
+DisassemblerElf<TRAITS>::DisassemblerElf() : Disassembler(2) {}
+
+template <class TRAITS>
+bool DisassemblerElf<TRAITS>::Parse(ConstBufferView image) {
+  image_ = image;
+  if (!ParseHeader())
+    return false;
+  ParseSections();
+  return true;
+}
+
+template <class TRAITS>
+std::unique_ptr<ReferenceReader> DisassemblerElf<TRAITS>::MakeReadRelocs(
+    offset_t lo,
+    offset_t hi) {
+  DCHECK_LE(lo, hi);
+  DCHECK_LE(hi, image_.size());
+
+  if (reloc_section_dims_.empty())
+    return std::make_unique<EmptyReferenceReader>();
+
+  return std::make_unique<RelocReaderElf>(
+      image_, Traits::kBitness, reloc_section_dims_,
+      supported_relocation_type(), lo, hi, translator_);
+}
+
+template <class TRAITS>
+std::unique_ptr<ReferenceWriter> DisassemblerElf<TRAITS>::MakeWriteRelocs(
+    MutableBufferView image) {
+  return std::make_unique<RelocWriterElf>(image, Traits::kBitness, translator_);
+}
+
+template <class TRAITS>
+bool DisassemblerElf<TRAITS>::ParseHeader() {
+  BufferSource source(image_);
+  // Ensure any offsets will fit within the |image_|'s bounds.
+  if (!base::IsValueInRangeForNumericType<offset_t>(image_.size()))
+    return false;
+
+  // Ensures |header_| is valid later on.
+  if (!QuickDetect(image_))
+    return false;
+
+  header_ = source.GetPointer<typename Traits::Elf_Ehdr>();
+
+  sections_count_ = header_->e_shnum;
+  source = std::move(BufferSource(image_).Skip(header_->e_shoff));
+  sections_ = source.GetArray<typename Traits::Elf_Shdr>(sections_count_);
+  if (!sections_)
+    return false;
+  offset_t section_table_end =
+      base::checked_cast<offset_t>(source.begin() - image_.begin());
+
+  segments_count_ = header_->e_phnum;
+  source = std::move(BufferSource(image_).Skip(header_->e_phoff));
+  segments_ = source.GetArray<typename Traits::Elf_Phdr>(segments_count_);
+  if (!segments_)
+    return false;
+  offset_t segment_table_end =
+      base::checked_cast<offset_t>(source.begin() - image_.begin());
+
+  // Check string section -- even though we've stopped using them.
+  elf::Elf32_Half string_section_id = header_->e_shstrndx;
+  if (string_section_id >= sections_count_)
+    return false;
+  size_t section_names_size = sections_[string_section_id].sh_size;
+  if (section_names_size > 0) {
+    // If nonempty, then last byte of string section must be null.
+    const char* section_names = nullptr;
+    source = std::move(
+        BufferSource(image_).Skip(sections_[string_section_id].sh_offset));
+    section_names = source.GetArray<char>(section_names_size);
+    if (!section_names || section_names[section_names_size - 1] != '\0')
+      return false;
+  }
+
+  // Establish bound on encountered offsets.
+  offset_t offset_bound = std::max(section_table_end, segment_table_end);
+
+  // Visits |segments_| to get estimate on |offset_bound|.
+  for (const typename Traits::Elf_Phdr* segment = segments_;
+       segment != segments_ + segments_count_; ++segment) {
+    // |image_.covers()| is a sufficient check except when size_t is 32 bit and
+    // parsing ELF64. In such cases a value-in-range check is needed on the
+    // segment. This fixes crbug/1035603.
+    offset_t segment_end;
+    base::CheckedNumeric<offset_t> checked_segment_end = segment->p_offset;
+    checked_segment_end += segment->p_filesz;
+    if (!checked_segment_end.AssignIfValid(&segment_end) ||
+        !image_.covers({static_cast<size_t>(segment->p_offset),
+                        static_cast<size_t>(segment->p_filesz)})) {
+      return false;
+    }
+    offset_bound = std::max(offset_bound, segment_end);
+  }
+
+  // Visit and validate each section; add address translation data to |units|.
+  std::vector<AddressTranslator::Unit> units;
+  units.reserve(sections_count_);
+  section_judgements_.reserve(sections_count_);
+
+  for (int i = 0; i < sections_count_; ++i) {
+    const typename Traits::Elf_Shdr* section = &sections_[i];
+    int judgement = JudgeSection<Traits>(image_.size(), section);
+    section_judgements_.push_back(judgement);
+    if ((judgement & SECTION_BIT_SAFE) == 0)
+      return false;
+
+    uint32_t sh_size = base::checked_cast<uint32_t>(section->sh_size);
+    offset_t sh_offset = base::checked_cast<offset_t>(section->sh_offset);
+    rva_t sh_addr = base::checked_cast<rva_t>(section->sh_addr);
+    if ((judgement & SECTION_BIT_USEFUL_FOR_ADDRESS_TRANSLATOR) != 0) {
+      // Store mappings between RVA and offset.
+      units.push_back({sh_offset, sh_size, sh_addr, sh_size});
+    }
+    if ((judgement & SECTION_BIT_USEFUL_FOR_OFFSET_BOUND) != 0) {
+      offset_t section_end = base::checked_cast<offset_t>(sh_offset + sh_size);
+      offset_bound = std::max(offset_bound, section_end);
+    }
+  }
+
+  // Initialize |translator_| for offset-RVA translations. Any inconsistency
+  // (e.g., 2 offsets correspond to the same RVA) would invalidate the ELF file.
+  if (translator_.Initialize(std::move(units)) != AddressTranslator::kSuccess)
+    return false;
+
+  DCHECK_LE(offset_bound, image_.size());
+  image_.shrink(offset_bound);
+  return true;
+}
+
+template <class TRAITS>
+void DisassemblerElf<TRAITS>::ExtractInterestingSectionHeaders() {
+  DCHECK(reloc_section_dims_.empty());
+  DCHECK(exec_headers_.empty());
+  for (elf::Elf32_Half i = 0; i < sections_count_; ++i) {
+    const typename Traits::Elf_Shdr* section = sections_ + i;
+    if ((section_judgements_[i] & SECTION_BIT_MAYBE_USEFUL_FOR_POINTERS) != 0) {
+      if (IsRelocSection<Traits>(*section))
+        reloc_section_dims_.emplace_back(*section);
+      else if (IsExecSection<Traits>(*section))
+        exec_headers_.push_back(section);
+    }
+  }
+  auto comp = [](const typename Traits::Elf_Shdr* a,
+                 const typename Traits::Elf_Shdr* b) {
+    return a->sh_offset < b->sh_offset;
+  };
+  std::sort(reloc_section_dims_.begin(), reloc_section_dims_.end());
+  std::sort(exec_headers_.begin(), exec_headers_.end(), comp);
+}
+
+template <class TRAITS>
+void DisassemblerElf<TRAITS>::GetAbs32FromRelocSections() {
+  constexpr int kAbs32Width = Traits::kVAWidth;
+  DCHECK(abs32_locations_.empty());
+
+  // Read reloc targets to get preliminary abs32 locations.
+  std::unique_ptr<ReferenceReader> relocs = MakeReadRelocs(0, offset_t(size()));
+  for (auto ref = relocs->GetNext(); ref.has_value(); ref = relocs->GetNext())
+    abs32_locations_.push_back(ref->target);
+
+  std::sort(abs32_locations_.begin(), abs32_locations_.end());
+
+  // Abs32 references must have targets translatable to offsets. Remove those
+  // that are unable to do so.
+  size_t num_untranslatable =
+      RemoveUntranslatableAbs32(image_, {Traits::kBitness, kElfImageBase},
+                                translator_, &abs32_locations_);
+  LOG_IF(WARNING, num_untranslatable) << "Removed " << num_untranslatable
+                                      << " untranslatable abs32 references.";
+
+  // Abs32 reference bodies must not overlap. If found, simply remove them.
+  size_t num_overlapping =
+      RemoveOverlappingAbs32Locations(kAbs32Width, &abs32_locations_);
+  LOG_IF(WARNING, num_overlapping)
+      << "Removed " << num_overlapping
+      << " abs32 references with overlapping bodies.";
+
+  abs32_locations_.shrink_to_fit();
+}
+
+template <class TRAITS>
+void DisassemblerElf<TRAITS>::GetRel32FromCodeSections() {
+  for (const typename Traits::Elf_Shdr* section : exec_headers_)
+    ParseExecSection(*section);
+  PostProcessRel32();
+}
+
+template <class TRAITS>
+void DisassemblerElf<TRAITS>::ParseSections() {
+  ExtractInterestingSectionHeaders();
+  GetAbs32FromRelocSections();
+  GetRel32FromCodeSections();
+}
+
+/******** DisassemblerElfIntel ********/
+
+template <class TRAITS>
+DisassemblerElfIntel<TRAITS>::DisassemblerElfIntel() = default;
+
+template <class TRAITS>
+DisassemblerElfIntel<TRAITS>::~DisassemblerElfIntel() = default;
+
+template <class TRAITS>
+std::vector<ReferenceGroup> DisassemblerElfIntel<TRAITS>::MakeReferenceGroups()
+    const {
+  return {
+      {ReferenceTypeTraits{sizeof(TRAITS::Elf_Rel::r_offset), TypeTag(kReloc),
+                           PoolTag(kReloc)},
+       &DisassemblerElfIntel<TRAITS>::MakeReadRelocs,
+       &DisassemblerElfIntel<TRAITS>::MakeWriteRelocs},
+      {ReferenceTypeTraits{Traits::kVAWidth, TypeTag(kAbs32), PoolTag(kAbs32)},
+       &DisassemblerElfIntel<TRAITS>::MakeReadAbs32,
+       &DisassemblerElfIntel<TRAITS>::MakeWriteAbs32},
+      // N.B.: Rel32 |width| is 4 bytes, even for x64.
+      {ReferenceTypeTraits{4, TypeTag(kRel32), PoolTag(kRel32)},
+       &DisassemblerElfIntel<TRAITS>::MakeReadRel32,
+       &DisassemblerElfIntel<TRAITS>::MakeWriteRel32}};
+}
+
+template <class TRAITS>
+void DisassemblerElfIntel<TRAITS>::ParseExecSection(
+    const typename TRAITS::Elf_Shdr& section) {
+  constexpr int kAbs32Width = Traits::kVAWidth;
+
+  // |this->| is needed to access protected members of templated base class. To
+  // reduce noise, use local references for these.
+  ConstBufferView& image_ = this->image_;
+  const AddressTranslator& translator_ = this->translator_;
+  auto& abs32_locations_ = this->abs32_locations_;
+
+  // Range of values was ensured in ParseHeader().
+  rva_t start_rva = base::checked_cast<rva_t>(section.sh_addr);
+  rva_t end_rva = base::checked_cast<rva_t>(start_rva + section.sh_size);
+
+  AddressTranslator::RvaToOffsetCache target_rva_checker(translator_);
+
+  ConstBufferView region(image_.begin() + section.sh_offset, section.sh_size);
+  Abs32GapFinder gap_finder(image_, region, abs32_locations_, kAbs32Width);
+  typename TRAITS::Rel32FinderUse rel_finder(image_, translator_);
+  // Iterate over gaps between abs32 references, to avoid collision.
+  while (gap_finder.FindNext()) {
+    rel_finder.SetRegion(gap_finder.GetGap());
+    while (rel_finder.FindNext()) {
+      auto rel32 = rel_finder.GetRel32();
+      if (target_rva_checker.IsValid(rel32.target_rva) &&
+          (rel32.can_point_outside_section ||
+           (start_rva <= rel32.target_rva && rel32.target_rva < end_rva))) {
+        rel_finder.Accept();
+        rel32_locations_.push_back(rel32.location);
+      }
+    }
+  }
+}
+
+template <class TRAITS>
+void DisassemblerElfIntel<TRAITS>::PostProcessRel32() {
+  rel32_locations_.shrink_to_fit();
+  std::sort(rel32_locations_.begin(), rel32_locations_.end());
+}
+
+template <class TRAITS>
+std::unique_ptr<ReferenceReader> DisassemblerElfIntel<TRAITS>::MakeReadAbs32(
+    offset_t lo,
+    offset_t hi) {
+  // TODO(huangs): Don't use Abs32RvaExtractorWin32 here; use new class that
+  // caters to different ELF architectures.
+  Abs32RvaExtractorWin32 abs_rva_extractor(
+      this->image_, AbsoluteAddress(TRAITS::kBitness, kElfImageBase),
+      this->abs32_locations_, lo, hi);
+  return std::make_unique<Abs32ReaderWin32>(std::move(abs_rva_extractor),
+                                            this->translator_);
+}
+
+template <class TRAITS>
+std::unique_ptr<ReferenceWriter> DisassemblerElfIntel<TRAITS>::MakeWriteAbs32(
+    MutableBufferView image) {
+  return std::make_unique<Abs32WriterWin32>(
+      image, AbsoluteAddress(TRAITS::kBitness, kElfImageBase),
+      this->translator_);
+}
+
+template <class TRAITS>
+std::unique_ptr<ReferenceReader> DisassemblerElfIntel<TRAITS>::MakeReadRel32(
+    offset_t lo,
+    offset_t hi) {
+  return std::make_unique<Rel32ReaderX86>(this->image_, lo, hi,
+                                          &rel32_locations_, this->translator_);
+}
+
+template <class TRAITS>
+std::unique_ptr<ReferenceWriter> DisassemblerElfIntel<TRAITS>::MakeWriteRel32(
+    MutableBufferView image) {
+  return std::make_unique<Rel32WriterX86>(image, this->translator_);
+}
+
+// Explicit instantiation for supported classes.
+template class DisassemblerElfIntel<Elf32IntelTraits>;
+template class DisassemblerElfIntel<Elf64IntelTraits>;
+template bool DisassemblerElf<Elf32IntelTraits>::QuickDetect(
+    ConstBufferView image);
+template bool DisassemblerElf<Elf64IntelTraits>::QuickDetect(
+    ConstBufferView image);
+
+/******** DisassemblerElfArm ********/
+
+template <class Traits>
+DisassemblerElfArm<Traits>::DisassemblerElfArm() = default;
+
+template <class Traits>
+DisassemblerElfArm<Traits>::~DisassemblerElfArm() = default;
+
+template <class Traits>
+bool DisassemblerElfArm<Traits>::IsTargetOffsetInExecSection(
+    offset_t offset) const {
+  // Executable sections can appear in large numbers in .o files and in
+  // pathological cases. Since this function may be called for each reference
+  // candidate, linear search may be too slow (so use binary search).
+  return IsTargetOffsetInElfSectionList(this->exec_headers_, offset);
+}
+
+template <class Traits>
+void DisassemblerElfArm<Traits>::ParseExecSection(
+    const typename Traits::Elf_Shdr& section) {
+  ConstBufferView& image_ = this->image_;
+  const AddressTranslator& translator_ = this->translator_;
+  auto& abs32_locations_ = this->abs32_locations_;
+
+  ConstBufferView region(image_.begin() + section.sh_offset, section.sh_size);
+  Abs32GapFinder gap_finder(image_, region, abs32_locations_, Traits::kVAWidth);
+  std::unique_ptr<typename Traits::Rel32FinderUse> rel_finder =
+      MakeRel32Finder(section);
+  AddressTranslator::RvaToOffsetCache rva_to_offset(translator_);
+  while (gap_finder.FindNext()) {
+    rel_finder->SetRegion(gap_finder.GetGap());
+    while (rel_finder->FindNext()) {
+      auto rel32 = rel_finder->GetRel32();
+      offset_t target_offset = rva_to_offset.Convert(rel32.target_rva);
+      if (target_offset != kInvalidOffset) {
+        // For robustness, reject illegal offsets, which can arise from, e.g.,
+        // misidentify ARM vs. THUMB2 mode, or even misidentifying data as code!
+        if (IsTargetOffsetInExecSection(target_offset)) {
+          rel_finder->Accept();
+          rel32_locations_table_[rel32.type].push_back(rel32.location);
+        }
+      }
+    }
+  }
+}
+
+template <class Traits>
+void DisassemblerElfArm<Traits>::PostProcessRel32() {
+  for (int type = 0; type < AArch32Rel32Translator::NUM_ADDR_TYPE; ++type) {
+    std::sort(rel32_locations_table_[type].begin(),
+              rel32_locations_table_[type].end());
+    rel32_locations_table_[type].shrink_to_fit();
+  }
+}
+
+template <class Traits>
+std::unique_ptr<ReferenceReader> DisassemblerElfArm<Traits>::MakeReadAbs32(
+    offset_t lo,
+    offset_t hi) {
+  // TODO(huangs): Reconcile the use of Win32-specific classes in ARM code!
+  Abs32RvaExtractorWin32 abs_rva_extractor(this->image_,
+                                           AbsoluteAddress(Traits::kBitness, 0),
+                                           this->abs32_locations_, lo, hi);
+  return std::make_unique<Abs32ReaderWin32>(std::move(abs_rva_extractor),
+                                            this->translator_);
+}
+
+template <class Traits>
+std::unique_ptr<ReferenceWriter> DisassemblerElfArm<Traits>::MakeWriteAbs32(
+    MutableBufferView image) {
+  return std::make_unique<Abs32WriterWin32>(
+      image, AbsoluteAddress(Traits::kBitness, 0), this->translator_);
+}
+
+template <class TRAITS>
+template <class ADDR_TRAITS>
+std::unique_ptr<ReferenceReader> DisassemblerElfArm<TRAITS>::MakeReadRel32(
+    offset_t lower,
+    offset_t upper) {
+  return std::make_unique<Rel32ReaderArm<ADDR_TRAITS>>(
+      this->translator_, this->image_,
+      this->rel32_locations_table_[ADDR_TRAITS::addr_type], lower, upper);
+}
+
+template <class TRAITS>
+template <class ADDR_TRAITS>
+std::unique_ptr<ReferenceWriter> DisassemblerElfArm<TRAITS>::MakeWriteRel32(
+    MutableBufferView image) {
+  return std::make_unique<Rel32WriterArm<ADDR_TRAITS>>(this->translator_,
+                                                       image);
+}
+
+/******** DisassemblerElfAArch32 ********/
+
+DisassemblerElfAArch32::DisassemblerElfAArch32() = default;
+DisassemblerElfAArch32::~DisassemblerElfAArch32() = default;
+
+std::vector<ReferenceGroup> DisassemblerElfAArch32::MakeReferenceGroups()
+    const {
+  return {
+      {ReferenceTypeTraits{sizeof(Traits::Elf_Rel::r_offset),
+                           TypeTag(AArch32ReferenceType::kReloc),
+                           PoolTag(ArmReferencePool::kPoolReloc)},
+       &DisassemblerElfAArch32::MakeReadRelocs,
+       &DisassemblerElfAArch32::MakeWriteRelocs},
+      {ReferenceTypeTraits{Traits::kVAWidth,
+                           TypeTag(AArch32ReferenceType::kAbs32),
+                           PoolTag(ArmReferencePool::kPoolAbs32)},
+       &DisassemblerElfAArch32::MakeReadAbs32,
+       &DisassemblerElfAArch32::MakeWriteAbs32},
+      {ReferenceTypeTraits{4, TypeTag(AArch32ReferenceType::kRel32_A24),
+                           PoolTag(ArmReferencePool::kPoolRel32)},
+       &DisassemblerElfAArch32::MakeReadRel32<
+           AArch32Rel32Translator::AddrTraits_A24>,
+       &DisassemblerElfAArch32::MakeWriteRel32<
+           AArch32Rel32Translator::AddrTraits_A24>},
+      {ReferenceTypeTraits{2, TypeTag(AArch32ReferenceType::kRel32_T8),
+                           PoolTag(ArmReferencePool::kPoolRel32)},
+       &DisassemblerElfAArch32::MakeReadRel32<
+           AArch32Rel32Translator::AddrTraits_T8>,
+       &DisassemblerElfAArch32::MakeWriteRel32<
+           AArch32Rel32Translator::AddrTraits_T8>},
+      {ReferenceTypeTraits{2, TypeTag(AArch32ReferenceType::kRel32_T11),
+                           PoolTag(ArmReferencePool::kPoolRel32)},
+       &DisassemblerElfAArch32::MakeReadRel32<
+           AArch32Rel32Translator::AddrTraits_T11>,
+       &DisassemblerElfAArch32::MakeWriteRel32<
+           AArch32Rel32Translator::AddrTraits_T11>},
+      {ReferenceTypeTraits{4, TypeTag(AArch32ReferenceType::kRel32_T20),
+                           PoolTag(ArmReferencePool::kPoolRel32)},
+       &DisassemblerElfAArch32::MakeReadRel32<
+           AArch32Rel32Translator::AddrTraits_T20>,
+       &DisassemblerElfAArch32::MakeWriteRel32<
+           AArch32Rel32Translator::AddrTraits_T20>},
+      {ReferenceTypeTraits{4, TypeTag(AArch32ReferenceType::kRel32_T24),
+                           PoolTag(ArmReferencePool::kPoolRel32)},
+       &DisassemblerElfAArch32::MakeReadRel32<
+           AArch32Rel32Translator::AddrTraits_T24>,
+       &DisassemblerElfAArch32::MakeWriteRel32<
+           AArch32Rel32Translator::AddrTraits_T24>},
+  };
+}
+
+std::unique_ptr<DisassemblerElfAArch32::Traits::Rel32FinderUse>
+DisassemblerElfAArch32::MakeRel32Finder(
+    const typename Traits::Elf_Shdr& section) {
+  return std::make_unique<Rel32FinderAArch32>(image_, translator_,
+                                              IsExecSectionThumb2(section));
+}
+
+bool DisassemblerElfAArch32::IsExecSectionThumb2(
+    const typename Traits::Elf_Shdr& section) const {
+  // ARM mode requires 4-byte alignment.
+  if (section.sh_addr % 4 != 0 || section.sh_size % 4 != 0)
+    return true;
+  const uint8_t* first = image_.begin() + section.sh_offset;
+  const uint8_t* end = first + section.sh_size;
+  // Each instruction in 32-bit ARM (little-endian) looks like
+  //   ?? ?? ?? X?,
+  // where X specifies conditional execution. X = 0xE represents AL = "ALways
+  // execute", and tends to appear very often. We use this as our main indicator
+  // to discern 32-bit ARM mode from THUMB2 mode.
+  size_t num = 0;
+  size_t den = 0;
+  for (const uint8_t* cur = first; cur < end; cur += 4) {
+    // |cur[3]| is within bounds because |end - cur| is a multiple of 4.
+    uint8_t maybe_cond = cur[3] & 0xF0;
+    if (maybe_cond == 0xE0)
+      ++num;
+    ++den;
+  }
+
+  if (den > 0) {
+    LOG(INFO) << "Section scan: " << num << " / " << den << " => "
+              << base::StringPrintf("%.2f", num * 100.0 / den) << "%";
+  }
+  return num < den * kAArch32BitCondAlwaysDensityThreshold;
+}
+
+/******** DisassemblerElfAArch64 ********/
+
+DisassemblerElfAArch64::DisassemblerElfAArch64() = default;
+
+DisassemblerElfAArch64::~DisassemblerElfAArch64() = default;
+
+std::vector<ReferenceGroup> DisassemblerElfAArch64::MakeReferenceGroups()
+    const {
+  return {
+      {ReferenceTypeTraits{sizeof(Traits::Elf_Rel::r_offset),
+                           TypeTag(AArch64ReferenceType::kReloc),
+                           PoolTag(ArmReferencePool::kPoolReloc)},
+       &DisassemblerElfAArch64::MakeReadRelocs,
+       &DisassemblerElfAArch64::MakeWriteRelocs},
+      {ReferenceTypeTraits{Traits::kVAWidth,
+                           TypeTag(AArch64ReferenceType::kAbs32),
+                           PoolTag(ArmReferencePool::kPoolAbs32)},
+       &DisassemblerElfAArch64::MakeReadAbs32,
+       &DisassemblerElfAArch64::MakeWriteAbs32},
+      {ReferenceTypeTraits{4, TypeTag(AArch64ReferenceType::kRel32_Immd14),
+                           PoolTag(ArmReferencePool::kPoolRel32)},
+       &DisassemblerElfAArch64::MakeReadRel32<
+           AArch64Rel32Translator::AddrTraits_Immd14>,
+       &DisassemblerElfAArch64::MakeWriteRel32<
+           AArch64Rel32Translator::AddrTraits_Immd14>},
+      {ReferenceTypeTraits{4, TypeTag(AArch64ReferenceType::kRel32_Immd19),
+                           PoolTag(ArmReferencePool::kPoolRel32)},
+       &DisassemblerElfAArch64::MakeReadRel32<
+           AArch64Rel32Translator::AddrTraits_Immd19>,
+       &DisassemblerElfAArch64::MakeWriteRel32<
+           AArch64Rel32Translator::AddrTraits_Immd19>},
+      {ReferenceTypeTraits{4, TypeTag(AArch64ReferenceType::kRel32_Immd26),
+                           PoolTag(ArmReferencePool::kPoolRel32)},
+       &DisassemblerElfAArch64::MakeReadRel32<
+           AArch64Rel32Translator::AddrTraits_Immd26>,
+       &DisassemblerElfAArch64::MakeWriteRel32<
+           AArch64Rel32Translator::AddrTraits_Immd26>},
+  };
+}
+
+std::unique_ptr<DisassemblerElfAArch64::Traits::Rel32FinderUse>
+DisassemblerElfAArch64::MakeRel32Finder(
+    const typename Traits::Elf_Shdr& section) {
+  return std::make_unique<Rel32FinderAArch64>(image_, translator_);
+}
+
+// Explicit instantiation for supported classes.
+template class DisassemblerElfArm<ElfAArch32Traits>;
+template class DisassemblerElfArm<ElfAArch64Traits>;
+template bool DisassemblerElf<ElfAArch32Traits>::QuickDetect(
+    ConstBufferView image);
+template bool DisassemblerElf<ElfAArch64Traits>::QuickDetect(
+    ConstBufferView image);
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/disassembler_no_op.cc b/native/zucchini/vendor/zucchini/disassembler_no_op.cc
new file mode 100644
index 0000000..b17979c
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/disassembler_no_op.cc
@@ -0,0 +1,31 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/disassembler_no_op.h"
+
+namespace zucchini {
+
+// |num_equivalence_iterations_| = 1 since no pointers are present.
+DisassemblerNoOp::DisassemblerNoOp() : Disassembler(1) {}
+
+DisassemblerNoOp::~DisassemblerNoOp() = default;
+
+ExecutableType DisassemblerNoOp::GetExeType() const {
+  return kExeTypeNoOp;
+}
+
+std::string DisassemblerNoOp::GetExeTypeString() const {
+  return "(Unknown)";
+}
+
+std::vector<ReferenceGroup> DisassemblerNoOp::MakeReferenceGroups() const {
+  return std::vector<ReferenceGroup>();
+}
+
+bool DisassemblerNoOp::Parse(ConstBufferView image) {
+  image_ = image;
+  return true;
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/element_detection.cc b/native/zucchini/vendor/zucchini/element_detection.cc
new file mode 100644
index 0000000..4d4a1c6
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/element_detection.cc
@@ -0,0 +1,200 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/element_detection.h"
+
+#include <utility>
+
+#include "components/zucchini/buildflags.h"
+#include "components/zucchini/disassembler.h"
+#include "components/zucchini/disassembler_no_op.h"
+#include "components/zucchini/version_info.h"
+
+#if BUILDFLAG(ENABLE_DEX)
+#include "components/zucchini/disassembler_dex.h"
+#endif  // BUILDFLAG(ENABLE_DEX)
+
+#if BUILDFLAG(ENABLE_ELF)
+#include "components/zucchini/disassembler_elf.h"
+#endif  // BUILDFLAG(ENABLE_ELF)
+
+#if BUILDFLAG(ENABLE_WIN)
+#include "components/zucchini/disassembler_win32.h"
+#endif  // BUILDFLAG(ENABLE_WIN)
+
+#if BUILDFLAG(ENABLE_ZTF)
+#include "components/zucchini/disassembler_ztf.h"
+#endif  // BUILDFLAG(ENABLE_ZTF)
+
+namespace zucchini {
+
+namespace {
+
+// Impose a minimal program size to eliminate pathological cases.
+enum : size_t { kMinProgramSize = 16 };
+
+}  // namespace
+
+/******** Utility Functions ********/
+
+std::unique_ptr<Disassembler> MakeDisassemblerWithoutFallback(
+    ConstBufferView image) {
+#if BUILDFLAG(ENABLE_WIN)
+  if (DisassemblerWin32X86::QuickDetect(image)) {
+    auto disasm = Disassembler::Make<DisassemblerWin32X86>(image);
+    if (disasm && disasm->size() >= kMinProgramSize)
+      return disasm;
+  }
+
+  if (DisassemblerWin32X64::QuickDetect(image)) {
+    auto disasm = Disassembler::Make<DisassemblerWin32X64>(image);
+    if (disasm && disasm->size() >= kMinProgramSize)
+      return disasm;
+  }
+#endif  // BUILDFLAG(ENABLE_WIN)
+
+#if BUILDFLAG(ENABLE_ELF)
+  if (DisassemblerElfX86::QuickDetect(image)) {
+    auto disasm = Disassembler::Make<DisassemblerElfX86>(image);
+    if (disasm && disasm->size() >= kMinProgramSize)
+      return disasm;
+  }
+
+  if (DisassemblerElfX64::QuickDetect(image)) {
+    auto disasm = Disassembler::Make<DisassemblerElfX64>(image);
+    if (disasm && disasm->size() >= kMinProgramSize)
+      return disasm;
+  }
+
+  if (DisassemblerElfAArch32::QuickDetect(image)) {
+    auto disasm = Disassembler::Make<DisassemblerElfAArch32>(image);
+    if (disasm && disasm->size() >= kMinProgramSize)
+      return disasm;
+  }
+
+  if (DisassemblerElfAArch64::QuickDetect(image)) {
+    auto disasm = Disassembler::Make<DisassemblerElfAArch64>(image);
+    if (disasm && disasm->size() >= kMinProgramSize)
+      return disasm;
+  }
+#endif  // BUILDFLAG(ENABLE_ELF)
+
+#if BUILDFLAG(ENABLE_DEX)
+  if (DisassemblerDex::QuickDetect(image)) {
+    auto disasm = Disassembler::Make<DisassemblerDex>(image);
+    if (disasm && disasm->size() >= kMinProgramSize)
+      return disasm;
+  }
+#endif  // BUILDFLAG(ENABLE_DEX)
+
+#if BUILDFLAG(ENABLE_ZTF)
+  if (DisassemblerZtf::QuickDetect(image)) {
+    // This disallows very short examples like "ZTxtxtZ\n" in ensemble patching.
+    auto disasm = Disassembler::Make<DisassemblerZtf>(image);
+    if (disasm && disasm->size() >= kMinProgramSize)
+      return disasm;
+  }
+#endif  // BUILDFLAG(ENABLE_ZTF)
+
+  return nullptr;
+}
+
+std::unique_ptr<Disassembler> MakeDisassemblerOfType(ConstBufferView image,
+                                                     ExecutableType exe_type) {
+  switch (exe_type) {
+#if BUILDFLAG(ENABLE_WIN)
+    case kExeTypeWin32X86:
+      return Disassembler::Make<DisassemblerWin32X86>(image);
+    case kExeTypeWin32X64:
+      return Disassembler::Make<DisassemblerWin32X64>(image);
+#endif  // BUILDFLAG(ENABLE_WIN)
+#if BUILDFLAG(ENABLE_ELF)
+    case kExeTypeElfX86:
+      return Disassembler::Make<DisassemblerElfX86>(image);
+    case kExeTypeElfX64:
+      return Disassembler::Make<DisassemblerElfX64>(image);
+    case kExeTypeElfAArch32:
+      return Disassembler::Make<DisassemblerElfAArch32>(image);
+    case kExeTypeElfAArch64:
+      return Disassembler::Make<DisassemblerElfAArch64>(image);
+#endif  // BUILDFLAG(ENABLE_ELF)
+#if BUILDFLAG(ENABLE_DEX)
+    case kExeTypeDex:
+      return Disassembler::Make<DisassemblerDex>(image);
+#endif  // BUILDFLAG(ENABLE_DEX)
+#if BUILDFLAG(ENABLE_ZTF)
+    case kExeTypeZtf:
+      return Disassembler::Make<DisassemblerZtf>(image);
+#endif  // BUILDFLAG(ENABLE_ZTF)
+    case kExeTypeNoOp:
+      return Disassembler::Make<DisassemblerNoOp>(image);
+    default:
+      // If an architecture is disabled then null is handled gracefully.
+      return nullptr;
+  }
+}
+
+uint16_t DisassemblerVersionOfType(ExecutableType exe_type) {
+  switch (exe_type) {
+#if BUILDFLAG(ENABLE_WIN)
+    case kExeTypeWin32X86:
+      return DisassemblerWin32X86::kVersion;
+    case kExeTypeWin32X64:
+      return DisassemblerWin32X64::kVersion;
+#endif  // BUILDFLAG(ENABLE_WIN)
+#if BUILDFLAG(ENABLE_ELF)
+    case kExeTypeElfX86:
+      return DisassemblerElfX86::kVersion;
+    case kExeTypeElfX64:
+      return DisassemblerElfX64::kVersion;
+    case kExeTypeElfAArch32:
+      return DisassemblerElfAArch32::kVersion;
+    case kExeTypeElfAArch64:
+      return DisassemblerElfAArch64::kVersion;
+#endif  // BUILDFLAG(ENABLE_ELF)
+#if BUILDFLAG(ENABLE_DEX)
+    case kExeTypeDex:
+      return DisassemblerDex::kVersion;
+#endif  // BUILDFLAG(ENABLE_DEX)
+#if BUILDFLAG(ENABLE_ZTF)
+    case kExeTypeZtf:
+      return DisassemblerZtf::kVersion;
+#endif  // BUILDFLAG(ENABLE_ZTF)
+    case kExeTypeNoOp:
+      return DisassemblerNoOp::kVersion;
+    default:
+      // If an architecture is disabled then null is handled gracefully.
+      return kInvalidVersion;
+  }
+}
+
+std::optional<Element> DetectElementFromDisassembler(ConstBufferView image) {
+  std::unique_ptr<Disassembler> disasm = MakeDisassemblerWithoutFallback(image);
+  if (disasm)
+    return Element({0, disasm->size()}, disasm->GetExeType());
+  return std::nullopt;
+}
+
+/******** ProgramScanner ********/
+
+ElementFinder::ElementFinder(ConstBufferView image, ElementDetector&& detector)
+    : image_(image), detector_(std::move(detector)) {}
+
+ElementFinder::~ElementFinder() = default;
+
+std::optional<Element> ElementFinder::GetNext() {
+  for (; pos_ < image_.size(); ++pos_) {
+    ConstBufferView test_image =
+        ConstBufferView::FromRange(image_.begin() + pos_, image_.end());
+    std::optional<Element> element = detector_.Run(test_image);
+    if (element) {
+      element->offset += pos_;
+      pos_ = element->EndOffset();
+      return element;
+    }
+  }
+  return std::nullopt;
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/equivalence_map.cc b/native/zucchini/vendor/zucchini/equivalence_map.cc
new file mode 100644
index 0000000..b4d5e27
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/equivalence_map.cc
@@ -0,0 +1,549 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/equivalence_map.h"
+
+#include <algorithm>
+#include <utility>
+
+#include "base/containers/cxx20_erase.h"
+#include "base/logging.h"
+#include "base/numerics/safe_conversions.h"
+#include "components/zucchini/encoded_view.h"
+#include "components/zucchini/patch_reader.h"
+#include "components/zucchini/suffix_array.h"
+
+namespace zucchini {
+
+namespace {
+
+// TODO(haungs): Tune these numbers to improve pathological case results.
+
+// In pathological cases Zucchini can exhibit O(n^2) behavior if the seed
+// selection process runs to completion. To prevent this we impose a quota for
+// the total length of equivalences the seed selection process can perform
+// trials on. For regular use cases it is unlikely this quota will be exceeded,
+// and if it is the effects on patch size are expected to be small.
+constexpr uint64_t kSeedSelectionTotalVisitLengthQuota = 1 << 18;  // 256 KiB
+
+// The aforementioned quota alone is insufficient, as exploring backwards will
+// still be very successful resulting in O(n) behavior in the case of a limited
+// seed selection trials. This results in O(n^2) behavior returning. To mitigate
+// this we also impose a cap on the ExtendEquivalenceBackward() exploration.
+constexpr offset_t kBackwardsExtendLimit = 1 << 16;  // 64 KiB
+
+}  // namespace
+
+/******** Utility Functions ********/
+
+double GetTokenSimilarity(
+    const ImageIndex& old_image_index,
+    const ImageIndex& new_image_index,
+    const std::vector<TargetsAffinity>& targets_affinities,
+    offset_t src,
+    offset_t dst) {
+  DCHECK(old_image_index.IsToken(src));
+  DCHECK(new_image_index.IsToken(dst));
+
+  TypeTag old_type = old_image_index.LookupType(src);
+  TypeTag new_type = new_image_index.LookupType(dst);
+  if (old_type != new_type)
+    return kMismatchFatal;
+
+  // Raw comparison.
+  if (!old_image_index.IsReference(src) && !new_image_index.IsReference(dst)) {
+    return old_image_index.GetRawValue(src) == new_image_index.GetRawValue(dst)
+               ? 1.0
+               : -1.5;
+  }
+
+  const ReferenceSet& old_ref_set = old_image_index.refs(old_type);
+  const ReferenceSet& new_ref_set = new_image_index.refs(new_type);
+  Reference old_reference = old_ref_set.at(src);
+  Reference new_reference = new_ref_set.at(dst);
+  PoolTag pool_tag = old_ref_set.pool_tag();
+
+  double affinity = targets_affinities[pool_tag.value()].AffinityBetween(
+      old_ref_set.target_pool().KeyForOffset(old_reference.target),
+      new_ref_set.target_pool().KeyForOffset(new_reference.target));
+
+  // Both targets are not associated, which implies a weak match.
+  if (affinity == 0.0)
+    return 0.5 * old_ref_set.width();
+
+  // At least one target is associated, so values are compared.
+  return affinity > 0.0 ? old_ref_set.width() : -2.0;
+}
+
+double GetEquivalenceSimilarity(
+    const ImageIndex& old_image_index,
+    const ImageIndex& new_image_index,
+    const std::vector<TargetsAffinity>& targets_affinities,
+    const Equivalence& equivalence) {
+  double similarity = 0.0;
+  for (offset_t k = 0; k < equivalence.length; ++k) {
+    // Non-tokens are joined with the nearest previous token: skip until we
+    // cover the unit.
+    if (!new_image_index.IsToken(equivalence.dst_offset + k))
+      continue;
+
+    similarity += GetTokenSimilarity(
+        old_image_index, new_image_index, targets_affinities,
+        equivalence.src_offset + k, equivalence.dst_offset + k);
+    if (similarity == kMismatchFatal)
+      return kMismatchFatal;
+  }
+  return similarity;
+}
+
+EquivalenceCandidate ExtendEquivalenceForward(
+    const ImageIndex& old_image_index,
+    const ImageIndex& new_image_index,
+    const std::vector<TargetsAffinity>& targets_affinities,
+    const EquivalenceCandidate& candidate,
+    double min_similarity) {
+  Equivalence equivalence = candidate.eq;
+  offset_t best_k = equivalence.length;
+  double current_similarity = candidate.similarity;
+  double best_similarity = current_similarity;
+  double current_penalty = min_similarity;
+  for (offset_t k = best_k;
+       equivalence.src_offset + k < old_image_index.size() &&
+       equivalence.dst_offset + k < new_image_index.size();
+       ++k) {
+    // Mismatch in type, |candidate| cannot be extended further.
+    if (old_image_index.LookupType(equivalence.src_offset + k) !=
+        new_image_index.LookupType(equivalence.dst_offset + k)) {
+      break;
+    }
+
+    if (!new_image_index.IsToken(equivalence.dst_offset + k)) {
+      // Non-tokens are joined with the nearest previous token: skip until we
+      // cover the unit, and extend |best_k| if applicable.
+      if (best_k == k)
+        best_k = k + 1;
+      continue;
+    }
+
+    double similarity = GetTokenSimilarity(
+        old_image_index, new_image_index, targets_affinities,
+        equivalence.src_offset + k, equivalence.dst_offset + k);
+    current_similarity += similarity;
+    current_penalty = std::max(0.0, current_penalty) - similarity;
+
+    if (current_similarity < 0.0 || current_penalty >= min_similarity)
+      break;
+    if (current_similarity >= best_similarity) {
+      best_similarity = current_similarity;
+      best_k = k + 1;
+    }
+  }
+  equivalence.length = best_k;
+  return {equivalence, best_similarity};
+}
+
+EquivalenceCandidate ExtendEquivalenceBackward(
+    const ImageIndex& old_image_index,
+    const ImageIndex& new_image_index,
+    const std::vector<TargetsAffinity>& targets_affinities,
+    const EquivalenceCandidate& candidate,
+    double min_similarity) {
+  Equivalence equivalence = candidate.eq;
+  offset_t best_k = 0;
+  double current_similarity = candidate.similarity;
+  double best_similarity = current_similarity;
+  double current_penalty = 0.0;
+  offset_t k_min = std::min(
+      {equivalence.dst_offset, equivalence.src_offset, kBackwardsExtendLimit});
+  for (offset_t k = 1; k <= k_min; ++k) {
+    // Mismatch in type, |candidate| cannot be extended further.
+    if (old_image_index.LookupType(equivalence.src_offset - k) !=
+        new_image_index.LookupType(equivalence.dst_offset - k)) {
+      break;
+    }
+
+    // Non-tokens are joined with the nearest previous token: skip until we
+    // reach the next token.
+    if (!new_image_index.IsToken(equivalence.dst_offset - k))
+      continue;
+
+    DCHECK_EQ(old_image_index.LookupType(equivalence.src_offset - k),
+              new_image_index.LookupType(equivalence.dst_offset -
+                                         k));  // Sanity check.
+    double similarity = GetTokenSimilarity(
+        old_image_index, new_image_index, targets_affinities,
+        equivalence.src_offset - k, equivalence.dst_offset - k);
+
+    current_similarity += similarity;
+    current_penalty = std::max(0.0, current_penalty) - similarity;
+
+    if (current_similarity < 0.0 || current_penalty >= min_similarity)
+      break;
+    if (current_similarity >= best_similarity) {
+      best_similarity = current_similarity;
+      best_k = k;
+    }
+  }
+
+  equivalence.dst_offset -= best_k;
+  equivalence.src_offset -= best_k;
+  equivalence.length += best_k;
+  return {equivalence, best_similarity};
+}
+
+EquivalenceCandidate VisitEquivalenceSeed(
+    const ImageIndex& old_image_index,
+    const ImageIndex& new_image_index,
+    const std::vector<TargetsAffinity>& targets_affinities,
+    offset_t src,
+    offset_t dst,
+    double min_similarity) {
+  EquivalenceCandidate candidate{{src, dst, 0}, 0.0};  // Empty.
+  if (!old_image_index.IsToken(src))
+    return candidate;
+  candidate =
+      ExtendEquivalenceForward(old_image_index, new_image_index,
+                               targets_affinities, candidate, min_similarity);
+  if (candidate.similarity < min_similarity)
+    return candidate;  // Not worth exploring any more.
+  return ExtendEquivalenceBackward(old_image_index, new_image_index,
+                                   targets_affinities, candidate,
+                                   min_similarity);
+}
+
+/******** OffsetMapper ********/
+
+OffsetMapper::OffsetMapper(std::deque<Equivalence>&& equivalences,
+                           offset_t old_image_size,
+                           offset_t new_image_size)
+    : equivalences_(std::move(equivalences)),
+      old_image_size_(old_image_size),
+      new_image_size_(new_image_size) {
+  DCHECK_GT(new_image_size_, 0U);
+  DCHECK(std::is_sorted(equivalences_.begin(), equivalences_.end(),
+                        [](const Equivalence& a, const Equivalence& b) {
+                          return a.src_offset < b.src_offset;
+                        }));
+  // This is for testing. Assume pruned.
+}
+
+OffsetMapper::OffsetMapper(EquivalenceSource&& equivalence_source,
+                           offset_t old_image_size,
+                           offset_t new_image_size)
+    : old_image_size_(old_image_size), new_image_size_(new_image_size) {
+  DCHECK_GT(new_image_size_, 0U);
+  for (auto e = equivalence_source.GetNext(); e.has_value();
+       e = equivalence_source.GetNext()) {
+    equivalences_.push_back(*e);
+  }
+  PruneEquivalencesAndSortBySource(&equivalences_);
+}
+
+OffsetMapper::OffsetMapper(const EquivalenceMap& equivalence_map,
+                           offset_t old_image_size,
+                           offset_t new_image_size)
+    : equivalences_(equivalence_map.size()),
+      old_image_size_(old_image_size),
+      new_image_size_(new_image_size) {
+  DCHECK_GT(new_image_size_, 0U);
+  std::transform(equivalence_map.begin(), equivalence_map.end(),
+                 equivalences_.begin(),
+                 [](const EquivalenceCandidate& c) { return c.eq; });
+  PruneEquivalencesAndSortBySource(&equivalences_);
+}
+
+OffsetMapper::~OffsetMapper() = default;
+
+// Safely evaluates |offset - unit.src_offset + unit.dst_offset| with signed
+// arithmetic, then clips the result to |[0, new_image_size_)|.
+offset_t OffsetMapper::NaiveExtendedForwardProject(const Equivalence& unit,
+                                                   offset_t offset) const {
+  int64_t old_offset64 = offset;
+  int64_t src_offset64 = unit.src_offset;
+  int64_t dst_offset64 = unit.dst_offset;
+  uint64_t new_offset64 = std::min<uint64_t>(
+      std::max<int64_t>(0LL, old_offset64 - src_offset64 + dst_offset64),
+      new_image_size_ - 1);
+  return base::checked_cast<offset_t>(new_offset64);
+}
+
+offset_t OffsetMapper::ExtendedForwardProject(offset_t offset) const {
+  DCHECK(!equivalences_.empty());
+  if (offset < old_image_size_) {
+    // Finds the equivalence unit whose "old" block is nearest to |offset|,
+    // favoring the block with lower offset in case of a tie.
+    auto pos = std::upper_bound(
+        equivalences_.begin(), equivalences_.end(), offset,
+        [](offset_t a, const Equivalence& b) { return a < b.src_offset; });
+    // For tiebreaking: |offset - pos[-1].src_end()| is actually 1 less than
+    // |offset|'s distance to "old" block of |pos[-1]|. Therefore "<" is used.
+    if (pos != equivalences_.begin() &&
+        (pos == equivalences_.end() || offset < pos[-1].src_end() ||
+         offset - pos[-1].src_end() < pos->src_offset - offset)) {
+      --pos;
+    }
+    return NaiveExtendedForwardProject(*pos, offset);
+  }
+  // Fake offsets.
+  offset_t delta = offset - old_image_size_;
+  return delta < kOffsetBound - new_image_size_ ? new_image_size_ + delta
+                                                : kOffsetBound - 1;
+}
+
+void OffsetMapper::ForwardProjectAll(std::deque<offset_t>* offsets) const {
+  DCHECK(std::is_sorted(offsets->begin(), offsets->end()));
+  auto current = equivalences_.begin();
+  for (auto& src : *offsets) {
+    while (current != end() && current->src_end() <= src) {
+      ++current;
+    }
+
+    if (current != end() && current->src_offset <= src) {
+      src = src - current->src_offset + current->dst_offset;
+    } else {
+      src = kInvalidOffset;
+    }
+  }
+  base::Erase(*offsets, kInvalidOffset);
+  offsets->shrink_to_fit();
+}
+
+void OffsetMapper::PruneEquivalencesAndSortBySource(
+    std::deque<Equivalence>* equivalences) {
+  std::sort(equivalences->begin(), equivalences->end(),
+            [](const Equivalence& a, const Equivalence& b) {
+              return a.src_offset < b.src_offset;
+            });
+
+  for (auto current = equivalences->begin(); current != equivalences->end();
+       ++current) {
+    // A "reaper" is an equivalence after |current| that overlaps with it, but
+    // is longer, and so truncates |current|.  For example:
+    //  ******  <=  |current|
+    //    **
+    //    ****
+    //      ****
+    //      **********  <= |next| as reaper.
+    // If a reaper is found (as |next|), every equivalence strictly between
+    // |current| and |next| would be truncated to 0 and discarded. Handling this
+    // case is important to avoid O(n^2) behavior.
+    bool next_is_reaper = false;
+
+    // Look ahead to resolve overlaps, until a better candidate is found.
+    auto next = current + 1;
+    for (; next != equivalences->end(); ++next) {
+      DCHECK_GE(next->src_offset, current->src_offset);
+      if (next->src_offset >= current->src_end())
+        break;  // No more overlap.
+
+      if (current->length < next->length) {
+        // |next| is better: So it is a reaper that shrinks |current|.
+        offset_t delta = current->src_end() - next->src_offset;
+        current->length -= delta;
+        next_is_reaper = true;
+        break;
+      }
+    }
+
+    if (next_is_reaper) {
+      // Discard all equivalences strictly between |cur| and |next|.
+      for (auto reduced = current + 1; reduced != next; ++reduced)
+        reduced->length = 0;
+      current = next - 1;
+    } else {
+      // Shrink all equivalences that overlap with |current|. These are all
+      // worse than |current| since no reaper is found.
+      for (auto reduced = current + 1; reduced != next; ++reduced) {
+        offset_t delta = current->src_end() - reduced->src_offset;
+        reduced->length -= std::min(reduced->length, delta);
+        reduced->src_offset += delta;
+        reduced->dst_offset += delta;
+        DCHECK_EQ(reduced->src_offset, current->src_end());
+      }
+    }
+  }
+
+  // Discard all equivalences with length == 0.
+  base::EraseIf(*equivalences, [](const Equivalence& equivalence) {
+    return equivalence.length == 0;
+  });
+  equivalences->shrink_to_fit();
+}
+
+/******** EquivalenceMap ********/
+
+EquivalenceMap::EquivalenceMap() = default;
+
+EquivalenceMap::EquivalenceMap(std::vector<EquivalenceCandidate>&& equivalences)
+    : candidates_(std::move(equivalences)) {
+  SortByDestination();
+}
+
+EquivalenceMap::EquivalenceMap(EquivalenceMap&&) = default;
+
+EquivalenceMap::~EquivalenceMap() = default;
+
+void EquivalenceMap::Build(
+    const std::vector<offset_t>& old_sa,
+    const EncodedView& old_view,
+    const EncodedView& new_view,
+    const std::vector<TargetsAffinity>& targets_affinities,
+    double min_similarity) {
+  DCHECK_EQ(old_sa.size(), old_view.size());
+
+  CreateCandidates(old_sa, old_view, new_view, targets_affinities,
+                   min_similarity);
+  SortByDestination();
+  Prune(old_view, new_view, targets_affinities, min_similarity);
+
+  offset_t coverage = 0;
+  offset_t current_offset = 0;
+  for (auto candidate : candidates_) {
+    DCHECK_GE(candidate.eq.dst_offset, current_offset);
+    coverage += candidate.eq.length;
+    current_offset = candidate.eq.dst_end();
+  }
+  LOG(INFO) << "Equivalence Count: " << size();
+  LOG(INFO) << "Coverage / Extra / Total: " << coverage << " / "
+            << new_view.size() - coverage << " / " << new_view.size();
+}
+
+void EquivalenceMap::CreateCandidates(
+    const std::vector<offset_t>& old_sa,
+    const EncodedView& old_view,
+    const EncodedView& new_view,
+    const std::vector<TargetsAffinity>& targets_affinities,
+    double min_similarity) {
+  candidates_.clear();
+
+  // This is an heuristic to find 'good' equivalences on encoded views.
+  // Equivalences are found in ascending order of |new_image|.
+  offset_t dst_offset = 0;
+
+  while (dst_offset < new_view.size()) {
+    if (!new_view.IsToken(dst_offset)) {
+      ++dst_offset;
+      continue;
+    }
+    auto match =
+        SuffixLowerBound(old_sa, old_view.begin(),
+                         new_view.begin() + dst_offset, new_view.end());
+
+    offset_t next_dst_offset = dst_offset + 1;
+    // TODO(huangs): Clean up.
+    double best_similarity = min_similarity;
+    uint64_t total_visit_length = 0;
+    EquivalenceCandidate best_candidate = {{0, 0, 0}, 0.0};
+    for (auto it = match; it != old_sa.end(); ++it) {
+      EquivalenceCandidate candidate = VisitEquivalenceSeed(
+          old_view.image_index(), new_view.image_index(), targets_affinities,
+          static_cast<offset_t>(*it), dst_offset, min_similarity);
+      if (candidate.similarity > best_similarity) {
+        best_candidate = candidate;
+        best_similarity = candidate.similarity;
+        next_dst_offset = candidate.eq.dst_end();
+        total_visit_length += candidate.eq.length;
+        if (total_visit_length > kSeedSelectionTotalVisitLengthQuota) {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    total_visit_length = 0;
+    for (auto it = match; it != old_sa.begin(); --it) {
+      EquivalenceCandidate candidate = VisitEquivalenceSeed(
+          old_view.image_index(), new_view.image_index(), targets_affinities,
+          static_cast<offset_t>(it[-1]), dst_offset, min_similarity);
+      if (candidate.similarity > best_similarity) {
+        best_candidate = candidate;
+        best_similarity = candidate.similarity;
+        next_dst_offset = candidate.eq.dst_end();
+        total_visit_length += candidate.eq.length;
+        if (total_visit_length > kSeedSelectionTotalVisitLengthQuota) {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    if (best_candidate.similarity >= min_similarity) {
+      candidates_.push_back(best_candidate);
+    }
+
+    dst_offset = next_dst_offset;
+  }
+}
+
+void EquivalenceMap::SortByDestination() {
+  std::sort(candidates_.begin(), candidates_.end(),
+            [](const EquivalenceCandidate& a, const EquivalenceCandidate& b) {
+              return a.eq.dst_offset < b.eq.dst_offset;
+            });
+}
+
+void EquivalenceMap::Prune(
+    const EncodedView& old_view,
+    const EncodedView& new_view,
+    const std::vector<TargetsAffinity>& target_affinities,
+    double min_similarity) {
+  // TODO(etiennep): unify with
+  // OffsetMapper::PruneEquivalencesAndSortBySource().
+  for (auto current = candidates_.begin(); current != candidates_.end();
+       ++current) {
+    if (current->similarity < min_similarity)
+      continue;  // This candidate will be discarded anyways.
+
+    bool next_is_reaper = false;
+
+    // Look ahead to resolve overlaps, until a better candidate is found.
+    auto next = current + 1;
+    for (; next != candidates_.end(); ++next) {
+      DCHECK_GE(next->eq.dst_offset, current->eq.dst_offset);
+      if (next->eq.dst_offset >= current->eq.dst_offset + current->eq.length)
+        break;  // No more overlap.
+
+      if (current->similarity < next->similarity) {
+        // |next| is better: So it is a reaper that shrinks |current|.
+        offset_t delta = current->eq.dst_end() - next->eq.dst_offset;
+        current->eq.length -= delta;
+        current->similarity = GetEquivalenceSimilarity(
+            old_view.image_index(), new_view.image_index(), target_affinities,
+            current->eq);
+
+        next_is_reaper = true;
+        break;
+      }
+    }
+
+    if (next_is_reaper) {
+      // Discard all equivalences strictly between |cur| and |next|.
+      for (auto reduced = current + 1; reduced != next; ++reduced) {
+        reduced->eq.length = 0;
+        reduced->similarity = 0;
+      }
+      current = next - 1;
+    } else {
+      // Shrinks all overlapping candidates following and worse than |current|.
+      for (auto reduced = current + 1; reduced != next; ++reduced) {
+        offset_t delta = current->eq.dst_end() - reduced->eq.dst_offset;
+        reduced->eq.length -= std::min(reduced->eq.length, delta);
+        reduced->eq.src_offset += delta;
+        reduced->eq.dst_offset += delta;
+        reduced->similarity = GetEquivalenceSimilarity(
+            old_view.image_index(), new_view.image_index(), target_affinities,
+            reduced->eq);
+        DCHECK_EQ(reduced->eq.dst_offset, current->eq.dst_end());
+      }
+    }
+  }
+
+  // Discard all candidates with similarity smaller than |min_similarity|.
+  base::EraseIf(candidates_,
+                [min_similarity](const EquivalenceCandidate& candidate) {
+                  return candidate.similarity < min_similarity;
+                });
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/patch_reader.cc b/native/zucchini/vendor/zucchini/patch_reader.cc
new file mode 100644
index 0000000..168389f
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/patch_reader.cc
@@ -0,0 +1,401 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/patch_reader.h"
+
+#include <type_traits>
+#include <utility>
+
+#include "base/numerics/safe_conversions.h"
+#include "components/zucchini/algorithm.h"
+#include "components/zucchini/crc32.h"
+#include "components/zucchini/element_detection.h"
+#include "components/zucchini/version_info.h"
+
+namespace zucchini {
+
+namespace patch {
+
+bool ParseElementMatch(BufferSource* source, ElementMatch* element_match) {
+  PatchElementHeader unsafe_element_header;
+  if (!source->GetValue(&unsafe_element_header)) {
+    LOG(ERROR) << "Impossible to read ElementMatch from source.";
+    return false;
+  }
+  ExecutableType exe_type =
+      CastToExecutableType(unsafe_element_header.exe_type);
+  if (exe_type == kExeTypeUnknown) {
+    LOG(ERROR) << "Invalid ExecutableType found.";
+    return false;
+  }
+  uint16_t element_version = DisassemblerVersionOfType(exe_type);
+  if (element_version != unsafe_element_header.version) {
+    LOG(ERROR) << "Element version doesn't match. Expected: " << element_version
+               << ", Actual:" << unsafe_element_header.version;
+    return false;
+  }
+  if (!unsafe_element_header.old_length || !unsafe_element_header.new_length) {
+    LOG(ERROR) << "Empty patch element found.";
+    return false;
+  }
+  // |unsafe_element_header| is now considered to be safe as it has a valid
+  // |exe_type| and the length fields are of sufficient size.
+  const auto& element_header = unsafe_element_header;
+
+  // Caveat: Element offsets and lengths can still be invalid (e.g., exceeding
+  // archive bounds), but this will be checked later.
+  element_match->old_element.offset = element_header.old_offset;
+  element_match->old_element.size = element_header.old_length;
+  element_match->new_element.offset = element_header.new_offset;
+  element_match->new_element.size = element_header.new_length;
+  element_match->old_element.exe_type = exe_type;
+  element_match->new_element.exe_type = exe_type;
+  return true;
+}
+
+bool ParseBuffer(BufferSource* source, BufferSource* buffer) {
+  uint32_t unsafe_size = 0;  // Bytes.
+  static_assert(sizeof(size_t) >= sizeof(unsafe_size),
+                "size_t is expected to be larger than uint32_t.");
+  if (!source->GetValue(&unsafe_size)) {
+    LOG(ERROR) << "Impossible to read buffer size from source.";
+    return false;
+  }
+  if (!source->GetRegion(static_cast<size_t>(unsafe_size), buffer)) {
+    LOG(ERROR) << "Impossible to read buffer content from source.";
+    return false;
+  }
+  // Caveat: |buffer| is considered to be safe as it was possible to extract it
+  // from the patch. However, this does not mean its contents are safe and when
+  // parsed must be validated if possible.
+  return true;
+}
+
+}  // namespace patch
+
+/******** EquivalenceSource ********/
+
+EquivalenceSource::EquivalenceSource() = default;
+EquivalenceSource::EquivalenceSource(const EquivalenceSource&) = default;
+EquivalenceSource::~EquivalenceSource() = default;
+
+bool EquivalenceSource::Initialize(BufferSource* source) {
+  return patch::ParseBuffer(source, &src_skip_) &&
+         patch::ParseBuffer(source, &dst_skip_) &&
+         patch::ParseBuffer(source, &copy_count_);
+}
+
+std::optional<Equivalence> EquivalenceSource::GetNext() {
+  if (src_skip_.empty() || dst_skip_.empty() || copy_count_.empty())
+    return std::nullopt;
+
+  Equivalence equivalence = {};
+
+  uint32_t length = 0;
+  if (!patch::ParseVarUInt<uint32_t>(&copy_count_, &length))
+    return std::nullopt;
+  equivalence.length = base::strict_cast<offset_t>(length);
+
+  int32_t src_offset_diff = 0;  // Intentionally signed.
+  if (!patch::ParseVarInt<int32_t>(&src_skip_, &src_offset_diff))
+    return std::nullopt;
+  base::CheckedNumeric<offset_t> src_offset =
+      previous_src_offset_ + src_offset_diff;
+  if (!src_offset.IsValid())
+    return std::nullopt;
+
+  equivalence.src_offset = src_offset.ValueOrDie();
+  previous_src_offset_ = src_offset + equivalence.length;
+  if (!previous_src_offset_.IsValid())
+    return std::nullopt;
+
+  uint32_t dst_offset_diff = 0;  // Intentionally unsigned.
+  if (!patch::ParseVarUInt<uint32_t>(&dst_skip_, &dst_offset_diff))
+    return std::nullopt;
+  base::CheckedNumeric<offset_t> dst_offset =
+      previous_dst_offset_ + dst_offset_diff;
+  if (!dst_offset.IsValid())
+    return std::nullopt;
+
+  equivalence.dst_offset = dst_offset.ValueOrDie();
+  previous_dst_offset_ = equivalence.dst_offset + equivalence.length;
+  if (!previous_dst_offset_.IsValid())
+    return std::nullopt;
+
+  // Caveat: |equivalence| is assumed to be safe only once the
+  // ValidateEquivalencesAndExtraData() method has returned true. Prior to this
+  // any equivalence returned is assumed to be unsafe.
+  return equivalence;
+}
+
+/******** ExtraDataSource ********/
+
+ExtraDataSource::ExtraDataSource() = default;
+ExtraDataSource::ExtraDataSource(const ExtraDataSource&) = default;
+ExtraDataSource::~ExtraDataSource() = default;
+
+bool ExtraDataSource::Initialize(BufferSource* source) {
+  return patch::ParseBuffer(source, &extra_data_);
+}
+
+std::optional<ConstBufferView> ExtraDataSource::GetNext(offset_t size) {
+  ConstBufferView buffer;
+  if (!extra_data_.GetRegion(size, &buffer))
+    return std::nullopt;
+  // |buffer| is assumed to always be safe/valid.
+  return buffer;
+}
+
+/******** RawDeltaSource ********/
+
+RawDeltaSource::RawDeltaSource() = default;
+RawDeltaSource::RawDeltaSource(const RawDeltaSource&) = default;
+RawDeltaSource::~RawDeltaSource() = default;
+
+bool RawDeltaSource::Initialize(BufferSource* source) {
+  return patch::ParseBuffer(source, &raw_delta_skip_) &&
+         patch::ParseBuffer(source, &raw_delta_diff_);
+}
+
+std::optional<RawDeltaUnit> RawDeltaSource::GetNext() {
+  if (raw_delta_skip_.empty() || raw_delta_diff_.empty())
+    return std::nullopt;
+
+  RawDeltaUnit raw_delta = {};
+  uint32_t copy_offset_diff = 0;
+  if (!patch::ParseVarUInt<uint32_t>(&raw_delta_skip_, &copy_offset_diff))
+    return std::nullopt;
+  base::CheckedNumeric<offset_t> copy_offset =
+      copy_offset_diff + copy_offset_compensation_;
+  if (!copy_offset.IsValid())
+    return std::nullopt;
+  raw_delta.copy_offset = copy_offset.ValueOrDie();
+
+  if (!raw_delta_diff_.GetValue<int8_t>(&raw_delta.diff))
+    return std::nullopt;
+
+  // A 0 value for a delta.diff is considered invalid since it has no meaning.
+  if (!raw_delta.diff)
+    return std::nullopt;
+
+  // We keep track of the compensation needed for next offset, taking into
+  // account delta encoding and bias of -1.
+  copy_offset_compensation_ = copy_offset + 1;
+  if (!copy_offset_compensation_.IsValid())
+    return std::nullopt;
+  // |raw_delta| is assumed to always be safe/valid.
+  return raw_delta;
+}
+
+/******** ReferenceDeltaSource ********/
+
+ReferenceDeltaSource::ReferenceDeltaSource() = default;
+ReferenceDeltaSource::ReferenceDeltaSource(const ReferenceDeltaSource&) =
+    default;
+ReferenceDeltaSource::~ReferenceDeltaSource() = default;
+
+bool ReferenceDeltaSource::Initialize(BufferSource* source) {
+  return patch::ParseBuffer(source, &source_);
+}
+
+std::optional<int32_t> ReferenceDeltaSource::GetNext() {
+  if (source_.empty())
+    return std::nullopt;
+  int32_t ref_delta = 0;
+  if (!patch::ParseVarInt<int32_t>(&source_, &ref_delta))
+    return std::nullopt;
+  // |ref_delta| is assumed to always be safe/valid.
+  return ref_delta;
+}
+
+/******** TargetSource ********/
+
+TargetSource::TargetSource() = default;
+TargetSource::TargetSource(const TargetSource&) = default;
+TargetSource::~TargetSource() = default;
+
+bool TargetSource::Initialize(BufferSource* source) {
+  return patch::ParseBuffer(source, &extra_targets_);
+}
+
+std::optional<offset_t> TargetSource::GetNext() {
+  if (extra_targets_.empty())
+    return std::nullopt;
+
+  uint32_t target_diff = 0;
+  if (!patch::ParseVarUInt<uint32_t>(&extra_targets_, &target_diff))
+    return std::nullopt;
+  base::CheckedNumeric<offset_t> target = target_diff + target_compensation_;
+  if (!target.IsValid())
+    return std::nullopt;
+
+  // We keep track of the compensation needed for next target, taking into
+  // account delta encoding and bias of -1.
+  target_compensation_ = target + 1;
+  if (!target_compensation_.IsValid())
+    return std::nullopt;
+  // Caveat: |target| will be a valid offset_t, but it's up to the caller to
+  // check whether it's a valid offset for an image.
+  return offset_t(target.ValueOrDie());
+}
+
+/******** PatchElementReader ********/
+
+PatchElementReader::PatchElementReader() = default;
+PatchElementReader::PatchElementReader(PatchElementReader&&) = default;
+PatchElementReader::~PatchElementReader() = default;
+
+bool PatchElementReader::Initialize(BufferSource* source) {
+  bool ok =
+      patch::ParseElementMatch(source, &element_match_) &&
+      equivalences_.Initialize(source) && extra_data_.Initialize(source) &&
+      ValidateEquivalencesAndExtraData() && raw_delta_.Initialize(source) &&
+      reference_delta_.Initialize(source);
+  if (!ok)
+    return false;
+  uint32_t pool_count = 0;
+  if (!source->GetValue(&pool_count)) {
+    LOG(ERROR) << "Impossible to read pool_count from source.";
+    return false;
+  }
+  for (uint32_t i = 0; i < pool_count; ++i) {
+    uint8_t pool_tag_value = 0;
+    if (!source->GetValue(&pool_tag_value)) {
+      LOG(ERROR) << "Impossible to read pool_tag from source.";
+      return false;
+    }
+    PoolTag pool_tag(pool_tag_value);
+    if (pool_tag == kNoPoolTag) {
+      LOG(ERROR) << "Invalid pool_tag encountered in ExtraTargetList.";
+      return false;
+    }
+    auto insert_result = extra_targets_.insert({pool_tag, {}});
+    if (!insert_result.second) {  // Element already present.
+      LOG(ERROR) << "Multiple ExtraTargetList found for the same pool_tag.";
+      return false;
+    }
+    if (!insert_result.first->second.Initialize(source))
+      return false;
+  }
+  return true;
+}
+
+bool PatchElementReader::ValidateEquivalencesAndExtraData() {
+  EquivalenceSource equivalences_copy = equivalences_;
+
+  const size_t old_region_size = element_match_.old_element.size;
+  const size_t new_region_size = element_match_.new_element.size;
+
+  base::CheckedNumeric<uint32_t> total_length = 0;
+  // Validate that each |equivalence| falls within the bounds of the
+  // |element_match_| and are in order.
+  offset_t prev_dst_end = 0;
+  for (auto equivalence = equivalences_copy.GetNext(); equivalence.has_value();
+       equivalence = equivalences_copy.GetNext()) {
+    if (!RangeIsBounded(equivalence->src_offset, equivalence->length,
+                        old_region_size) ||
+        !RangeIsBounded(equivalence->dst_offset, equivalence->length,
+                        new_region_size)) {
+      LOG(ERROR) << "Out of bounds equivalence detected.";
+      return false;
+    }
+    if (prev_dst_end > equivalence->dst_end()) {
+      LOG(ERROR) << "Out of order equivalence detected.";
+      return false;
+    }
+    prev_dst_end = equivalence->dst_end();
+    total_length += equivalence->length;
+  }
+  if (!total_length.IsValid() ||
+      element_match_.new_element.region().size < total_length.ValueOrDie() ||
+      extra_data_.extra_data().size() !=
+          element_match_.new_element.region().size -
+              static_cast<size_t>(total_length.ValueOrDie())) {
+    LOG(ERROR) << "Incorrect amount of extra_data.";
+    return false;
+  }
+  return true;
+}
+
+/******** EnsemblePatchReader ********/
+
+std::optional<EnsemblePatchReader> EnsemblePatchReader::Create(
+    ConstBufferView buffer) {
+  BufferSource source(buffer);
+  EnsemblePatchReader patch;
+  if (!patch.Initialize(&source))
+    return std::nullopt;
+  return patch;
+}
+
+EnsemblePatchReader::EnsemblePatchReader() = default;
+EnsemblePatchReader::EnsemblePatchReader(EnsemblePatchReader&&) = default;
+EnsemblePatchReader::~EnsemblePatchReader() = default;
+
+bool EnsemblePatchReader::Initialize(BufferSource* source) {
+  if (!source->GetValue(&header_)) {
+    LOG(ERROR) << "Impossible to read header from source.";
+    return false;
+  }
+  if (header_.magic != PatchHeader::kMagic) {
+    LOG(ERROR) << "Patch contains invalid magic.";
+    return false;
+  }
+  if (header_.major_version != kMajorVersion) {
+    LOG(ERROR) << "Patch major version doesn't match. Expected: "
+               << kMajorVersion << ", Actual:" << header_.major_version;
+    return false;
+  }
+  // |header_| is assumed to be safe from this point forward.
+
+  uint32_t element_count = 0;
+  if (!source->GetValue(&element_count)) {
+    LOG(ERROR) << "Impossible to read element_count from source.";
+    return false;
+  }
+
+  offset_t current_dst_offset = 0;
+  for (uint32_t i = 0; i < element_count; ++i) {
+    PatchElementReader element_patch;
+    if (!element_patch.Initialize(source))
+      return false;
+
+    if (!element_patch.old_element().FitsIn(header_.old_size) ||
+        !element_patch.new_element().FitsIn(header_.new_size)) {
+      LOG(ERROR) << "Invalid element encountered.";
+      return false;
+    }
+
+    if (element_patch.new_element().offset != current_dst_offset) {
+      LOG(ERROR) << "Invalid element encountered.";
+      return false;
+    }
+    current_dst_offset = element_patch.new_element().EndOffset();
+
+    elements_.push_back(std::move(element_patch));
+  }
+  if (current_dst_offset != header_.new_size) {
+    LOG(ERROR) << "Patch elements don't fully cover new image file.";
+    return false;
+  }
+
+  if (!source->empty()) {
+    LOG(ERROR) << "Patch was not fully consumed.";
+    return false;
+  }
+
+  return true;
+}
+
+bool EnsemblePatchReader::CheckOldFile(ConstBufferView old_image) const {
+  return old_image.size() == header_.old_size &&
+         CalculateCrc32(old_image.begin(), old_image.end()) == header_.old_crc;
+}
+
+bool EnsemblePatchReader::CheckNewFile(ConstBufferView new_image) const {
+  return new_image.size() == header_.new_size &&
+         CalculateCrc32(new_image.begin(), new_image.end()) == header_.new_crc;
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/rel32_finder.cc b/native/zucchini/vendor/zucchini/rel32_finder.cc
new file mode 100644
index 0000000..1ad8910
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/rel32_finder.cc
@@ -0,0 +1,294 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/rel32_finder.h"
+
+#include <algorithm>
+
+#include "base/numerics/safe_conversions.h"
+
+namespace zucchini {
+
+/******** Abs32GapFinder ********/
+
+Abs32GapFinder::Abs32GapFinder(ConstBufferView image,
+                               ConstBufferView region,
+                               const std::vector<offset_t>& abs32_locations,
+                               size_t abs32_width)
+    : base_(image.begin()),
+      region_end_(region.end()),
+      abs32_end_(abs32_locations.end()),
+      abs32_width_(abs32_width) {
+  DCHECK_GT(abs32_width, size_t(0));
+  DCHECK_GE(region.begin(), image.begin());
+  DCHECK_LE(region.end(), image.end());
+
+  const offset_t begin_offset =
+      base::checked_cast<offset_t>(region.begin() - image.begin());
+  // Find the first |abs32_cur_| with |*abs32_cur_ >= begin_offset|.
+  abs32_cur_ = std::lower_bound(abs32_locations.begin(), abs32_locations.end(),
+                                begin_offset);
+
+  // Find lower boundary, accounting for the possibility that |abs32_cur_[-1]|
+  // may straddle across |region.begin()|.
+  cur_lo_ = region.begin();
+  if (abs32_cur_ > abs32_locations.begin())
+    cur_lo_ = std::max(cur_lo_, image.begin() + abs32_cur_[-1] + abs32_width_);
+}
+
+Abs32GapFinder::~Abs32GapFinder() = default;
+
+bool Abs32GapFinder::FindNext() {
+  // Iterate over |[abs32_cur_, abs32_end_)| and emit segments.
+  while (abs32_cur_ != abs32_end_ && base_ + *abs32_cur_ < region_end_) {
+    ConstBufferView::const_iterator hi = base_ + *abs32_cur_;
+    gap_ = ConstBufferView::FromRange(cur_lo_, hi);
+    cur_lo_ = hi + abs32_width_;
+    ++abs32_cur_;
+    if (!gap_.empty())
+      return true;
+  }
+  // Emit final segment.
+  if (cur_lo_ < region_end_) {
+    gap_ = ConstBufferView::FromRange(cur_lo_, region_end_);
+    cur_lo_ = region_end_;
+    return true;
+  }
+  return false;
+}
+
+/******** Rel32Finder ********/
+
+Rel32Finder::Rel32Finder(ConstBufferView image,
+                         const AddressTranslator& translator)
+    : image_(image), offset_to_rva_(translator) {}
+
+Rel32Finder::~Rel32Finder() = default;
+
+void Rel32Finder::SetRegion(ConstBufferView region) {
+  region_ = region;
+  accept_it_ = region.begin();
+}
+
+bool Rel32Finder::FindNext() {
+  NextIterators next_iters = Scan(region_);
+  if (next_iters.reject == nullptr) {
+    region_.seek(region_.end());
+    return false;
+  }
+  region_.seek(next_iters.reject);
+  accept_it_ = next_iters.accept;
+  DCHECK_GE(accept_it_, region_.begin());
+  DCHECK_LE(accept_it_, region_.end());
+  return true;
+}
+
+void Rel32Finder::Accept() {
+  region_.seek(accept_it_);
+}
+
+/******** Rel32FinderIntel ********/
+
+Rel32Finder::NextIterators Rel32FinderIntel::SetResult(
+    ConstBufferView::const_iterator cursor,
+    uint32_t opcode_size,
+    bool can_point_outside_section) {
+  offset_t location =
+      base::checked_cast<offset_t>((cursor + opcode_size) - image_.begin());
+  rva_t location_rva = offset_to_rva_.Convert(location);
+  DCHECK_NE(location_rva, kInvalidRva);
+  rva_t target_rva = location_rva + 4 + image_.read<uint32_t>(location);
+  rel32_ = {location, target_rva, can_point_outside_section};
+  return {cursor + 1, cursor + (opcode_size + 4)};
+}
+
+/******** Rel32FinderX86 ********/
+
+Rel32Finder::NextIterators Rel32FinderX86::Scan(ConstBufferView region) {
+  ConstBufferView::const_iterator cursor = region.begin();
+  while (cursor < region.end()) {
+    // Heuristic rel32 detection by looking for opcodes that use them.
+    if (cursor + 5 <= region.end()) {
+      if (cursor[0] == 0xE8 || cursor[0] == 0xE9)  // JMP rel32; CALL rel32
+        return SetResult(cursor, 1, false);
+    }
+    if (cursor + 6 <= region.end()) {
+      if (cursor[0] == 0x0F && (cursor[1] & 0xF0) == 0x80)  // Jcc long form
+        return SetResult(cursor, 2, false);
+    }
+    ++cursor;
+  }
+  return {nullptr, nullptr};
+}
+
+/******** Rel32FinderX64 ********/
+
+Rel32Finder::NextIterators Rel32FinderX64::Scan(ConstBufferView region) {
+  ConstBufferView::const_iterator cursor = region.begin();
+  while (cursor < region.end()) {
+    // Heuristic rel32 detection by looking for opcodes that use them.
+    if (cursor + 5 <= region.end()) {
+      if (cursor[0] == 0xE8 || cursor[0] == 0xE9)  // JMP rel32; CALL rel32
+        return SetResult(cursor, 1, false);
+    }
+    if (cursor + 6 <= region.end()) {
+      if (cursor[0] == 0x0F && (cursor[1] & 0xF0) == 0x80) {  // Jcc long form
+        return SetResult(cursor, 2, false);
+      } else if ((cursor[0] == 0xFF &&
+                  (cursor[1] == 0x15 || cursor[1] == 0x25)) ||
+                 ((cursor[0] == 0x89 || cursor[0] == 0x8B ||
+                   cursor[0] == 0x8D) &&
+                  (cursor[1] & 0xC7) == 0x05)) {
+        // 6-byte instructions:
+        // [2-byte opcode] [disp32]:
+        //  Opcode
+        //   FF 15: CALL QWORD PTR [rip+disp32]
+        //   FF 25: JMP  QWORD PTR [rip+disp32]
+        //
+        // [1-byte opcode] [ModR/M] [disp32]:
+        //  Opcode
+        //   89: MOV DWORD PTR [rip+disp32],reg
+        //   8B: MOV reg,DWORD PTR [rip+disp32]
+        //   8D: LEA reg,[rip+disp32]
+        //  ModR/M : MMRRRMMM
+        //   MM = 00 & MMM = 101 => rip+disp32
+        //   RRR: selects reg operand from [eax|ecx|...|edi]
+        return SetResult(cursor, 2, true);
+      }
+    }
+    ++cursor;
+  }
+  return {nullptr, nullptr};
+}
+
+/******** Rel32FinderArm ********/
+
+template <typename ADDR_TYPE>
+Rel32FinderArm<ADDR_TYPE>::Rel32FinderArm(ConstBufferView image,
+                                          const AddressTranslator& translator)
+    : Rel32Finder(image, translator) {}
+
+template <typename ADDR_TYPE>
+Rel32FinderArm<ADDR_TYPE>::~Rel32FinderArm() = default;
+
+template <typename ADDR_TYPE>
+Rel32Finder::NextIterators Rel32FinderArm<ADDR_TYPE>::SetResult(
+    Result&& result,
+    ConstBufferView::const_iterator cursor,
+    int instr_size) {
+  rel32_ = result;
+  return {cursor + instr_size, cursor + instr_size};
+}
+
+// SetResult() for end of scan.
+template <typename ADDR_TYPE>
+Rel32Finder::NextIterators Rel32FinderArm<ADDR_TYPE>::SetEmptyResult() {
+  rel32_ = {kInvalidOffset, kInvalidOffset, ADDR_TYPE::ADDR_NONE};
+  return {nullptr, nullptr};
+}
+
+/******** Rel32FinderAArch32 ********/
+
+Rel32FinderAArch32::Rel32FinderAArch32(ConstBufferView image,
+                                       const AddressTranslator& translator,
+                                       bool is_thumb2)
+    : Rel32FinderArm(image, translator), is_thumb2_(is_thumb2) {}
+
+Rel32FinderAArch32::~Rel32FinderAArch32() = default;
+
+Rel32Finder::NextIterators Rel32FinderAArch32::ScanA32(ConstBufferView region) {
+  // Guard against alignment potentially causing |cursor > region.end()|.
+  if (region.size() < 4)
+    return SetEmptyResult();
+  ConstBufferView::const_iterator cursor = region.begin();
+  cursor += IncrementForAlignCeil4(cursor - image_.begin());
+  for (; region.end() - cursor >= 4; cursor += 4) {
+    offset_t offset = base::checked_cast<offset_t>(cursor - image_.begin());
+    AArch32Rel32Translator translator;
+    rva_t instr_rva = offset_to_rva_.Convert(offset);
+    uint32_t code32 = translator.FetchArmCode32(image_, offset);
+    rva_t target_rva = kInvalidRva;
+    if (translator.ReadA24(instr_rva, code32, &target_rva)) {
+      return SetResult({offset, target_rva, AArch32Rel32Translator::ADDR_A24},
+                       cursor, 4);
+    }
+  }
+  return SetEmptyResult();
+}
+
+Rel32Finder::NextIterators Rel32FinderAArch32::ScanT32(ConstBufferView region) {
+  // Guard against alignment potentially causing |cursor > region.end()|.
+  if (region.size() < 2)
+    return SetEmptyResult();
+  ConstBufferView::const_iterator cursor = region.begin();
+  cursor += IncrementForAlignCeil2(cursor - image_.begin());
+  while (region.end() - cursor >= 2) {
+    offset_t offset = base::checked_cast<offset_t>(cursor - image_.begin());
+    AArch32Rel32Translator translator;
+    AArch32Rel32Translator::AddrType type = AArch32Rel32Translator::ADDR_NONE;
+    rva_t instr_rva = offset_to_rva_.Convert(offset);
+    uint16_t code16 = translator.FetchThumb2Code16(image_, offset);
+    int instr_size = GetThumb2InstructionSize(code16);
+    rva_t target_rva = kInvalidRva;
+    if (instr_size == 2) {  // 16-bit THUMB2 instruction.
+      if (translator.ReadT8(instr_rva, code16, &target_rva))
+        type = AArch32Rel32Translator::ADDR_T8;
+      else if (translator.ReadT11(instr_rva, code16, &target_rva))
+        type = AArch32Rel32Translator::ADDR_T11;
+    } else {  // |instr_size == 4|: 32-bit THUMB2 instruction.
+      if (region.end() - cursor >= 4) {
+        uint32_t code32 = translator.FetchThumb2Code32(image_, offset);
+        if (translator.ReadT20(instr_rva, code32, &target_rva))
+          type = AArch32Rel32Translator::ADDR_T20;
+        else if (translator.ReadT24(instr_rva, code32, &target_rva))
+          type = AArch32Rel32Translator::ADDR_T24;
+      }
+    }
+    if (type != AArch32Rel32Translator::ADDR_NONE)
+      return SetResult({offset, target_rva, type}, cursor, instr_size);
+    cursor += instr_size;
+  }
+  return SetEmptyResult();
+}
+
+Rel32Finder::NextIterators Rel32FinderAArch32::Scan(ConstBufferView region) {
+  return is_thumb2_ ? ScanT32(region) : ScanA32(region);
+}
+
+/******** Rel32FinderAArch64 ********/
+
+Rel32FinderAArch64::Rel32FinderAArch64(ConstBufferView image,
+                                       const AddressTranslator& translator)
+    : Rel32FinderArm(image, translator) {}
+
+Rel32FinderAArch64::~Rel32FinderAArch64() = default;
+
+Rel32Finder::NextIterators Rel32FinderAArch64::Scan(ConstBufferView region) {
+  // Guard against alignment potentially causing |cursor > region.end()|.
+  if (region.size() < 4)
+    return SetEmptyResult();
+  ConstBufferView::const_iterator cursor = region.begin();
+  cursor += IncrementForAlignCeil4(cursor - image_.begin());
+  for (; region.end() - cursor >= 4; cursor += 4) {
+    offset_t offset = base::checked_cast<offset_t>(cursor - image_.begin());
+    // For simplicity we assume RVA fits within 32-bits.
+    AArch64Rel32Translator translator;
+    AArch64Rel32Translator::AddrType type = AArch64Rel32Translator::ADDR_NONE;
+    rva_t instr_rva = offset_to_rva_.Convert(offset);
+    uint32_t code32 = translator.FetchCode32(image_, offset);
+    rva_t target_rva = kInvalidRva;
+    if (translator.ReadImmd14(instr_rva, code32, &target_rva)) {
+      type = AArch64Rel32Translator::ADDR_IMMD14;
+    } else if (translator.ReadImmd19(instr_rva, code32, &target_rva)) {
+      type = AArch64Rel32Translator::ADDR_IMMD19;
+    } else if (translator.ReadImmd26(instr_rva, code32, &target_rva)) {
+      type = AArch64Rel32Translator::ADDR_IMMD26;
+    }
+    if (type != AArch64Rel32Translator::ADDR_NONE)
+      return SetResult({offset, target_rva, type}, cursor, 4);
+  }
+  return SetEmptyResult();
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/rel32_utils.cc b/native/zucchini/vendor/zucchini/rel32_utils.cc
new file mode 100644
index 0000000..3790ed0
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/rel32_utils.cc
@@ -0,0 +1,67 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/rel32_utils.h"
+
+#include <algorithm>
+
+#include "base/check_op.h"
+#include "components/zucchini/io_utils.h"
+
+namespace zucchini {
+
+/******** Rel32ReaderX86 ********/
+
+Rel32ReaderX86::Rel32ReaderX86(ConstBufferView image,
+                               offset_t lo,
+                               offset_t hi,
+                               const std::deque<offset_t>* locations,
+                               const AddressTranslator& translator)
+    : image_(image),
+      target_rva_to_offset_(translator),
+      location_offset_to_rva_(translator),
+      hi_(hi),
+      last_(locations->end()) {
+  DCHECK_LE(lo, image.size());
+  DCHECK_LE(hi, image.size());
+  current_ = std::lower_bound(locations->begin(), locations->end(), lo);
+}
+
+Rel32ReaderX86::~Rel32ReaderX86() = default;
+
+std::optional<Reference> Rel32ReaderX86::GetNext() {
+  while (current_ < last_ && *current_ < hi_) {
+    offset_t loc_offset = *(current_++);
+    DCHECK_LE(loc_offset + 4, image_.size());  // Sanity check.
+    rva_t loc_rva = location_offset_to_rva_.Convert(loc_offset);
+    rva_t target_rva = loc_rva + 4 + image_.read<int32_t>(loc_offset);
+    offset_t target_offset = target_rva_to_offset_.Convert(target_rva);
+    // |locations| is valid by assumption (see class description).
+    DCHECK_NE(kInvalidOffset, target_offset);
+    return Reference{loc_offset, target_offset};
+  }
+  return std::nullopt;
+}
+
+/******** Rel32ReceptorX86 ********/
+
+Rel32WriterX86::Rel32WriterX86(MutableBufferView image,
+                               const AddressTranslator& translator)
+    : image_(image),
+      target_offset_to_rva_(translator),
+      location_offset_to_rva_(translator) {}
+
+Rel32WriterX86::~Rel32WriterX86() = default;
+
+void Rel32WriterX86::PutNext(Reference ref) {
+  rva_t target_rva = target_offset_to_rva_.Convert(ref.target);
+  rva_t loc_rva = location_offset_to_rva_.Convert(ref.location);
+
+  // Subtraction underflow is okay
+  uint32_t code =
+      static_cast<uint32_t>(target_rva) - (static_cast<uint32_t>(loc_rva) + 4);
+  image_.write<uint32_t>(ref.location, code);
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/reloc_elf.cc b/native/zucchini/vendor/zucchini/reloc_elf.cc
new file mode 100644
index 0000000..9deaade
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/reloc_elf.cc
@@ -0,0 +1,163 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/reloc_elf.h"
+
+#include <algorithm>
+
+#include "base/logging.h"
+#include "components/zucchini/algorithm.h"
+
+namespace zucchini {
+
+/******** RelocReaderElf ********/
+
+RelocReaderElf::RelocReaderElf(
+    ConstBufferView image,
+    Bitness bitness,
+    const std::vector<SectionDimensionsElf>& reloc_section_dims,
+    uint32_t rel_type,
+    offset_t lo,
+    offset_t hi,
+    const AddressTranslator& translator)
+    : image_(image),
+      bitness_(bitness),
+      rel_type_(rel_type),
+      reloc_section_dimensions_(reloc_section_dims),
+      hi_(hi),
+      target_rva_to_offset_(translator) {
+  DCHECK(bitness_ == kBit32 || bitness_ == kBit64);
+
+  // Find the relocation section at or right before |lo|.
+  cur_section_dimensions_ = std::upper_bound(
+      reloc_section_dimensions_.begin(), reloc_section_dimensions_.end(), lo);
+  if (cur_section_dimensions_ != reloc_section_dimensions_.begin())
+    --cur_section_dimensions_;
+
+  // |lo| and |hi_| do not cut across a reloc reference (e.g.,
+  // Elf_Rel::r_offset), but may cut across a reloc struct (e.g. Elf_Rel)!
+  // GetNext() emits all reloc references in |[lo, hi_)|, but needs to examine
+  // the entire reloc struct for context. Knowing that |r_offset| is the first
+  // entry in a reloc struct, |cursor_| and |hi_| are adjusted by the following:
+  // - If |lo| is in a reloc section, then |cursor_| is chosen, as |lo| aligned
+  //   up to the next reloc struct, to exclude reloc struct that |lo| may cut
+  //   across.
+  // - If |hi_| is in a reloc section, then align it up, to include reloc struct
+  //   that |hi_| may cut across.
+  cursor_ =
+      base::checked_cast<offset_t>(cur_section_dimensions_->region.offset);
+  if (cursor_ < lo)
+    cursor_ +=
+        AlignCeil<offset_t>(lo - cursor_, cur_section_dimensions_->entry_size);
+
+  auto end_section = std::upper_bound(reloc_section_dimensions_.begin(),
+                                      reloc_section_dimensions_.end(), hi_);
+  if (end_section != reloc_section_dimensions_.begin()) {
+    --end_section;
+    if (hi_ - end_section->region.offset < end_section->region.size) {
+      offset_t end_region_offset =
+          base::checked_cast<offset_t>(end_section->region.offset);
+      hi_ = end_region_offset + AlignCeil<offset_t>(hi_ - end_region_offset,
+                                                    end_section->entry_size);
+    }
+  }
+}
+
+RelocReaderElf::~RelocReaderElf() = default;
+
+rva_t RelocReaderElf::GetRelocationTarget(elf::Elf32_Rel rel) const {
+  // The least significant byte of |rel.r_info| is the type. The other 3 bytes
+  // store the symbol, which we ignore.
+  uint32_t type = static_cast<uint32_t>(rel.r_info & 0xFF);
+  if (type == rel_type_)
+    return rel.r_offset;
+  return kInvalidRva;
+}
+
+rva_t RelocReaderElf::GetRelocationTarget(elf::Elf64_Rel rel) const {
+  // The least significant 4 bytes of |rel.r_info| is the type. The other 4
+  // bytes store the symbol, which we ignore.
+  uint32_t type = static_cast<uint32_t>(rel.r_info & 0xFFFFFFFF);
+  if (type == rel_type_) {
+    // Assume |rel.r_offset| fits within 32-bit integer.
+    if ((rel.r_offset & 0xFFFFFFFF) == rel.r_offset)
+      return static_cast<rva_t>(rel.r_offset);
+    // Otherwise output warning.
+    LOG(WARNING) << "Warning: Skipping r_offset whose value exceeds 32-bits.";
+  }
+  return kInvalidRva;
+}
+
+std::optional<Reference> RelocReaderElf::GetNext() {
+  offset_t cur_entry_size = cur_section_dimensions_->entry_size;
+  offset_t cur_section_dimensions_end =
+      base::checked_cast<offset_t>(cur_section_dimensions_->region.hi());
+
+  for (; cursor_ + cur_entry_size <= hi_; cursor_ += cur_entry_size) {
+    while (cursor_ >= cur_section_dimensions_end) {
+      ++cur_section_dimensions_;
+      if (cur_section_dimensions_ == reloc_section_dimensions_.end())
+        return std::nullopt;
+      cur_entry_size = cur_section_dimensions_->entry_size;
+      cursor_ =
+          base::checked_cast<offset_t>(cur_section_dimensions_->region.offset);
+      if (cursor_ + cur_entry_size > hi_)
+        return std::nullopt;
+      cur_section_dimensions_end =
+          base::checked_cast<offset_t>(cur_section_dimensions_->region.hi());
+    }
+    rva_t target_rva = kInvalidRva;
+    // TODO(huangs): Fix RELA sections: Need to process |r_addend|.
+    switch (bitness_) {
+      case kBit32:
+        target_rva = GetRelocationTarget(image_.read<elf::Elf32_Rel>(cursor_));
+        break;
+      case kBit64:
+        target_rva = GetRelocationTarget(image_.read<elf::Elf64_Rel>(cursor_));
+        break;
+    }
+    if (target_rva == kInvalidRva)
+      continue;
+    // TODO(huangs): Make the check more strict: The reference body should not
+    // straddle section boundary.
+    offset_t target = target_rva_to_offset_.Convert(target_rva);
+    if (target == kInvalidOffset)
+      continue;
+    // |target| will be used to obtain abs32 references, so we must ensure that
+    // it lies inside |image_|.
+    if (!image_.covers({target, WidthOf(bitness_)}))
+      continue;
+    offset_t location = cursor_;
+    cursor_ += cur_entry_size;
+    return Reference{location, target};
+  }
+  return std::nullopt;
+}
+
+/******** RelocWriterElf ********/
+
+RelocWriterElf::RelocWriterElf(MutableBufferView image,
+                               Bitness bitness,
+                               const AddressTranslator& translator)
+    : image_(image), bitness_(bitness), target_offset_to_rva_(translator) {
+  DCHECK(bitness_ == kBit32 || bitness_ == kBit64);
+}
+
+RelocWriterElf::~RelocWriterElf() = default;
+
+void RelocWriterElf::PutNext(Reference ref) {
+  switch (bitness_) {
+    case kBit32:
+      image_.modify<elf::Elf32_Rel>(ref.location).r_offset =
+          target_offset_to_rva_.Convert(ref.target);
+      break;
+    case kBit64:
+      image_.modify<elf::Elf64_Rel>(ref.location).r_offset =
+          target_offset_to_rva_.Convert(ref.target);
+      break;
+  }
+  // Leave |reloc.r_info| alone.
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/target_pool.cc b/native/zucchini/vendor/zucchini/target_pool.cc
new file mode 100644
index 0000000..e15d0b9
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/target_pool.cc
@@ -0,0 +1,84 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/target_pool.h"
+
+#include <algorithm>
+#include <iterator>
+#include <utility>
+
+#include "base/check.h"
+#include "components/zucchini/algorithm.h"
+#include "components/zucchini/equivalence_map.h"
+
+namespace zucchini {
+
+TargetPool::TargetPool() = default;
+
+TargetPool::TargetPool(std::deque<offset_t>&& targets) {
+  DCHECK(targets_.empty());
+  DCHECK(std::is_sorted(targets.begin(), targets.end()));
+  targets_ = std::move(targets);
+}
+
+TargetPool::TargetPool(TargetPool&&) = default;
+TargetPool::TargetPool(const TargetPool&) = default;
+TargetPool::~TargetPool() = default;
+
+void TargetPool::InsertTargets(const std::vector<offset_t>& targets) {
+  std::copy(targets.begin(), targets.end(), std::back_inserter(targets_));
+  SortAndUniquify(&targets_);
+}
+
+void TargetPool::InsertTargets(TargetSource* targets) {
+  for (auto target = targets->GetNext(); target.has_value();
+       target = targets->GetNext()) {
+    targets_.push_back(*target);
+  }
+  // InsertTargets() can be called many times (number of reference types for the
+  // pool) in succession. Calling SortAndUniquify() every time enables deduping
+  // to occur more often. This prioritizes peak memory reduction over running
+  // time.
+  SortAndUniquify(&targets_);
+}
+
+void TargetPool::InsertTargets(const std::vector<Reference>& references) {
+  // This can be called many times, so it's better to let std::back_inserter()
+  // manage |targets_| resize, instead of manually reserving space.
+  std::transform(references.begin(), references.end(),
+                 std::back_inserter(targets_),
+                 [](const Reference& ref) { return ref.target; });
+  SortAndUniquify(&targets_);
+}
+
+void TargetPool::InsertTargets(ReferenceReader&& references) {
+  for (auto ref = references.GetNext(); ref.has_value();
+       ref = references.GetNext()) {
+    targets_.push_back(ref->target);
+  }
+  SortAndUniquify(&targets_);
+}
+
+key_t TargetPool::KeyForOffset(offset_t offset) const {
+  auto pos = std::lower_bound(targets_.begin(), targets_.end(), offset);
+  DCHECK(pos != targets_.end() && *pos == offset);
+  return static_cast<offset_t>(pos - targets_.begin());
+}
+
+key_t TargetPool::KeyForNearestOffset(offset_t offset) const {
+  auto pos = std::lower_bound(targets_.begin(), targets_.end(), offset);
+  if (pos != targets_.begin()) {
+    // If distances are equal, prefer lower key.
+    if (pos == targets_.end() || *pos - offset >= offset - pos[-1])
+      --pos;
+  }
+  return static_cast<offset_t>(pos - targets_.begin());
+}
+
+void TargetPool::FilterAndProject(const OffsetMapper& offset_mapper) {
+  offset_mapper.ForwardProjectAll(&targets_);
+  std::sort(targets_.begin(), targets_.end());
+}
+
+}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/zucchini_apply.cc b/native/zucchini/vendor/zucchini/zucchini_apply.cc
new file mode 100644
index 0000000..76142e0
--- /dev/null
+++ b/native/zucchini/vendor/zucchini/zucchini_apply.cc
@@ -0,0 +1,217 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/zucchini/zucchini_apply.h"
+
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <utility>
+
+#include "base/logging.h"
+#include "base/numerics/safe_conversions.h"
+#include "components/zucchini/disassembler.h"
+#include "components/zucchini/element_detection.h"
+#include "components/zucchini/equivalence_map.h"
+#include "components/zucchini/image_index.h"
+
+namespace zucchini {
+
+bool ApplyEquivalenceAndExtraData(ConstBufferView old_image,
+                                  const PatchElementReader& patch_reader,
+                                  MutableBufferView new_image) {
+  EquivalenceSource equiv_source = patch_reader.GetEquivalenceSource();
+  ExtraDataSource extra_data_source = patch_reader.GetExtraDataSource();
+  MutableBufferView::iterator dst_it = new_image.begin();
+
+  for (auto equivalence = equiv_source.GetNext(); equivalence.has_value();
+       equivalence = equiv_source.GetNext()) {
+    MutableBufferView::iterator next_dst_it =
+        new_image.begin() + equivalence->dst_offset;
+    CHECK(next_dst_it >= dst_it);
+
+    offset_t gap = static_cast<offset_t>(next_dst_it - dst_it);
+    std::optional<ConstBufferView> extra_data = extra_data_source.GetNext(gap);
+    if (!extra_data) {
+      LOG(ERROR) << "Error reading extra_data";
+      return false;
+    }
+    // |extra_data| length is based on what was parsed from the patch so this
+    // copy should be valid.
+    dst_it = std::copy(extra_data->begin(), extra_data->end(), dst_it);
+    CHECK_EQ(dst_it, next_dst_it);
+    dst_it = std::copy_n(old_image.begin() + equivalence->src_offset,
+                         equivalence->length, dst_it);
+    CHECK_EQ(dst_it, next_dst_it + equivalence->length);
+  }
+  offset_t gap = static_cast<offset_t>(new_image.end() - dst_it);
+  std::optional<ConstBufferView> extra_data = extra_data_source.GetNext(gap);
+  if (!extra_data) {
+    LOG(ERROR) << "Error reading extra_data";
+    return false;
+  }
+  std::copy(extra_data->begin(), extra_data->end(), dst_it);
+  if (!equiv_source.Done() || !extra_data_source.Done()) {
+    LOG(ERROR) << "Found trailing equivalence and extra_data";
+    return false;
+  }
+  return true;
+}
+
+bool ApplyRawDelta(const PatchElementReader& patch_reader,
+                   MutableBufferView new_image) {
+  EquivalenceSource equiv_source = patch_reader.GetEquivalenceSource();
+  RawDeltaSource raw_delta_source = patch_reader.GetRawDeltaSource();
+  // Traverse |equiv_source| and |raw_delta_source| in lockstep.
+  auto equivalence = equiv_source.GetNext();
+  offset_t base_copy_offset = 0;
+  for (auto delta = raw_delta_source.GetNext(); delta.has_value();
+       delta = raw_delta_source.GetNext()) {
+    while (equivalence.has_value() &&
+           base_copy_offset + equivalence->length <= delta->copy_offset) {
+      base_copy_offset += equivalence->length;
+      equivalence = equiv_source.GetNext();
+    }
+    if (!equivalence.has_value()) {
+      LOG(ERROR) << "Error reading equivalences";
+      return false;
+    }
+    CHECK_GE(delta->copy_offset, base_copy_offset);
+    CHECK_LT(delta->copy_offset, base_copy_offset + equivalence->length);
+
+    // Invert byte diff.
+    new_image[equivalence->dst_offset - base_copy_offset +
+              delta->copy_offset] += delta->diff;
+  }
+  if (!raw_delta_source.Done()) {
+    LOG(ERROR) << "Found trailing raw_delta";
+    return false;
+  }
+  return true;
+}
+
+bool ApplyReferencesCorrection(ExecutableType exe_type,
+                               ConstBufferView old_image,
+                               const PatchElementReader& patch,
+                               MutableBufferView new_image) {
+  auto old_disasm = MakeDisassemblerOfType(old_image, exe_type);
+  auto new_disasm =
+      MakeDisassemblerOfType(ConstBufferView(new_image), exe_type);
+  if (!old_disasm || !new_disasm) {
+    LOG(ERROR) << "Failed to create Disassembler";
+    return false;
+  }
+  if (old_disasm->size() != old_image.size() ||
+      new_disasm->size() != new_image.size()) {
+    LOG(ERROR) << "Disassembler and element size mismatch";
+    return false;
+  }
+
+  ReferenceDeltaSource ref_delta_source = patch.GetReferenceDeltaSource();
+  std::map<PoolTag, std::vector<ReferenceGroup>> pool_groups;
+  for (const auto& ref_group : old_disasm->MakeReferenceGroups())
+    pool_groups[ref_group.pool_tag()].push_back(ref_group);
+
+  OffsetMapper offset_mapper(patch.GetEquivalenceSource(),
+                             base::checked_cast<offset_t>(old_image.size()),
+                             base::checked_cast<offset_t>(new_image.size()));
+
+  std::vector<ReferenceGroup> new_groups = new_disasm->MakeReferenceGroups();
+  for (const auto& pool_and_sub_groups : pool_groups) {
+    PoolTag pool_tag = pool_and_sub_groups.first;
+    const std::vector<ReferenceGroup>& sub_groups = pool_and_sub_groups.second;
+
+    TargetPool targets;
+    // Load "old" targets, then filter and map them to "new" targets.
+    for (ReferenceGroup group : sub_groups)
+      targets.InsertTargets(std::move(*group.GetReader(old_disasm.get())));
+    targets.FilterAndProject(offset_mapper);
+
+    // Load extra targets from patch.
+    TargetSource target_source = patch.GetExtraTargetSource(pool_tag);
+    targets.InsertTargets(&target_source);
+    if (!target_source.Done()) {
+      LOG(ERROR) << "Found trailing extra_targets";
+      return false;
+    }
+
+    // Correct all new references, and write results to |new_disasm|.
+    for (ReferenceGroup group : sub_groups) {
+      std::unique_ptr<ReferenceWriter> ref_writer =
+          new_groups[group.type_tag().value()].GetWriter(new_image,
+                                                         new_disasm.get());
+
+      EquivalenceSource equiv_source = patch.GetEquivalenceSource();
+      for (auto equivalence = equiv_source.GetNext(); equivalence.has_value();
+           equivalence = equiv_source.GetNext()) {
+        std::unique_ptr<ReferenceReader> ref_gen = group.GetReader(
+            equivalence->src_offset, equivalence->src_end(), old_disasm.get());
+        for (auto ref = ref_gen->GetNext(); ref.has_value();
+             ref = ref_gen->GetNext()) {
+          DCHECK_GE(ref->location, equivalence->src_offset);
+          DCHECK_LT(ref->location, equivalence->src_end());
+
+          offset_t projected_target =
+              offset_mapper.ExtendedForwardProject(ref->target);
+          offset_t expected_key = targets.KeyForNearestOffset(projected_target);
+          auto delta = ref_delta_source.GetNext();
+          if (!delta.has_value()) {
+            LOG(ERROR) << "Error reading reference_delta";
+            return false;
+          }
+          const key_t key = expected_key + delta.value();
+          if (!targets.KeyIsValid(key)) {
+            LOG(ERROR) << "Invalid reference_delta";
+            return false;
+          }
+          ref->target = targets.OffsetForKey(expected_key + delta.value());
+          ref->location =
+              ref->location - equivalence->src_offset + equivalence->dst_offset;
+          ref_writer->PutNext(*ref);
+        }
+      }
+    }
+  }
+  if (!ref_delta_source.Done()) {
+    LOG(ERROR) << "Found trailing ref_delta_source";
+    return false;
+  }
+  return true;
+}
+
+bool ApplyElement(ExecutableType exe_type,
+                  ConstBufferView old_image,
+                  const PatchElementReader& patch_reader,
+                  MutableBufferView new_image) {
+  return ApplyEquivalenceAndExtraData(old_image, patch_reader, new_image) &&
+         ApplyRawDelta(patch_reader, new_image) &&
+         ApplyReferencesCorrection(exe_type, old_image, patch_reader,
+                                   new_image);
+}
+
+/******** Exported Functions ********/
+
+status::Code ApplyBuffer(ConstBufferView old_image,
+                         const EnsemblePatchReader& patch_reader,
+                         MutableBufferView new_image) {
+  if (!patch_reader.CheckOldFile(old_image)) {
+    LOG(ERROR) << "Invalid old_image.";
+    return status::kStatusInvalidOldImage;
+  }
+
+  for (const auto& element_patch : patch_reader.elements()) {
+    ElementMatch match = element_patch.element_match();
+    if (!ApplyElement(match.exe_type(), old_image[match.old_element.region()],
+                      element_patch, new_image[match.new_element.region()]))
+      return status::kStatusFatal;
+  }
+
+  if (!patch_reader.CheckNewFile(ConstBufferView(new_image))) {
+    LOG(ERROR) << "Invalid new_image.";
+    return status::kStatusInvalidNewImage;
+  }
+  return status::kStatusSuccess;
+}
+
+}  // namespace zucchini
diff --git a/src/lib.rs b/src/lib.rs
index 481528e..30b156b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -7,6 +7,7 @@ mod payload;
 #[cfg(feature = "python")]
 mod python;
 mod verity;
+pub mod zucchini;
 
 use std::cmp::Reverse;
 use std::collections::HashSet;
diff --git a/src/zucchini.rs b/src/zucchini.rs
new file mode 100644
index 0000000..89fc892
--- /dev/null
+++ b/src/zucchini.rs
@@ -0,0 +1,135 @@
+use std::error;
+use std::fmt;
+
+#[cfg(otadump_zucchini)]
+const OFFSET_BOUND: usize = (u32::MAX / 2) as usize;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Status {
+    InvalidArgument,
+    InvalidPatch,
+    UnsupportedElement,
+    WrongOutputSize,
+    ApplyError,
+    AllocationFailure,
+    UnsupportedTarget,
+    Unknown(i32),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Error {
+    status: Status,
+    message: String,
+}
+
+impl Error {
+    pub fn status(&self) -> Status {
+        self.status
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str(&self.message)
+    }
+}
+
+impl error::Error for Error {}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Applies a Zucchini patch into a newly allocated, exact-size output buffer.
+///
+/// The native boundary borrows `old` and `patch` only for this call. The output
+/// allocation is distinct from both inputs, as required by Zucchini.
+pub fn apply(old: &[u8], patch: &[u8], output_size: usize) -> Result<Vec<u8>> {
+    apply_impl(old, patch, output_size)
+}
+
+#[cfg(otadump_zucchini)]
+fn apply_impl(old: &[u8], patch: &[u8], output_size: usize) -> Result<Vec<u8>> {
+    if old.len() >= OFFSET_BOUND || output_size >= OFFSET_BOUND {
+        return Err(Error {
+            status: Status::InvalidArgument,
+            message: "image exceeds Zucchini offset bound".into(),
+        });
+    }
+
+    let mut output = Vec::new();
+    output.try_reserve_exact(output_size).map_err(|error| Error {
+        status: Status::AllocationFailure,
+        message: format!("unable to allocate Zucchini output: {error}"),
+    })?;
+    output.resize(output_size, 0);
+
+    apply_native(old, patch, &mut output)?;
+    Ok(output)
+}
+
+#[cfg(not(otadump_zucchini))]
+fn apply_impl(_old: &[u8], _patch: &[u8], _output_size: usize) -> Result<Vec<u8>> {
+    Err(Error {
+        status: Status::UnsupportedTarget,
+        message: "Zucchini is supported only on Linux x86_64 GNU hosts".into(),
+    })
+}
+
+#[cfg(otadump_zucchini)]
+fn apply_native(old: &[u8], patch: &[u8], output: &mut [u8]) -> Result<()> {
+    use std::ffi::{CStr, c_char};
+
+    #[repr(C)]
+    struct NativeResult {
+        status: i32,
+        error: *const c_char,
+    }
+
+    unsafe extern "C" {
+        fn otadump_zucchini_apply(
+            old_data: *const u8,
+            old_size: usize,
+            patch_data: *const u8,
+            patch_size: usize,
+            new_data: *mut u8,
+            new_size: usize,
+        ) -> NativeResult;
+    }
+
+    // SAFETY: The slices remain alive for the call. `output` is a separate
+    // owned allocation and cannot overlap either borrowed input. The native
+    // function validates every length before it performs pointer arithmetic.
+    let result = unsafe {
+        otadump_zucchini_apply(
+            old.as_ptr(),
+            old.len(),
+            patch.as_ptr(),
+            patch.len(),
+            output.as_mut_ptr(),
+            output.len(),
+        )
+    };
+    if result.status == 0 {
+        return Ok(());
+    }
+
+    let message = if result.error.is_null() {
+        format!("Zucchini failed with status {}", result.status)
+    } else {
+        // SAFETY: Native errors point to static NUL-terminated strings. Copy
+        // the message before returning so Rust does not retain the pointer.
+        unsafe { CStr::from_ptr(result.error) }.to_string_lossy().into_owned()
+    };
+    Err(Error { status: native_status(result.status), message })
+}
+
+#[cfg(otadump_zucchini)]
+fn native_status(status: i32) -> Status {
+    match status {
+        1 => Status::InvalidArgument,
+        2 => Status::InvalidPatch,
+        3 => Status::UnsupportedElement,
+        4 => Status::WrongOutputSize,
+        5 => Status::ApplyError,
+        status => Status::Unknown(status),
+    }
+}
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index 5eebaac..01da18b 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -105,6 +105,56 @@ const BROTLI_INVALID_HEADER_PATCH: &[u8] = &[
     0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
 ];
 
+#[cfg(otadump_zucchini)]
+const ZUCCHINI_FIXTURES: &str = "tests/fixtures/zucchini";
+
+#[cfg(otadump_zucchini)]
+fn assert_zucchini_fixture(name: &str, extension: &str) {
+    let fixtures = Path::new(ZUCCHINI_FIXTURES);
+    let old = fs::read(fixtures.join(format!("{name}-old{extension}"))).unwrap();
+    let expected = fs::read(fixtures.join(format!("{name}-new{extension}"))).unwrap();
+    let patch = fs::read(fixtures.join(format!("{name}.zuc"))).unwrap();
+    let output = otadump::zucchini::apply(&old, &patch, expected.len()).unwrap();
+    assert_eq!(output, expected);
+}
+
+#[test]
+#[cfg(otadump_zucchini)]
+fn zucchini_wrapper_applies_android_formats_exactly() {
+    assert_zucchini_fixture("noop", ".bin");
+    assert_zucchini_fixture("dex", ".dex");
+    assert_zucchini_fixture("elf-x86", "");
+    assert_zucchini_fixture("elf", "");
+    assert_zucchini_fixture("elf-arm32", "");
+    assert_zucchini_fixture("elf-arm64", "");
+}
+
+#[test]
+#[cfg(otadump_zucchini)]
+fn zucchini_wrapper_applies_large_dex_jumbo_reference() {
+    assert_zucchini_fixture("dex-large", ".dex");
+}
+
+#[test]
+#[cfg(otadump_zucchini)]
+fn zucchini_wrapper_rejects_unsafe_large_dex_string16_reference() {
+    let fixtures = Path::new(ZUCCHINI_FIXTURES);
+    let old = fs::read(fixtures.join("dex-large-old.dex")).unwrap();
+    let patch = fs::read(fixtures.join("dex-large-unsafe16.zuc")).unwrap();
+    let expected_size = fs::metadata(fixtures.join("dex-large-new.dex")).unwrap().len() as usize;
+    let error = otadump::zucchini::apply(&old, &patch, expected_size).unwrap_err();
+    assert_eq!(error.status(), otadump::zucchini::Status::ApplyError);
+    assert_eq!(error.to_string(), "android executable preflight failed");
+}
+
+#[test]
+#[cfg(otadump_zucchini)]
+fn zucchini_wrapper_returns_owned_error_for_malformed_patch() {
+    let error = otadump::zucchini::apply(b"abcd", b"not a patch", 5).unwrap_err();
+    assert_eq!(error.status(), otadump::zucchini::Status::InvalidPatch);
+    assert_eq!(error.to_string(), "invalid ensemble patch");
+}
+
 fn extent(start_block: u64, num_blocks: u64) -> Extent {
     Extent { start_block: Some(start_block), num_blocks: Some(num_blocks) }
 }
diff --git a/tests/fixtures/zucchini/LICENSE b/tests/fixtures/zucchini/LICENSE
new file mode 100644
index 0000000..2ae33ee
--- /dev/null
+++ b/tests/fixtures/zucchini/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, dumpbot contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/tests/fixtures/zucchini/README.md b/tests/fixtures/zucchini/README.md
new file mode 100644
index 0000000..dd31923
--- /dev/null
+++ b/tests/fixtures/zucchini/README.md
@@ -0,0 +1,22 @@
+# Zucchini fixture provenance
+
+These fixtures use the BSD-3-Clause terms in `LICENSE`.
+`SHA256SUMS` records every binary fixture digest.
+
+The NoOp patch is the complete serialized fixture from the pinned upstream `patch_read_write_unittest.cc` field layout used by the Milestone 5a proof.
+
+The DEX and ELF fixtures were generated by the audited proof tooling from:
+
+- AOSP `external/zucchini` at `e256025d9d9c906caba814fd7b99a311ac8b8ec1`
+- AOSP `external/libchrome` at `0aba0dccfcd93d8303678a4beb61594f7582c73c`
+- Clang 22 for the x86-64 ELF pair
+
+The small DEX files are deterministic DEX 035 files.
+The ELF files cover x86, x86-64, AArch32, and AArch64 reference correction.
+
+The large DEX pair contains 65,537 strings, one `const-string` 16-bit reference to index 2, and one `const-string/jumbo` 32-bit reference to index 65,536.
+The pair was generated bytewise as DEX 035 and patched with the pinned proof's `GenerateBuffer` fixture tool.
+The target changes one same-length string while preserving both code references.
+`dex-large-unsafe16.zuc` changes reference-delta entry 5 from encoded zero to encoded `+2`.
+This resolves the 16-bit writer to the existing jumbo target at index 65,536 and must fail in preflight.
+The expected bytes are stored independently and are not constructed by the adapter tests.
diff --git a/tests/fixtures/zucchini/SHA256SUMS b/tests/fixtures/zucchini/SHA256SUMS
new file mode 100644
index 0000000..71e5b8f
--- /dev/null
+++ b/tests/fixtures/zucchini/SHA256SUMS
@@ -0,0 +1,22 @@
+bdf755e070b6cba4f0ea478130c261906c12c0f1fcd0a665effb24dda6db18b5  dex-large-new.dex
+c837542fb547d892cbc597a39951bc6b3b0398ec89ff76a472a5c0d720e05ae3  dex-large-old.dex
+ebad167e527b375967bef5932e7af4dd7317c4d905b4227f1ab5da6fdb2d4515  dex-large-unsafe16.zuc
+fef404d99db5d6e9570f6673a78a5a4d4dcf23616648812debd66d65947b5afc  dex-large.zuc
+63e76d95aaaa6bdcedf79b2a8f3b55736fb5e9899e021a6be5190fba2d820080  dex-new.dex
+3b06060663ae19133d71d72a1f3b40d9bf4716fb4d6fc83d7ae039d01e80e945  dex-old.dex
+88f7512d4fb07ef897804d370ab1db699104c8b72be3be36e29adb5970fed8d5  dex.zuc
+2664d1c48bf0a2a2e7b3f8b1a9bd38e08055580adf42f2d53ef6abd7dcc65f30  elf-arm32-new
+a5a51e66fb5f923113eeb1f5df5c020c715df6a16d691c5a6030e36d920c625c  elf-arm32-old
+852f01e48651fbcd093f6eb2f075fc59feb470413e79e6f9ddc16b9f2cdcec4c  elf-arm32.zuc
+5125780242c5b230291ba47102734e422e09255e66e6b711a0657aca8098b8b6  elf-arm64-new
+d101a04d15a4b975f01d179fbf8b98771acdb31edb71dca4d8de40fa88189ecb  elf-arm64-old
+0b6c484b0b8cfc2c22ff0257a1e3677e36948bb2f8062a099e88fa4cc4ddf9d7  elf-arm64.zuc
+1e2080509d361c7e87f3434a3ed2f7a9be1b6972fcfb48fb531f0311e5820d7c  elf-new
+32ae88b0151c4afff7b9a88524a554ce517055257ebdd17329fb23fefde75c55  elf-old
+9d5187d155ff0acbb22118ade13032b20d6efc1ebfaf95c970e83d8d2f33b9cd  elf-x86-new
+7eb3c69419c3221a489fa0ba12bfeb94d258f14212a8e108ee130a31c83dda3b  elf-x86-old
+3bd7d0fc9454f38707d6af56ba9d1382d8a700e7dbda0f4955dcffc748b93915  elf-x86.zuc
+7015ce4ab2589a48815f734366f01fa9c7553f06480274fd43e9ed85311afeaa  elf.zuc
+ff55ebfb1b1889f3d0544b00dfabed96de8e4e4234e857043dba47a7a210d019  noop-new.bin
+88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589  noop-old.bin
+dec6c4f3e44a1ae18c48efb1c25e59288ecaad04997b8668ce2de0abcf3342d9  noop.zuc
diff --git a/tests/fixtures/zucchini/dex-large-new.dex b/tests/fixtures/zucchini/dex-large-new.dex
new file mode 100644
index 0000000000000000000000000000000000000000..b7cc69be02b020c15ab4f3914718e04708a28b37
GIT binary patch
literal 786788
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

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/dex-large-old.dex b/tests/fixtures/zucchini/dex-large-old.dex
new file mode 100644
index 0000000000000000000000000000000000000000..e7e1b4b4692a70d36e9bbf0c35cfbe5c9334d46d
GIT binary patch
literal 786788
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

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/dex-large-unsafe16.zuc b/tests/fixtures/zucchini/dex-large-unsafe16.zuc
new file mode 100644
index 0000000000000000000000000000000000000000..a451b84982b173d8b211a6a338ffd4a8feb29522
GIT binary patch
literal 65758
zcmeIuze>YU7>D7ct^aCU+rdF`2ySi#5gZ-tC|$+1b#M>_5u8Qw798xYSOh0GM;F1t
z`!GMDUd3}D@A;CGWO&YQCX=!#ifP#?o_1#A><{D3tvt)h{bD~JomOR$lcS_+)_J=d
zR`oVLzikiq4~qNm_s^eEWAOEI^}Kg+a`^gjdEMQf&GYK~v7gU&dw;*Er&fJg1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZ;9p>{n92-|q?xpmrDQo-Nmi4!q@AoMour%el8vOF
F`~pX}82<nO

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/dex-large.zuc b/tests/fixtures/zucchini/dex-large.zuc
new file mode 100644
index 0000000000000000000000000000000000000000..bd78635bd6d287da2ee379b639ef21cb406f6b87
GIT binary patch
literal 65758
zcmeIuJxT*n7>3cA#NU|2q_9vd20Oce2$mM63~9wSv9J&X5v)aV3l?T82EoeC(nhdw
zAI>YJa1ZAe&v)<4ohi=Q&16y*MKLYg#nbL=ocS=`+Rn4AoEP(Ccv_W3-W(@Yv(DSy
zpsL68{I)eXI4thJ-#>qbjsDlm)${(v=;-z1^18D#o9F8Mv6s*Gx_`f@cNPHx1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oU%u&|jR&Y#K>3SxT0Zm1H$pOV*QCvXQitPSQ;_lV0)*
DMe`W@

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/dex-new.dex b/tests/fixtures/zucchini/dex-new.dex
new file mode 100644
index 0000000000000000000000000000000000000000..fdcb0a1ad48edf59837c23eae94e5e258ce4e1b9
GIT binary patch
literal 400
zcmYdEt>7{+Hf0FYd62b!-D^Ix3xeOCaj%#^Yf;+KmpAKHPGDqUC}3b<s0cF=0#aZg
z0u*BfvOwa@K->bvKp}<+Knw#Q{v03%(My2%3=kiI;<G^dArQX>;txO!0w8rDvp|>$
zh+%*Q$^glOFbKfpe?Yhl>^=cS`T1$q3_?CxiDilUIf;4c`u<5-smUeQ3|wG2J)lGq
z17jEib5Us?L>tgF&IXuKU?GtCd_c?vQ2@6OBo6a0NCV8zAQ~hG@;68x#0L494ax@j
dn@Is82l6`ukPT7;ayO#_gbfxDfUrT~3IG<oFa-br

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/dex-old.dex b/tests/fixtures/zucchini/dex-old.dex
new file mode 100644
index 0000000000000000000000000000000000000000..dd86313be17af9f8f9190b20e8d41a5fc93b112e
GIT binary patch
literal 400
zcmYdEt>7{+Hf4CP8TzKL`eTCY^dC7Dnyqd-cb0lP`)N&@z{tQ*z`(#z5oRI;q`*J~
zD8>q8fy9}CxCMxTLJSjt7zRN6IY11emjLk@AU*=cXMyxXAbtzPAAlGHK<YqdfiM#g
z!vG7E0g?w{5P-@5fN&YueFBQ|^V6&ugnY6R%M$f-67$ma{gbj%lS`}_xWICHAPEM>
zFb3wL(maSZplO^9Fr&aiAoKZvm<yr+ZXZY-=3kHon4dv3NDkz0kUWSD@-rKh4e~dW
b0z?kvcLpFEqz2?}Mg<5PEFb`3gTfU6Z@Vrl

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/dex.zuc b/tests/fixtures/zucchini/dex.zuc
new file mode 100644
index 0000000000000000000000000000000000000000..0eda0acc86d71aaee248cd231a215b0320fb6091
GIT binary patch
literal 223
zcmazlO-^QHU|^U4B(xcvFM(*Oi5GQ1VjuwG!)O=R2n9w4kbnb-P+$TQAD9$?WJ+oU
zmw~Y<LzvEkto7?&^O;=`{Pv7{#r#=|(vH5oS+^3T@-!nz6QdxIzyNSTux%jK49p;c
m1w^od2sRMG4k9=}1Sg2#0ukIGf(JzKf(Skk!4Dz?Km-8D-5O8;

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-arm32-new b/tests/fixtures/zucchini/elf-arm32-new
new file mode 100644
index 0000000000000000000000000000000000000000..2d847c950ecf6a33ce31853bedd50b0e45600dab
GIT binary patch
literal 280
zcmb<-^>JflWMqH=CI$@#Fi(Ji!2~F{04ia^pa2xtU|?oo0?Q|W#DQu+SOG|ZFe?zV
z05LKEn)MoJ%0s#T`d|!VqhP&~)QS=Yz2c1GlA@BtBxJp$uz~h~-Ngpd1awmZkWv6*
Y7=XEp9VoyI69m!?KrD#F2blu`09U>jL;wH)

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-arm32-old b/tests/fixtures/zucchini/elf-arm32-old
new file mode 100644
index 0000000000000000000000000000000000000000..ffadf72210379a5047a9bdc80114be0d621026dd
GIT binary patch
literal 280
zcmb<-^>JflWMqH=CI$@#Fi(Ji!2~F{04ia^pa2xtU|?oo0?Q|W#DQu+SOG|ZFe?zV
z05KYP4K(GU+<$#A2C-4FUP)?234>m7MsZ0|Nn#S3UZS~-K$RfO2GRj^Qv#4u0Ad(`
Wxr-erzzh=v(hWc?h{Ok(0RjM51{XsB

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-arm32.zuc b/tests/fixtures/zucchini/elf-arm32.zuc
new file mode 100644
index 0000000000000000000000000000000000000000..ef284fc95d7fcf2f39f1d71f13a9eee9214cbfe2
GIT binary patch
literal 103
zcmazlO-^QHU|^5{5{ss<Tm+)krG3LeVjuwG!)RAWV<SceumG4~0!qvP5pVz!W@3hM
JA&Nj`4gfgp2W9{O

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-arm64-new b/tests/fixtures/zucchini/elf-arm64-new
new file mode 100644
index 0000000000000000000000000000000000000000..67131d58780d6e8343f4d36d463b5885529e876f
GIT binary patch
literal 384
zcmb<-^>JfjWMqH=CWh?{V4eU(!~rUC07`=>2L=nE8V3eu1}3mtRwOxeW&_k{7|j4R
z7p9Jxfnkcg0`t`a%<<Pi7$y#<^-5AJN*MHtGm1-!N)nUc;#6XQoCm^eF!P}9Yk=|<
jVB%1k1&z-R<OBTx3<)SufY1w|TtO%eqoBb7<1zpMFclHM

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-arm64-old b/tests/fixtures/zucchini/elf-arm64-old
new file mode 100644
index 0000000000000000000000000000000000000000..8ebf0873599d47124f3b1d9f0de4ebd8047bdc46
GIT binary patch
literal 384
zcmb<-^>JfjWMqH=CWh?{V4eU(!~rUC07`=>2L=nE8V3eu1}3mtRwOxeW&_k{7|j4R
z7p9Jhfnkcg0`t`a%<<Pi7$y#<^-5AJN*MHtGm1-!N)nUc;#6XQoCm^eF!P}9Yk=|<
kVB%1k1&z-R<TC>?&>s+>0HGE@C<Z|&4WppJ0pl_N05260z5oCK

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-arm64.zuc b/tests/fixtures/zucchini/elf-arm64.zuc
new file mode 100644
index 0000000000000000000000000000000000000000..a9d24a6ab29b360930a7b543648cd771ad604e76
GIT binary patch
literal 104
zcmazlO-^QHU|?tf5;{V&=7Q+w$t#0FVjuwG!)RAWGZRJzumG4~0?9K&<RK(Tm<cWd
KQ3O)e!w3M;`Uz(M

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-new b/tests/fixtures/zucchini/elf-new
new file mode 100755
index 0000000000000000000000000000000000000000..06a022ad4a49730f8134d117dbb08aaa276bd894
GIT binary patch
literal 4680
zcmeHLu}T9$5Pf%ELc}7cje;Or*a!yfEJUu+%6~X6WYt0=<QCM*Z}2ZHE%QBAwthjJ
zxt%$aB>_o23%76P&Ah$4*X_Jr-CU<h0$nLC(PVkiP+<pp+u8vXI7do*2U*jb{go(E
zMZiy~DIyO9zoWyU<dF9%_Cp&K+dkn9%mH)2954sW0dv3{FbB*5bHE%h2h0I;;QtPM
z^F{o9dO`cytl!+omx{S9!_O=(ZZ$-LuHN6JVV5xH=|IHqD1TT;XMlqh{P7AN?&0=y
z?4Act@YUqbd6ea_uFIM-iruL46~TA}4C>cMUkwTUB;dV9-o5yR&saOzCnbB-)f4o;
zWxmnQF{HjYGYQ&MwR4z@{zJG8LVkLZ?+I=SFKG)?(Vw(T2>4s)7ms)N+<1M7{wONM
F`d_MhD;NL(

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-old b/tests/fixtures/zucchini/elf-old
new file mode 100755
index 0000000000000000000000000000000000000000..e6affdc917bf1ee5032186e14e1e08a38aaa924c
GIT binary patch
literal 4680
zcmeHLF;2rk5F8sP3ZjUi0SO5~L4!mjItql`K*b*{M>bFdBE?rg#TR%6C1u`2Mav7q
z?%l3QPDDb~dy;Q<XLru_bhj^8H`i&BKv#-O_$)6x6?R~-tsOvtbELHQkon&1r$mt|
z0=`R45qTi^9X$>uhrCa57}}uN^$Bla4wwVxfH`0em;>g3IbaT$1LlA^U=ElAe|O-M
zFXFHB3);^XLw_UxRm^P}z7}zD%M%IudViOOUBaBF0};QY{9z%T0S?yi$7^^rliSnj
zq#jM-s@YxRP?qDiEnCVcZtBWa1dlZ^YM&omH70bkfcF}?=E<#m#=nz&QnE*VJwg9l
z<{RA{L+YzDlb}siyM(#u--O#B<YyrHp5UhNl6Ei`{Yl4!fWLKl@py;Njn{|hkD@}X
F{|1*{D+~Yt

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-x86-new b/tests/fixtures/zucchini/elf-x86-new
new file mode 100644
index 0000000000000000000000000000000000000000..37eacaf23803d65f2d8a94c4493163726d97cb6a
GIT binary patch
literal 280
zcmb<-^>JflWMqH=CI)5(Fi(Ji!2~F{04ia^pa2xt0Ln6f<r6^SKs6w&0Hi>e6^L1Y
z7#X}^2l6K11`K*7sTCy*dc_&VB}FBPNyvIhVT0TZ!fYT-KsO}-DFq;g0hqf$&S8cL
P0_g@I7DVEM%m4uZSqB<(

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-x86-old b/tests/fixtures/zucchini/elf-x86-old
new file mode 100644
index 0000000000000000000000000000000000000000..af782f7d20676cbc1aee60230e6a57436c2b29b7
GIT binary patch
literal 280
zcmb<-^>JflWMqH=CI)5(Fi(Ji!2~F{04ia^pa2xt0Ln6f<r6^SKs6w&0Hi>e6^L1Y
z7#X}^2J$B01`K*7sTCy*dc_&VB}FBPNyvIhVT0TZ!fYT-KsO}-DFq;g0hqhkfdU{W
R!9W9$Aqe9DX^<Hp0034i8gBpq

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-x86.zuc b/tests/fixtures/zucchini/elf-x86.zuc
new file mode 100644
index 0000000000000000000000000000000000000000..cb6636799c9625c7ba47124500f32bca18d2e40a
GIT binary patch
literal 103
zcmazlO-^QHU|^5{5)(c}=YVLx?X${3VjuwG!)VtE3o}LrumG4~0!qvP5pVz!W@3hM
JA&Nj`4gi!x2%7)^

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf.zuc b/tests/fixtures/zucchini/elf.zuc
new file mode 100644
index 0000000000000000000000000000000000000000..e50ae63228e013cfa6688c9c0077823273f635d7
GIT binary patch
literal 112
zcmazlO-^QHU|{eNVqnP0RJ;qK?Xr1)fW$xm#D~$Y6=o)k3}6{B!32~zp#qX+1L9VN
Y?Lbi$AdB(;PhqeEW{?~Rz?Cxq09r*16951J

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/noop-new.bin b/tests/fixtures/zucchini/noop-new.bin
new file mode 100644
index 0000000..dbfa1e1
--- /dev/null
+++ b/tests/fixtures/zucchini/noop-new.bin
@@ -0,0 +1 @@
+aXcde
\ No newline at end of file
diff --git a/tests/fixtures/zucchini/noop-old.bin b/tests/fixtures/zucchini/noop-old.bin
new file mode 100644
index 0000000..85df507
--- /dev/null
+++ b/tests/fixtures/zucchini/noop-old.bin
@@ -0,0 +1 @@
+abcd
\ No newline at end of file
diff --git a/tests/fixtures/zucchini/noop.zuc b/tests/fixtures/zucchini/noop.zuc
new file mode 100644
index 0000000000000000000000000000000000000000..e96505cd17b3f63c9f1268f150e2a76539c2d96e
GIT binary patch
literal 88
zcmazlO-^QHU|?VYV!^XbZ&`u#f&+q5ATbaCiGu)0+%Mn1fRO<#11DHOtW*%e2qL}#
HF&F><@Qw&&

literal 0
HcmV?d00001


From 0291aee2408938b5817f4d2e23b41d282ce2d63b Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Fri, 11 Sep 2026 18:51:45 +0530
Subject: [PATCH 08/42] zucchini: Apply OTA patch operations

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 README.md                                     |   4 +-
 src/lib.rs                                    |  82 +++++++++-
 src/zucchini.rs                               |  10 +-
 tests/delta_extraction.rs                     | 143 ++++++++++++++++++
 tests/fixtures/zucchini/README.md             |  10 ++
 tests/fixtures/zucchini/SHA256SUMS            |   8 +
 tests/fixtures/zucchini/dex.zuc.br            | Bin 0 -> 146 bytes
 tests/fixtures/zucchini/elf-arm32.zuc.br      | Bin 0 -> 72 bytes
 tests/fixtures/zucchini/elf-arm64.zuc.br      | Bin 0 -> 74 bytes
 tests/fixtures/zucchini/elf-x86.zuc.br        | Bin 0 -> 73 bytes
 tests/fixtures/zucchini/elf.zuc.br            | Bin 0 -> 91 bytes
 .../fixtures/zucchini/malformed-brotli.zuc.br |   1 +
 .../zucchini/malformed-zucchini.zuc.br        |   1 +
 tests/fixtures/zucchini/noop.zuc.br           | Bin 0 -> 78 bytes
 14 files changed, 254 insertions(+), 5 deletions(-)
 create mode 100644 tests/fixtures/zucchini/dex.zuc.br
 create mode 100644 tests/fixtures/zucchini/elf-arm32.zuc.br
 create mode 100644 tests/fixtures/zucchini/elf-arm64.zuc.br
 create mode 100644 tests/fixtures/zucchini/elf-x86.zuc.br
 create mode 100644 tests/fixtures/zucchini/elf.zuc.br
 create mode 100644 tests/fixtures/zucchini/malformed-brotli.zuc.br
 create mode 100644 tests/fixtures/zucchini/malformed-zucchini.zuc.br
 create mode 100644 tests/fixtures/zucchini/noop.zuc.br

diff --git a/README.md b/README.md
index f4bf7b6..405787b 100644
--- a/README.md
+++ b/README.md
@@ -81,8 +81,8 @@ otadump ota.zip
 # Run on payload.bin file.
 otadump payload.bin
 
-# Apply a SOURCE_COPY, SOURCE_BSDIFF, or BROTLI_BSDIFF delta payload with
-# matching base partition images.
+# Apply a SOURCE_COPY, SOURCE_BSDIFF, BROTLI_BSDIFF, or ZUCCHINI delta payload
+# with matching base partition images. ZUCCHINI requires Linux x86-64 GNU.
 otadump delta.zip --output-dir output --source-dir source-images
 ```
 
diff --git a/src/lib.rs b/src/lib.rs
index 30b156b..0cf9791 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -21,6 +21,7 @@ use std::sync::{Arc, OnceLock};
 use std::{error, result, slice, thread};
 
 use anyhow::{Context as _, Error, Result, bail, ensure};
+use brotli::Decompressor as BrotliDecoder;
 use bsdiff_android::patch_bsdf2;
 use bzip2::read::BzDecoder;
 use chromeos_update_engine::install_operation::Type;
@@ -41,6 +42,7 @@ pub use crate::payload::Payload;
 // The chunk size is the number of bytes we verify before we count one "tick" in
 // the progress tracker.
 const VERIFY_CHUNK_SIZE: usize = 2 * 1024 * 1024; // 2 MiB
+const BROTLI_DECODE_CHUNK_SIZE: usize = 32 * 1024;
 
 #[derive(Clone, Debug, Default)]
 pub struct CancellationToken {
@@ -897,6 +899,10 @@ impl Task<'_> {
                 let patch = self.extract_data(op).context("Error extracting BROTLI_BSDIFF data")?;
                 self.run_op_bsdiff(op, patch, "BROTLI_BSDIFF", &mut dst_extents)
             }
+            Type::Zucchini => {
+                let patch = self.extract_data(op).context("Error extracting ZUCCHINI data")?;
+                self.run_op_zucchini(op, patch, &mut dst_extents)
+            }
             Type::Zero | Type::Discard => {
                 for extent in dst_extents {
                     for chunk in extent.chunks_mut(VERIFY_CHUNK_SIZE) {
@@ -918,7 +924,8 @@ impl Task<'_> {
         let source = self.source.as_ref().context("Source partition was not opened")?;
         let ranges = extent_ranges(&op.src_extents, self.block_size, source.len)?;
         let capacity = ranges_len(&ranges)?;
-        let mut data = Vec::with_capacity(capacity);
+        let mut data = Vec::new();
+        data.try_reserve_exact(capacity).context("Unable to allocate source extent buffer")?;
         for range in ranges {
             for chunk in source.bytes()[range].chunks(VERIFY_CHUNK_SIZE) {
                 self.cancellation_token.check()?;
@@ -952,6 +959,33 @@ impl Task<'_> {
         self.write_exact(&output, dst_extents)
     }
 
+    fn run_op_zucchini(
+        &self,
+        op: &InstallOperation,
+        compressed_patch: &[u8],
+        dst_extents: &mut [&mut [u8]],
+    ) -> Result<()> {
+        let source_partition = self.source.as_ref().context("Source partition was not opened")?;
+        let source_ranges = extent_ranges(&op.src_extents, self.block_size, source_partition.len)?;
+        let source_len = ranges_len(&source_ranges)?;
+        ensure!(
+            source_len < zucchini::OFFSET_BOUND,
+            "ZUCCHINI source exceeds the maximum size of {} bytes",
+            zucchini::OFFSET_BOUND - 1
+        );
+        let source = self.extract_source_data(op)?;
+        let expected_output_len = dst_extents.iter().try_fold(0usize, |len, extent| {
+            len.checked_add(extent.len()).context("Combined destination length overflow")
+        })?;
+        self.cancellation_token.check()?;
+        let patch = decode_zucchini_patch(compressed_patch, self.cancellation_token)?;
+        self.cancellation_token.check()?;
+        let output = zucchini::apply(&source, &patch, expected_output_len)
+            .map_err(|error| anyhow::anyhow!("ZUCCHINI apply failed: {error}"))?;
+        self.cancellation_token.check()?;
+        self.write_exact(&output, dst_extents)
+    }
+
     fn write_exact(&self, data: &[u8], dst_extents: &mut [&mut [u8]]) -> Result<()> {
         let dst_len = dst_extents.iter().try_fold(0usize, |len, extent| {
             len.checked_add(extent.len()).context("Combined destination length overflow")
@@ -1040,6 +1074,52 @@ impl Task<'_> {
     }
 }
 
+fn decode_zucchini_patch(
+    compressed_patch: &[u8],
+    cancellation_token: &CancellationToken,
+) -> Result<Vec<u8>> {
+    cancellation_token.check()?;
+    let mut decoder = BrotliDecoder::new(compressed_patch, BROTLI_DECODE_CHUNK_SIZE);
+    let mut patch = Vec::new();
+    let mut chunk = [0u8; BROTLI_DECODE_CHUNK_SIZE];
+    let maximum_size = zucchini::OFFSET_BOUND - 1;
+
+    loop {
+        cancellation_token.check()?;
+        let remaining = maximum_size
+            .checked_sub(patch.len())
+            .context("Decoded ZUCCHINI patch length exceeded its bound")?;
+        let read_len = chunk.len().min(remaining.saturating_add(1));
+        let count = decoder
+            .read(&mut chunk[..read_len])
+            .context("Unable to decode ZUCCHINI Brotli patch")?;
+        if count == 0 {
+            cancellation_token.check()?;
+            // The decoder reports buffered trailing input only on a read after
+            // EOF. The source check also catches trailing bytes it did not read.
+            let mut trailing = [0u8; 1];
+            let trailing_count =
+                decoder.read(&mut trailing).context("Unable to decode ZUCCHINI Brotli patch")?;
+            ensure!(
+                trailing_count == 0 && decoder.get_ref().is_empty(),
+                "ZUCCHINI Brotli patch contains trailing data"
+            );
+            break;
+        }
+        ensure!(
+            count <= remaining,
+            "Decoded ZUCCHINI patch exceeds the maximum size of {maximum_size} bytes"
+        );
+        let new_len =
+            patch.len().checked_add(count).context("Decoded ZUCCHINI patch length overflow")?;
+        patch.try_reserve(count).context("Unable to allocate decoded ZUCCHINI patch buffer")?;
+        patch.extend_from_slice(&chunk[..count]);
+        debug_assert_eq!(patch.len(), new_len);
+    }
+
+    Ok(patch)
+}
+
 fn verify_partition(
     update: &PartitionUpdate,
     partition: &[u8],
diff --git a/src/zucchini.rs b/src/zucchini.rs
index 89fc892..579581f 100644
--- a/src/zucchini.rs
+++ b/src/zucchini.rs
@@ -1,8 +1,8 @@
 use std::error;
 use std::fmt;
 
-#[cfg(otadump_zucchini)]
-const OFFSET_BOUND: usize = (u32::MAX / 2) as usize;
+/// Exclusive upper bound for buffers represented by Zucchini offsets.
+pub const OFFSET_BOUND: usize = (u32::MAX / 2) as usize;
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum Status {
@@ -54,6 +54,12 @@ fn apply_impl(old: &[u8], patch: &[u8], output_size: usize) -> Result<Vec<u8>> {
             message: "image exceeds Zucchini offset bound".into(),
         });
     }
+    if patch.len() >= OFFSET_BOUND {
+        return Err(Error {
+            status: Status::InvalidArgument,
+            message: "patch exceeds Zucchini offset bound".into(),
+        });
+    }
 
     let mut output = Vec::new();
     output.try_reserve_exact(output_size).map_err(|error| Error {
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index 01da18b..bc1ebf2 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -118,6 +118,116 @@ fn assert_zucchini_fixture(name: &str, extension: &str) {
     assert_eq!(output, expected);
 }
 
+#[cfg(otadump_zucchini)]
+fn assert_zucchini_extraction(name: &str, extension: &str) {
+    let fixtures = Path::new(ZUCCHINI_FIXTURES);
+    let old = fs::read(fixtures.join(format!("{name}-old{extension}"))).unwrap();
+    let target = fs::read(fixtures.join(format!("{name}-new{extension}"))).unwrap();
+    let patch = fs::read(fixtures.join(format!("{name}.zuc.br"))).unwrap();
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+
+    let old_split = old.len() / 2;
+    let mut source = Vec::with_capacity(old.len() + 1);
+    source.extend_from_slice(&old[..old_split]);
+    source.push(0xa5);
+    source.extend_from_slice(&old[old_split..]);
+    fs::write(source_dir.join("system.img"), &source).unwrap();
+
+    let target_split = target.len() / 2;
+    let mut expected = Vec::with_capacity(target.len() + 1);
+    expected.extend_from_slice(&target[..target_split]);
+    expected.push(0);
+    expected.extend_from_slice(&target[target_split..]);
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(1),
+        minor_version: Some(8),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(&source)),
+            new_partition_info: Some(partition_info(&expected)),
+            operations: vec![InstallOperation {
+                operation_type: 11,
+                data_offset: Some(0),
+                data_length: Some(patch.len() as u64),
+                src_extents: vec![
+                    extent(0, old_split as u64),
+                    extent((old_split + 1) as u64, (old.len() - old_split) as u64),
+                ],
+                src_length: Some(old.len() as u64),
+                dst_extents: vec![
+                    extent(0, target_split as u64),
+                    extent((target_split + 1) as u64, (target.len() - target_split) as u64),
+                ],
+                dst_length: Some(target.len() as u64),
+                data_sha256_hash: Some(sha256(&patch)),
+                src_sha256_hash: Some(sha256(&old)),
+            }],
+            ..Default::default()
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &patch);
+
+    ExtractOptions::new()
+        .source_dir(&source_dir)
+        .num_threads(2)
+        .extract(&payload, &output_dir)
+        .unwrap();
+
+    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), expected);
+    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+    assert_eq!(fs::read_dir(&output_dir).unwrap().count(), 1);
+}
+
+#[cfg(otadump_zucchini)]
+fn assert_zucchini_extraction_fails(patch_name: &str, expected_error: &str) {
+    let patch = fs::read(Path::new(ZUCCHINI_FIXTURES).join(patch_name)).unwrap();
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+    let source = b"abcd";
+    fs::write(source_dir.join("system.img"), source).unwrap();
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(1),
+        minor_version: Some(8),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(source)),
+            new_partition_info: Some(partition_info(source)),
+            operations: vec![InstallOperation {
+                operation_type: 11,
+                data_offset: Some(0),
+                data_length: Some(patch.len() as u64),
+                src_extents: vec![extent(0, source.len() as u64)],
+                src_length: Some(source.len() as u64),
+                dst_extents: vec![extent(0, source.len() as u64)],
+                dst_length: Some(source.len() as u64),
+                data_sha256_hash: Some(sha256(&patch)),
+                src_sha256_hash: Some(sha256(source)),
+            }],
+            ..Default::default()
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &patch);
+
+    let error = ExtractOptions::new()
+        .source_dir(&source_dir)
+        .num_threads(2)
+        .extract(&payload, &output_dir)
+        .unwrap_err()
+        .to_string();
+
+    assert!(error.contains(expected_error), "unexpected error: {error}");
+    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+    assert!(!output_dir.join("system.img").exists());
+    assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
+}
+
 #[test]
 #[cfg(otadump_zucchini)]
 fn zucchini_wrapper_applies_android_formats_exactly() {
@@ -129,6 +239,39 @@ fn zucchini_wrapper_applies_android_formats_exactly() {
     assert_zucchini_fixture("elf-arm64", "");
 }
 
+#[test]
+#[cfg(otadump_zucchini)]
+fn zucchini_operations_reconstruct_android_formats_exactly() {
+    for (name, extension) in [
+        ("noop", ".bin"),
+        ("dex", ".dex"),
+        ("elf-x86", ""),
+        ("elf", ""),
+        ("elf-arm32", ""),
+        ("elf-arm64", ""),
+    ] {
+        assert_zucchini_extraction(name, extension);
+    }
+}
+
+#[test]
+#[cfg(otadump_zucchini)]
+fn zucchini_operation_rejects_malformed_outer_brotli_without_publication() {
+    assert_zucchini_extraction_fails(
+        "malformed-brotli.zuc.br",
+        "Unable to decode ZUCCHINI Brotli patch",
+    );
+}
+
+#[test]
+#[cfg(otadump_zucchini)]
+fn zucchini_operation_rejects_malformed_inner_patch_without_publication() {
+    assert_zucchini_extraction_fails(
+        "malformed-zucchini.zuc.br",
+        "ZUCCHINI apply failed: invalid ensemble patch",
+    );
+}
+
 #[test]
 #[cfg(otadump_zucchini)]
 fn zucchini_wrapper_applies_large_dex_jumbo_reference() {
diff --git a/tests/fixtures/zucchini/README.md b/tests/fixtures/zucchini/README.md
index dd31923..95c804f 100644
--- a/tests/fixtures/zucchini/README.md
+++ b/tests/fixtures/zucchini/README.md
@@ -20,3 +20,13 @@ The target changes one same-length string while preserving both code references.
 `dex-large-unsafe16.zuc` changes reference-delta entry 5 from encoded zero to encoded `+2`.
 This resolves the 16-bit writer to the existing jumbo target at index 65,536 and must fail in preflight.
 The expected bytes are stored independently and are not constructed by the adapter tests.
+
+The `*.zuc.br` files wrap the matching serialized patches with Brotli.
+They were created offline with the independent Brotli 1.2.0 command-line compressor:
+
+```sh
+brotli --quality=9 --lgwin=20 --stdout input.zuc > input.zuc.br
+```
+
+`malformed-zucchini.zuc.br` is the same Brotli encoding of the ASCII bytes `not a zucchini patch`.
+`malformed-brotli.zuc.br` contains the ASCII bytes `not a Brotli stream` followed by a newline and is intentionally not a Brotli stream.
diff --git a/tests/fixtures/zucchini/SHA256SUMS b/tests/fixtures/zucchini/SHA256SUMS
index 71e5b8f..9a14671 100644
--- a/tests/fixtures/zucchini/SHA256SUMS
+++ b/tests/fixtures/zucchini/SHA256SUMS
@@ -5,18 +5,26 @@ fef404d99db5d6e9570f6673a78a5a4d4dcf23616648812debd66d65947b5afc  dex-large.zuc
 63e76d95aaaa6bdcedf79b2a8f3b55736fb5e9899e021a6be5190fba2d820080  dex-new.dex
 3b06060663ae19133d71d72a1f3b40d9bf4716fb4d6fc83d7ae039d01e80e945  dex-old.dex
 88f7512d4fb07ef897804d370ab1db699104c8b72be3be36e29adb5970fed8d5  dex.zuc
+91dd18f228539cc9fa8b6094a503c58f2a0ed4ffd038e8a0efea9ddd3859e3e8  dex.zuc.br
 2664d1c48bf0a2a2e7b3f8b1a9bd38e08055580adf42f2d53ef6abd7dcc65f30  elf-arm32-new
 a5a51e66fb5f923113eeb1f5df5c020c715df6a16d691c5a6030e36d920c625c  elf-arm32-old
 852f01e48651fbcd093f6eb2f075fc59feb470413e79e6f9ddc16b9f2cdcec4c  elf-arm32.zuc
+5d22c4011510d42f2db22958ab8fef24df44130806c5c873b77dcb872d798358  elf-arm32.zuc.br
 5125780242c5b230291ba47102734e422e09255e66e6b711a0657aca8098b8b6  elf-arm64-new
 d101a04d15a4b975f01d179fbf8b98771acdb31edb71dca4d8de40fa88189ecb  elf-arm64-old
 0b6c484b0b8cfc2c22ff0257a1e3677e36948bb2f8062a099e88fa4cc4ddf9d7  elf-arm64.zuc
+d60e4cf4ebcc47178e4f299d04ed7ea4dceb485d2fe2b05b2ef4de3458ca0b2d  elf-arm64.zuc.br
 1e2080509d361c7e87f3434a3ed2f7a9be1b6972fcfb48fb531f0311e5820d7c  elf-new
 32ae88b0151c4afff7b9a88524a554ce517055257ebdd17329fb23fefde75c55  elf-old
 9d5187d155ff0acbb22118ade13032b20d6efc1ebfaf95c970e83d8d2f33b9cd  elf-x86-new
 7eb3c69419c3221a489fa0ba12bfeb94d258f14212a8e108ee130a31c83dda3b  elf-x86-old
 3bd7d0fc9454f38707d6af56ba9d1382d8a700e7dbda0f4955dcffc748b93915  elf-x86.zuc
+05230ea7dc74f03cd8e5c5bb39c79bea750d0f61de56ae32070f88025c607c43  elf-x86.zuc.br
 7015ce4ab2589a48815f734366f01fa9c7553f06480274fd43e9ed85311afeaa  elf.zuc
+fc8ad67255a38ea5153b7e020ef279e80a07235f69710712eeac82587bcf6f5e  elf.zuc.br
+fd4675a50b0ebdbff64c2f7dfa62fb8d33aaea4cea5358ffb004d3e25634ae8f  malformed-brotli.zuc.br
+2c02a903730016cd9cd79728af16068da480c0770ca55c8d9a82037d5da698a0  malformed-zucchini.zuc.br
 ff55ebfb1b1889f3d0544b00dfabed96de8e4e4234e857043dba47a7a210d019  noop-new.bin
 88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589  noop-old.bin
 dec6c4f3e44a1ae18c48efb1c25e59288ecaad04997b8668ce2de0abcf3342d9  noop.zuc
+d58e45c97d88ea4f5836c687fa15c668c4df5655d445eeca6867d0526a750a70  noop.zuc.br
diff --git a/tests/fixtures/zucchini/dex.zuc.br b/tests/fixtures/zucchini/dex.zuc.br
new file mode 100644
index 0000000000000000000000000000000000000000..a8e52517c24916a74fd6df2049757f7b1f7c889e
GIT binary patch
literal 146
zcmV;D0B!#l-T(l^hrj0gx4vr~eP0DPXlj%f4S3T?iV_+{*=$rnBgmbfP(b``wY3EW
z)WX0bjxD#-Y%{hy--%)}NdVM*n-DzaHr5a3eFs-;g~Bn4h~}$78KfUW@tsOnSi8%E
zi1}Pt%%7rnulz6Eu-h19miJS2bUjx@_#z5gCGy8mOsEEG8d^Gf1}qLwAd-#@09Bbm
Ar~m)}

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-arm32.zuc.br b/tests/fixtures/zucchini/elf-arm32.zuc.br
new file mode 100644
index 0000000000000000000000000000000000000000..7c2709b8b4cd3e8e9e580e9ccef7fe396859b182
GIT binary patch
literal 72
zcmV-O0Jr}aW&i-ha(90(@>}z~fPye?OJCE7i{Ek^8~dvS1>JUdUhCy{ifo>(zw5XQ
e0F&eXNar-B-?#<0w_3npCGj6I&_ng~h^;mSU?nC1

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-arm64.zuc.br b/tests/fixtures/zucchini/elf-arm64.zuc.br
new file mode 100644
index 0000000000000000000000000000000000000000..19c4fbb3f82e8625d39dca9207c893e0823d9e28
GIT binary patch
literal 74
zcmV-Q0JZ-YX8-^M{&V;40!uh-c@R*Re&D=$KyA%q%57}yuhIx2XsqzO&dco-$s41;
gV@d`rImL6!U$5uIEx4_g44RYfA6V%2RFBYX11V`G9smFU

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf-x86.zuc.br b/tests/fixtures/zucchini/elf-x86.zuc.br
new file mode 100644
index 0000000000000000000000000000000000000000..0fa377813edba5d096c3090fdcda9ed4ca3626d1
GIT binary patch
literal 73
zcmV-P0Ji@ZW&i-hZ1?+#jHnAF?YwY0?Mg80B1t{Bv9Z5OP|$6M=e1sLr^x2n`rC%P
f05Ey~9_jk-^c%O}mX#A2tR(&+270KT9<fybg0m(l

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/elf.zuc.br b/tests/fixtures/zucchini/elf.zuc.br
new file mode 100644
index 0000000000000000000000000000000000000000..632ef91d2b85c8ae6848c0362696d6cc3a2e2359
GIT binary patch
literal 91
zcmV-h0HpsHZvX&f>gI3z4Ke}$!fXMjPYqolAqSdB;zhZQZO?10FBAlwpdU8Y$!&=0
x;}@}?VJ!s$0D1#0qkls6%-?x|ookz;%A{EU^_@B}JKY6A4*s7#8VpjrBmm>%CSm{p

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/malformed-brotli.zuc.br b/tests/fixtures/zucchini/malformed-brotli.zuc.br
new file mode 100644
index 0000000..d41f431
--- /dev/null
+++ b/tests/fixtures/zucchini/malformed-brotli.zuc.br
@@ -0,0 +1 @@
+not a Brotli stream
diff --git a/tests/fixtures/zucchini/malformed-zucchini.zuc.br b/tests/fixtures/zucchini/malformed-zucchini.zuc.br
new file mode 100644
index 0000000..b16e974
--- /dev/null
+++ b/tests/fixtures/zucchini/malformed-zucchini.zuc.br
@@ -0,0 +1 @@
+‡	€not a zucchini patch
\ No newline at end of file
diff --git a/tests/fixtures/zucchini/noop.zuc.br b/tests/fixtures/zucchini/noop.zuc.br
new file mode 100644
index 0000000000000000000000000000000000000000..9477010179a4633daacba607a83db298cad15122
GIT binary patch
literal 78
zcmV-U0I~lUR{#JUsZn3d?!Y0p15g5=mjp7ow*``>&^%8)!ayQSYk-0XK~R(P6ME5H
kKWJ-vkt~m~EW?pV%`1Su?We9M@55#@6wR6wPzuRk7UZ5GQ~&?~

literal 0
HcmV?d00001


From 2cbadc0aff0a2c820bfb48d50ea709ea9430164d Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Fri, 11 Sep 2026 19:54:09 +0530
Subject: [PATCH 09/42] puffin: Apply BSDIFF patch operations

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 .github/workflows/release.yaml             |   4 +-
 README.md                                  |   5 +-
 src/lib.rs                                 |  39 +-
 src/puffin/LICENSE                         |  27 +
 src/puffin/README.md                       |  10 +
 src/puffin/bit_io.rs                       | 179 +++++
 src/puffin/huffer.rs                       | 146 ++++
 src/puffin/huffman.rs                      | 766 +++++++++++++++++++++
 src/puffin/mod.rs                          | 104 +++
 src/puffin/patch.rs                        | 523 ++++++++++++++
 src/puffin/puff_io.rs                      | 337 +++++++++
 src/puffin/puffer.rs                       | 159 +++++
 src/puffin/stream.rs                       | 481 +++++++++++++
 tests/delta_extraction.rs                  | 142 ++++
 tests/fixtures/puffin/LICENSE              |  27 +
 tests/fixtures/puffin/README.md            |  13 +
 tests/fixtures/puffin/SHA256SUMS           |   5 +
 tests/fixtures/puffin/deflates-sample1.bin | Bin 0 -> 17 bytes
 tests/fixtures/puffin/deflates-sample2.bin | Bin 0 -> 22 bytes
 tests/fixtures/puffin/patch-1-to-2.puf     | Bin 0 -> 266 bytes
 tests/fixtures/puffin/patch-1-to-raw.puf   | Bin 0 -> 185 bytes
 tests/fixtures/puffin/raw-11-22-33-44.bin  |   1 +
 22 files changed, 2963 insertions(+), 5 deletions(-)
 create mode 100644 src/puffin/LICENSE
 create mode 100644 src/puffin/README.md
 create mode 100644 src/puffin/bit_io.rs
 create mode 100644 src/puffin/huffer.rs
 create mode 100644 src/puffin/huffman.rs
 create mode 100644 src/puffin/mod.rs
 create mode 100644 src/puffin/patch.rs
 create mode 100644 src/puffin/puff_io.rs
 create mode 100644 src/puffin/puffer.rs
 create mode 100644 src/puffin/stream.rs
 create mode 100644 tests/fixtures/puffin/LICENSE
 create mode 100644 tests/fixtures/puffin/README.md
 create mode 100644 tests/fixtures/puffin/SHA256SUMS
 create mode 100644 tests/fixtures/puffin/deflates-sample1.bin
 create mode 100644 tests/fixtures/puffin/deflates-sample2.bin
 create mode 100644 tests/fixtures/puffin/patch-1-to-2.puf
 create mode 100644 tests/fixtures/puffin/patch-1-to-raw.puf
 create mode 100644 tests/fixtures/puffin/raw-11-22-33-44.bin

diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index b0caeb0..dad4e62 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -128,7 +128,7 @@ jobs:
         if: runner.os != 'Windows'
         run: >
           tar -cv
-          LICENSE README.md
+          LICENSE README.md src/puffin/LICENSE
           -C target/${{ matrix.target }}/release/ otadump
           | gzip --best
           > 'otadump-${{ steps.get_version.outputs.value }}-${{ matrix.target }}.tar.gz'
@@ -136,7 +136,7 @@ jobs:
         if: runner.os == 'Windows'
         run: >
           7z a 'otadump-${{ steps.get_version.outputs.value }}-${{ matrix.target }}.zip'
-          LICENSE README.md
+          LICENSE README.md src/puffin/LICENSE
           ./target/${{ matrix.target }}/release/otadump.exe
       - name: Upload artifact
         uses: actions/upload-artifact@v4.6.0
diff --git a/README.md b/README.md
index 405787b..9cbc4b4 100644
--- a/README.md
+++ b/README.md
@@ -81,8 +81,9 @@ otadump ota.zip
 # Run on payload.bin file.
 otadump payload.bin
 
-# Apply a SOURCE_COPY, SOURCE_BSDIFF, BROTLI_BSDIFF, or ZUCCHINI delta payload
-# with matching base partition images. ZUCCHINI requires Linux x86-64 GNU.
+# Apply a SOURCE_COPY, SOURCE_BSDIFF, BROTLI_BSDIFF, PUFFDIFF (inner BSDIFF),
+# or ZUCCHINI delta payload with matching base partition images.
+# ZUCCHINI requires Linux x86-64 GNU.
 otadump delta.zip --output-dir output --source-dir source-images
 ```
 
diff --git a/src/lib.rs b/src/lib.rs
index 0cf9791..7dea119 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,6 +4,7 @@ mod chromeos_update_engine {
     include!(concat!(env!("OUT_DIR"), "/chromeos_update_engine.rs"));
 }
 mod payload;
+mod puffin;
 #[cfg(feature = "python")]
 mod python;
 mod verity;
@@ -903,6 +904,10 @@ impl Task<'_> {
                 let patch = self.extract_data(op).context("Error extracting ZUCCHINI data")?;
                 self.run_op_zucchini(op, patch, &mut dst_extents)
             }
+            Type::Puffdiff => {
+                let patch = self.extract_data(op).context("Error extracting PUFFDIFF data")?;
+                self.run_op_puffdiff(op, patch, &mut dst_extents)
+            }
             Type::Zero | Type::Discard => {
                 for extent in dst_extents {
                     for chunk in extent.chunks_mut(VERIFY_CHUNK_SIZE) {
@@ -949,6 +954,9 @@ impl Task<'_> {
         validate_bsdiff_output_len(patch, expected_output_len)
             .map_err(|error| anyhow::anyhow!("{operation} patch is invalid: {error}"))?;
         self.cancellation_token.check()?;
+        puffin::validate_bsdiff_resources(patch, expected_output_len, self.cancellation_token)
+            .map_err(|error| anyhow::anyhow!("{operation} patch is invalid: {error}"))?;
+        self.cancellation_token.check()?;
         let mut output = Vec::new();
         output
             .try_reserve_exact(expected_output_len)
@@ -986,6 +994,34 @@ impl Task<'_> {
         self.write_exact(&output, dst_extents)
     }
 
+    fn run_op_puffdiff(
+        &self,
+        op: &InstallOperation,
+        patch: &[u8],
+        dst_extents: &mut [&mut [u8]],
+    ) -> Result<()> {
+        let source_partition = self.source.as_ref().context("Source partition was not opened")?;
+        let source_ranges = extent_ranges(&op.src_extents, self.block_size, source_partition.len)?;
+        let source_size = ranges_len(&source_ranges)?;
+        let destination_size = dst_extents.iter().try_fold(0usize, |size, extent| {
+            size.checked_add(extent.len()).context("Combined PUFFDIFF destination length overflow")
+        })?;
+        ensure!(
+            source_size < zucchini::OFFSET_BOUND && destination_size < zucchini::OFFSET_BOUND,
+            "PUFFDIFF raw stream exceeds the maximum size of {} bytes",
+            zucchini::OFFSET_BOUND - 1
+        );
+        let source = self.extract_source_data(op)?;
+        self.cancellation_token.check()?;
+        let output = puffin::apply(&source, patch, destination_size, self.cancellation_token)
+            .map_err(|error| {
+                let message = error.to_string();
+                anyhow::Error::new(error).context(format!("PUFFDIFF apply failed: {message}"))
+            })?;
+        self.cancellation_token.check()?;
+        self.write_exact(&output, dst_extents)
+    }
+
     fn write_exact(&self, data: &[u8], dst_extents: &mut [&mut [u8]]) -> Result<()> {
         let dst_len = dst_extents.iter().try_fold(0usize, |len, extent| {
             len.checked_add(extent.len()).context("Combined destination length overflow")
@@ -1170,7 +1206,8 @@ fn validate_bsdiff_output_len(patch: &[u8], expected: usize) -> Result<()> {
         &patch[..8] == b"BSDIFF40" || &patch[..5] == b"BSDF2",
         "Invalid BSDIFF/BSDF2 magic header"
     );
-    let encoded = u64::from_le_bytes(patch[24..32].try_into().unwrap());
+    let encoded =
+        u64::from_le_bytes(patch[24..32].try_into().context("Invalid BSDIFF output length field")?);
     ensure!(encoded & (1 << 63) == 0, "Negative output length in patch header");
     let actual = usize::try_from(encoded).context("Patch output length is too large")?;
     ensure!(actual == expected, "Patch output length mismatch: expected {expected}, got {actual}");
diff --git a/src/puffin/LICENSE b/src/puffin/LICENSE
new file mode 100644
index 0000000..f6d41c6
--- /dev/null
+++ b/src/puffin/LICENSE
@@ -0,0 +1,27 @@
+// Copyright 2017 The ChromiumOS Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/src/puffin/README.md b/src/puffin/README.md
new file mode 100644
index 0000000..9cc6e37
--- /dev/null
+++ b/src/puffin/README.md
@@ -0,0 +1,10 @@
+# Puffin-derived Rust code
+
+This module adapts the pure-Rust Puffin implementation from `puffdiff` 0.1.0.
+That crate ports ChromiumOS Puffin's parser, bit I/O, PuffData I/O, Huffman table, puffer, huffer, and whole-buffer stream code.
+
+The reference Puffin revision is `343e23db1b4d81045e91a10244244893f5acd73b`.
+The Rust code is restricted to PUF1 parsing and inner BSDIFF application.
+It adds checked arithmetic, fallible allocations, operation size bounds, and cooperative cancellation for otadump.
+
+The code is available under the BSD-3-Clause terms in `LICENSE`.
diff --git a/src/puffin/bit_io.rs b/src/puffin/bit_io.rs
new file mode 100644
index 0000000..45ab098
--- /dev/null
+++ b/src/puffin/bit_io.rs
@@ -0,0 +1,179 @@
+// Copyright 2017 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Adapted from puffdiff 0.1.0, a pure-Rust port of ChromiumOS Puffin.
+
+//! LSB-first bit reader/writer, ported from puffin `bit_reader.cc` /
+//! `bit_writer.cc`. Deflate packs bits least-significant-first within each byte.
+
+use crate::puffin::{Error, Result};
+
+/// Reads bits from a byte buffer, LSB-first, exactly like `BufferBitReader`.
+pub struct BitReader<'a> {
+    buf: &'a [u8],
+    index: usize,      // next byte to pull into the cache
+    cache: u32,        // pending bits, LSB = next bit to read
+    cache_bits: usize, // number of valid bits in `cache`
+}
+
+impl<'a> BitReader<'a> {
+    pub fn new(buf: &'a [u8]) -> Self {
+        BitReader { buf, index: 0, cache: 0, cache_bits: 0 }
+    }
+
+    /// Ensure at least `nbits` bits are cached. Max 32.
+    pub fn cache_bits(&mut self, nbits: usize) -> bool {
+        if (self.buf.len() - self.index) * 8 + self.cache_bits < nbits {
+            return false;
+        }
+        if nbits > 32 {
+            return false;
+        }
+        while self.cache_bits < nbits {
+            self.cache |= (self.buf[self.index] as u32) << self.cache_bits;
+            self.index += 1;
+            self.cache_bits += 8;
+        }
+        true
+    }
+
+    /// Peek the low `nbits` cached bits (call `cache_bits` first).
+    pub fn read_bits(&self, nbits: usize) -> u32 {
+        if nbits == 0 {
+            return 0;
+        }
+        if nbits >= 32 {
+            return self.cache;
+        }
+        self.cache & ((1u32 << nbits) - 1)
+    }
+
+    pub fn drop_bits(&mut self, nbits: usize) {
+        self.cache >>= nbits;
+        self.cache_bits -= nbits;
+    }
+
+    pub fn cached_bits(&self) -> usize {
+        self.cache_bits
+    }
+
+    pub fn offset_in_bits(&self) -> Result<usize> {
+        self.index
+            .checked_mul(8)
+            .and_then(|offset| offset.checked_sub(self.cache_bits))
+            .ok_or_else(|| Error::Corrupt("bit reader position is invalid".into()))
+    }
+
+    pub fn read_boundary_bits(&self) -> u8 {
+        (self.cache & ((1u32 << (self.cache_bits & 7)) - 1)) as u8
+    }
+
+    pub fn skip_boundary_bits(&mut self) -> usize {
+        let nbits = self.cache_bits & 7;
+        self.cache >>= nbits;
+        self.cache_bits -= nbits;
+        nbits
+    }
+
+    pub fn offset(&self) -> usize {
+        self.index - self.cache_bits / 8
+    }
+
+    pub fn bits_remaining(&self) -> u64 {
+        ((self.buf.len() - self.index) as u64) * 8 + self.cache_bits as u64
+    }
+
+    /// Rewind the cache to the current byte boundary and read `count` raw bytes.
+    /// Mirrors `GetByteReaderFn`: subsequent bit reads start on a byte boundary.
+    pub fn get_bytes(&mut self, count: usize) -> Result<&'a [u8]> {
+        self.index -= self.cache_bits.div_ceil(8);
+        self.cache = 0;
+        self.cache_bits = 0;
+        if count > self.buf.len() - self.index {
+            return Err(Error::Corrupt("get_bytes out of range".into()));
+        }
+        let slice = &self.buf[self.index..self.index + count];
+        self.index += count;
+        Ok(slice)
+    }
+}
+
+/// Writes bits into a fixed-size byte buffer, LSB-first, like `BufferBitWriter`.
+pub struct BitWriter<'a> {
+    out: &'a mut [u8],
+    index: usize,
+    holder: u32,
+    holder_bits: usize,
+}
+
+impl<'a> BitWriter<'a> {
+    pub fn new(out: &'a mut [u8]) -> Self {
+        BitWriter { out, index: 0, holder: 0, holder_bits: 0 }
+    }
+
+    pub fn write_bits(&mut self, mut nbits: usize, mut bits: u32) -> Result<()> {
+        if ((self.out.len() - self.index) * 8).saturating_sub(self.holder_bits) < nbits {
+            return Err(Error::Corrupt("bit writer overflow".into()));
+        }
+        if nbits > 32 {
+            return Err(Error::Corrupt("write_bits > 32".into()));
+        }
+        while nbits > 0 {
+            while self.holder_bits >= 8 {
+                self.out[self.index] = (self.holder & 0xFF) as u8;
+                self.index += 1;
+                self.holder >>= 8;
+                self.holder_bits -= 8;
+            }
+            while self.holder_bits < 24 && nbits > 0 {
+                self.holder |= (bits & 0xFF) << self.holder_bits;
+                let min = nbits.min(8);
+                self.holder_bits += min;
+                bits >>= min;
+                nbits -= min;
+            }
+        }
+        Ok(())
+    }
+
+    /// Write `data` verbatim; requires the writer to be on a byte boundary.
+    pub fn write_bytes(&mut self, data: &[u8]) -> Result<()> {
+        if ((self.out.len() - self.index) * 8).saturating_sub(self.holder_bits) < data.len() * 8 {
+            return Err(Error::Corrupt("bit writer byte overflow".into()));
+        }
+        if self.holder_bits % 8 != 0 {
+            return Err(Error::Corrupt("write_bytes not byte aligned".into()));
+        }
+        self.flush()?;
+        self.out[self.index..self.index + data.len()].copy_from_slice(data);
+        self.index += data.len();
+        Ok(())
+    }
+
+    pub fn write_boundary_bits(&mut self, bits: u8) -> Result<()> {
+        self.write_bits((8 - (self.holder_bits & 7)) & 7, bits as u32)
+    }
+
+    pub fn flush(&mut self) -> Result<()> {
+        self.write_boundary_bits(0)?;
+        while self.holder_bits > 0 {
+            self.out[self.index] = (self.holder & 0xFF) as u8;
+            self.index += 1;
+            self.holder >>= 8;
+            self.holder_bits -= 8;
+        }
+        Ok(())
+    }
+
+    pub fn size(&self) -> usize {
+        self.index
+    }
+
+    pub fn offset_in_bits(&self) -> Result<usize> {
+        self.index
+            .checked_mul(8)
+            .and_then(|offset| offset.checked_add(self.holder_bits))
+            .ok_or_else(|| Error::Corrupt("bit writer position overflows".into()))
+    }
+}
diff --git a/src/puffin/huffer.rs b/src/puffin/huffer.rs
new file mode 100644
index 0000000..f2712e9
--- /dev/null
+++ b/src/puffin/huffer.rs
@@ -0,0 +1,146 @@
+// Copyright 2017 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Adapted from puffdiff 0.1.0, a pure-Rust port of ChromiumOS Puffin.
+
+//! Puff -> deflate transform, ported from puffin `huffer.cc`.
+
+use crate::CancellationToken;
+use crate::puffin::bit_io::BitWriter;
+use crate::puffin::huffman::{
+    BlockType, DISTANCE_BASES, DISTANCE_EXTRA_BITS, HuffmanTable, LENGTH_BASES, LENGTH_EXTRA_BITS,
+};
+use crate::puffin::puff_io::{PuffData, PuffReader};
+use crate::puffin::{Error, Result, check_cancelled};
+
+/// Re-encode puff tokens from `pr` back into a bit-exact deflate stream in `bw`.
+pub fn huff_deflate(
+    pr: &mut PuffReader,
+    bw: &mut BitWriter,
+    cancellation_token: &CancellationToken,
+) -> Result<()> {
+    let mut fixed_ht = HuffmanTable::new()?;
+    let mut dyn_ht = HuffmanTable::new()?;
+    let mut fixed_built = false;
+
+    while pr.bytes_left() != 0 {
+        check_cancelled(cancellation_token)?;
+        let pd = pr.get_next()?;
+        let meta = match pd {
+            PuffData::BlockMetadata(m) => m,
+            _ => return Err(Error::Corrupt("expected block metadata".into())),
+        };
+        let header = meta[0];
+        let final_bit = (header & 0x80) >> 7;
+        let btype = (header & 0x60) >> 5;
+        let skipped_bits = header & 0x1F;
+
+        bw.write_bits(1, final_bit as u32)?;
+        bw.write_bits(2, btype as u32)?;
+
+        let use_dynamic = match BlockType::from_bits(btype)? {
+            BlockType::Uncompressed => {
+                bw.write_boundary_bits(skipped_bits)?;
+                let next = pr.get_next()?;
+                match next {
+                    PuffData::Literals(raw) => {
+                        bw.write_bits(16, raw.len() as u32)?;
+                        bw.write_bits(16, !(raw.len() as u32) & 0xFFFF)?;
+                        bw.write_bytes(raw)?;
+                        match pr.get_next()? {
+                            PuffData::EndOfBlock => {}
+                            _ => return Err(Error::Corrupt("uncompressed block not ended".into())),
+                        }
+                    }
+                    PuffData::EndOfBlock => {
+                        bw.write_bits(16, 0)?;
+                        bw.write_bits(16, 0xFFFF)?;
+                    }
+                    PuffData::Literal(_) => {
+                        return Err(Error::Corrupt("unexpected single literal".into()));
+                    }
+                    _ => return Err(Error::Corrupt("uncompressed block malformed".into())),
+                }
+                continue;
+            }
+            BlockType::Fixed => {
+                if !fixed_built {
+                    fixed_ht.build_fixed()?;
+                    fixed_built = true;
+                }
+                false
+            }
+            BlockType::Dynamic => {
+                dyn_ht.build_dynamic_from_puff(&meta[1..], bw)?;
+                true
+            }
+        };
+
+        let mut block_ended = false;
+        while !block_ended {
+            check_cancelled(cancellation_token)?;
+            let pd = pr.get_next()?;
+            let cur_ht: &HuffmanTable = if use_dynamic { &dyn_ht } else { &fixed_ht };
+            match pd {
+                PuffData::Literal(b) => {
+                    let (code, nbits) = cur_ht.lit_len_huffman(b as u16)?;
+                    bw.write_bits(nbits, code as u32)?;
+                }
+                PuffData::Literals(bytes) => {
+                    for &b in bytes {
+                        check_cancelled(cancellation_token)?;
+                        let (code, nbits) = cur_ht.lit_len_huffman(b as u16)?;
+                        bw.write_bits(nbits, code as u32)?;
+                    }
+                }
+                PuffData::LenDist { length, distance } => {
+                    if !(3..=258).contains(&length) {
+                        return Err(Error::Corrupt("length out of range".into()));
+                    }
+                    // Linear search for the length base (guard stops us short).
+                    let mut index = 0usize;
+                    while length > LENGTH_BASES[index] as usize {
+                        index += 1;
+                    }
+                    if length < LENGTH_BASES[index] as usize {
+                        index -= 1;
+                    }
+                    let extra_len = LENGTH_EXTRA_BITS[index] as usize;
+                    let (code, nbits) = cur_ht.lit_len_huffman((index + 257) as u16)?;
+                    bw.write_bits(nbits, code as u32)?;
+                    if extra_len > 0 {
+                        bw.write_bits(extra_len, (length - LENGTH_BASES[index] as usize) as u32)?;
+                    }
+
+                    let mut index = 0usize;
+                    while distance > DISTANCE_BASES[index] as usize {
+                        index += 1;
+                    }
+                    if distance < DISTANCE_BASES[index] as usize {
+                        index -= 1;
+                    }
+                    let extra_len = DISTANCE_EXTRA_BITS[index] as usize;
+                    let (code, nbits) = cur_ht.distance_huffman(index as u16)?;
+                    bw.write_bits(nbits, code as u32)?;
+                    if extra_len > 0 {
+                        bw.write_bits(
+                            extra_len,
+                            (distance - DISTANCE_BASES[index] as usize) as u32,
+                        )?;
+                    }
+                }
+                PuffData::EndOfBlock => {
+                    let (code, nbits) = cur_ht.lit_len_huffman(256)?;
+                    bw.write_bits(nbits, code as u32)?;
+                    block_ended = true;
+                }
+                PuffData::BlockMetadata(_) => {
+                    return Err(Error::Corrupt("unexpected block metadata".into()));
+                }
+            }
+        }
+    }
+    check_cancelled(cancellation_token)?;
+    Ok(())
+}
diff --git a/src/puffin/huffman.rs b/src/puffin/huffman.rs
new file mode 100644
index 0000000..f5eeb1f
--- /dev/null
+++ b/src/puffin/huffman.rs
@@ -0,0 +1,766 @@
+// Copyright 2017 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Adapted from puffdiff 0.1.0, a pure-Rust port of ChromiumOS Puffin.
+
+//! RFC1951 Huffman handling, ported from puffin `huffman_table.cc`.
+//!
+//! Builds canonical decode/encode tables and (de)serializes a dynamic Huffman
+//! block header to/from the puff `block_metadata` blob. Byte-for-byte fidelity
+//! with puffin is required.
+
+use crate::puffin::bit_io::{BitReader, BitWriter};
+use crate::puffin::{Error, Result};
+
+pub const MAX_HUFFMAN_BITS: usize = 15;
+
+const PERMUTATIONS: [u8; 19] = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+
+pub const LENGTH_BASES: [u16; 30] = [
+    3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131,
+    163, 195, 227, 258, 0xFFFF,
+];
+
+pub const LENGTH_EXTRA_BITS: [u8; 29] =
+    [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
+
+pub const DISTANCE_BASES: [u16; 31] = [
+    1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537,
+    2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0xFFFF,
+];
+
+pub const DISTANCE_EXTRA_BITS: [u8; 30] = [
+    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13,
+    13,
+];
+
+fn replace_bytes(target: &mut Vec<u8>, bytes: &[u8], label: &str) -> Result<()> {
+    target.clear();
+    target
+        .try_reserve_exact(bytes.len())
+        .map_err(|error| Error::Allocation(format!("{label}: {error}")))?;
+    target.extend_from_slice(bytes);
+    Ok(())
+}
+
+fn fill_bytes(target: &mut Vec<u8>, length: usize, value: u8, label: &str) -> Result<()> {
+    target.clear();
+    target
+        .try_reserve_exact(length)
+        .map_err(|error| Error::Allocation(format!("{label}: {error}")))?;
+    target.resize(length, value);
+    Ok(())
+}
+
+#[derive(Clone, Copy)]
+pub enum BlockType {
+    Uncompressed,
+    Fixed,
+    Dynamic,
+}
+
+impl BlockType {
+    pub fn from_bits(v: u8) -> Result<BlockType> {
+        match v {
+            0 => Ok(BlockType::Uncompressed),
+            1 => Ok(BlockType::Fixed),
+            2 => Ok(BlockType::Dynamic),
+            _ => Err(Error::Corrupt("invalid block type".into())),
+        }
+    }
+}
+
+/// One (canonical code, alphabet index) pair used while building tables.
+#[derive(Clone, Copy)]
+struct CodeIndexPair {
+    code: u16,
+    index: u16,
+}
+
+/// Holds the current block's literal/length, distance and code-length tables.
+pub struct HuffmanTable {
+    lit_len_lens: Vec<u8>,
+    lit_len_hcodes: Vec<u16>,
+    lit_len_rcodes: Vec<u16>,
+    lit_len_max_bits: usize,
+
+    distance_lens: Vec<u8>,
+    distance_hcodes: Vec<u16>,
+    distance_rcodes: Vec<u16>,
+    distance_max_bits: usize,
+
+    code_lens: Vec<u8>,
+    code_hcodes: Vec<u16>,
+    code_rcodes: Vec<u16>,
+    code_max_bits: usize,
+
+    tmp_lens: Vec<u8>,
+    pairs: Vec<CodeIndexPair>,
+}
+
+impl HuffmanTable {
+    pub fn new() -> Result<Self> {
+        let mut code_lens = Vec::new();
+        code_lens
+            .try_reserve_exact(19)
+            .map_err(|error| Error::Allocation(format!("Huffman code lengths: {error}")))?;
+        code_lens.resize(19, 0);
+        let mut pairs = Vec::new();
+        pairs
+            .try_reserve_exact(288)
+            .map_err(|error| Error::Allocation(format!("Huffman code pairs: {error}")))?;
+        Ok(HuffmanTable {
+            lit_len_lens: Vec::new(),
+            lit_len_hcodes: Vec::new(),
+            lit_len_rcodes: Vec::new(),
+            lit_len_max_bits: 0,
+            distance_lens: Vec::new(),
+            distance_hcodes: Vec::new(),
+            distance_rcodes: Vec::new(),
+            distance_max_bits: 0,
+            code_lens,
+            code_hcodes: Vec::new(),
+            code_rcodes: Vec::new(),
+            code_max_bits: 0,
+            tmp_lens: Vec::new(),
+            pairs,
+        })
+    }
+
+    pub fn lit_len_max_bits(&self) -> usize {
+        self.lit_len_max_bits
+    }
+    pub fn distance_max_bits(&self) -> usize {
+        self.distance_max_bits
+    }
+
+    /// Decode lookup: map `bits` (max_bits wide) to a lit/len alphabet + code
+    /// length. Returns `(alphabet, nbits)`.
+    pub fn lit_len_alphabet(&self, bits: u32) -> Result<(u16, usize)> {
+        let hc = *self
+            .lit_len_hcodes
+            .get(bits as usize)
+            .ok_or_else(|| Error::Corrupt("lit/len lookup is out of range".into()))?;
+        if hc & 0x8000 == 0 {
+            return Err(Error::Corrupt("invalid lit/len code".into()));
+        }
+        let alphabet = hc & 0x7FFF;
+        let length = *self
+            .lit_len_lens
+            .get(alphabet as usize)
+            .ok_or_else(|| Error::Corrupt("lit/len alphabet is out of range".into()))?;
+        Ok((alphabet, length as usize))
+    }
+
+    pub fn distance_alphabet(&self, bits: u32) -> Result<(u16, usize)> {
+        let hc = *self
+            .distance_hcodes
+            .get(bits as usize)
+            .ok_or_else(|| Error::Corrupt("distance lookup is out of range".into()))?;
+        if hc & 0x8000 == 0 {
+            return Err(Error::Corrupt("invalid distance code".into()));
+        }
+        let alphabet = hc & 0x7FFF;
+        let length = *self
+            .distance_lens
+            .get(alphabet as usize)
+            .ok_or_else(|| Error::Corrupt("distance alphabet is out of range".into()))?;
+        Ok((alphabet, length as usize))
+    }
+
+    fn code_alphabet(&self, bits: u32) -> Result<(u16, usize)> {
+        let hc = *self
+            .code_hcodes
+            .get(bits as usize)
+            .ok_or_else(|| Error::Corrupt("code-length lookup is out of range".into()))?;
+        if hc & 0x8000 == 0 {
+            return Err(Error::Corrupt("invalid code-length code".into()));
+        }
+        let alphabet = hc & 0x7FFF;
+        let length = *self
+            .code_lens
+            .get(alphabet as usize)
+            .ok_or_else(|| Error::Corrupt("code-length alphabet is out of range".into()))?;
+        Ok((alphabet, length as usize))
+    }
+
+    pub fn end_of_block_bit_length(&self) -> Result<usize> {
+        if 256 >= self.lit_len_lens.len() {
+            return Err(Error::Corrupt("no end-of-block symbol".into()));
+        }
+        Ok(self.lit_len_lens[256] as usize)
+    }
+
+    /// Encode lookup: alphabet -> (huffman code, nbits).
+    pub fn lit_len_huffman(&self, alphabet: u16) -> Result<(u16, usize)> {
+        if (alphabet as usize) >= self.lit_len_lens.len() {
+            return Err(Error::Corrupt("lit/len alphabet out of range".into()));
+        }
+        Ok((self.lit_len_rcodes[alphabet as usize], self.lit_len_lens[alphabet as usize] as usize))
+    }
+
+    pub fn distance_huffman(&self, alphabet: u16) -> Result<(u16, usize)> {
+        if (alphabet as usize) >= self.distance_lens.len() {
+            return Err(Error::Corrupt("distance alphabet out of range".into()));
+        }
+        Ok((
+            self.distance_rcodes[alphabet as usize],
+            self.distance_lens[alphabet as usize] as usize,
+        ))
+    }
+
+    fn code_huffman(&self, alphabet: u16) -> Result<(u16, usize)> {
+        if (alphabet as usize) >= self.code_lens.len() {
+            return Err(Error::Corrupt("code alphabet out of range".into()));
+        }
+        Ok((self.code_rcodes[alphabet as usize], self.code_lens[alphabet as usize] as usize))
+    }
+
+    /// Compute canonical codes from an array of code lengths, filling `pairs`.
+    /// Returns the max code length seen (0 if all lengths are zero).
+    fn init_huffman_codes(lens: &[u8], pairs: &mut Vec<CodeIndexPair>) -> Result<usize> {
+        let mut len_count = [0u16; MAX_HUFFMAN_BITS + 1];
+        for &l in lens {
+            let count = len_count
+                .get_mut(l as usize)
+                .ok_or_else(|| Error::Corrupt("Huffman code length exceeds 15 bits".into()))?;
+            *count = count
+                .checked_add(1)
+                .ok_or_else(|| Error::Corrupt("Huffman code count overflows".into()))?;
+        }
+
+        let mut max_bits = 0usize;
+        for bits in (1..=MAX_HUFFMAN_BITS).rev() {
+            if len_count[bits] != 0 {
+                max_bits = bits;
+                break;
+            }
+        }
+
+        let mut available = 1i32;
+        for count in len_count.iter().take(MAX_HUFFMAN_BITS + 1).skip(1) {
+            available = available
+                .checked_mul(2)
+                .and_then(|slots| slots.checked_sub(i32::from(*count)))
+                .ok_or_else(|| Error::Corrupt("Huffman code-space accounting overflows".into()))?;
+            if available < 0 {
+                return Err(Error::Corrupt("oversubscribed code lengths".into()));
+            }
+        }
+
+        let mut code = 0u16;
+        len_count[0] = 0;
+        let mut next_code = [0u16; MAX_HUFFMAN_BITS + 1];
+        for bits in 1..=MAX_HUFFMAN_BITS {
+            code = (code + len_count[bits - 1]) << 1;
+            next_code[bits] = code;
+        }
+
+        pairs.clear();
+        for (idx, &len_u8) in lens.iter().enumerate() {
+            let len = len_u8 as usize;
+            if len == 0 {
+                continue;
+            }
+            // Bit-reverse the canonical code (deflate reads codes MSB-first).
+            let mut rev = 0u16;
+            let mut tmp = next_code[len];
+            for _ in 0..len {
+                rev <<= 1;
+                rev |= tmp & 1;
+                tmp >>= 1;
+            }
+            pairs.push(CodeIndexPair { code: rev, index: idx as u16 });
+            next_code[len] += 1;
+        }
+        Ok(max_bits)
+    }
+
+    fn build_huffman_codes(
+        lens: &[u8],
+        pairs: &mut [CodeIndexPair],
+        hcodes: &mut Vec<u16>,
+        max_bits: usize,
+    ) -> Result<()> {
+        // Sort descending by code length so shorter codes fill the don't-care
+        // slots without overwriting exact matches.
+        pairs.sort_by(|a, b| lens[b.index as usize].cmp(&lens[a.index as usize]));
+        hcodes.clear();
+        let size = 1usize
+            .checked_shl(max_bits as u32)
+            .ok_or_else(|| Error::Corrupt("Huffman lookup size overflows".into()))?;
+        hcodes
+            .try_reserve_exact(size)
+            .map_err(|error| Error::Allocation(format!("Huffman lookup table: {error}")))?;
+        hcodes.resize(size, 0);
+        for cip in pairs.iter() {
+            let slot = hcodes
+                .get_mut(cip.code as usize)
+                .ok_or_else(|| Error::Corrupt("Huffman code exceeds lookup table".into()))?;
+            *slot = cip.index | 0x8000;
+            let code_len = lens[cip.index as usize] as usize;
+            let fill_bits = max_bits - code_len;
+            for idx in 1..(1usize << fill_bits) {
+                let location = (idx << code_len) | cip.code as usize;
+                let slot = hcodes
+                    .get_mut(location)
+                    .ok_or_else(|| Error::Corrupt("Huffman fill exceeds lookup table".into()))?;
+                if *slot & 0x8000 == 0 {
+                    *slot = cip.index | 0x8000;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn build_huffman_reverse_codes(
+        lens: &[u8],
+        pairs: &mut [CodeIndexPair],
+        rcodes: &mut Vec<u16>,
+    ) -> Result<()> {
+        pairs.sort_by_key(|pair| pair.index);
+        rcodes.clear();
+        rcodes
+            .try_reserve_exact(lens.len())
+            .map_err(|error| Error::Allocation(format!("Huffman reverse table: {error}")))?;
+        rcodes.resize(lens.len(), 0);
+        let mut i = 0usize;
+        for (idx, slot) in rcodes.iter_mut().enumerate() {
+            if i < pairs.len() && idx == pairs[i].index as usize {
+                *slot = pairs[i].code;
+                i += 1;
+            } else {
+                *slot = 0;
+            }
+        }
+        Ok(())
+    }
+
+    pub fn build_fixed(&mut self) -> Result<()> {
+        fill_bytes(&mut self.lit_len_lens, 288, 0, "fixed literal lengths")?;
+        let mut i = 0;
+        while i < 144 {
+            self.lit_len_lens[i] = 8;
+            i += 1;
+        }
+        while i < 256 {
+            self.lit_len_lens[i] = 9;
+            i += 1;
+        }
+        while i < 280 {
+            self.lit_len_lens[i] = 7;
+            i += 1;
+        }
+        while i < 288 {
+            self.lit_len_lens[i] = 8;
+            i += 1;
+        }
+        fill_bytes(&mut self.distance_lens, 30, 5, "fixed distance lengths")?;
+
+        let mut pairs;
+        {
+            self.lit_len_max_bits = Self::init_huffman_codes(&self.lit_len_lens, &mut self.pairs)?;
+            pairs = std::mem::take(&mut self.pairs);
+            Self::build_huffman_codes(
+                &self.lit_len_lens,
+                &mut pairs,
+                &mut self.lit_len_hcodes,
+                self.lit_len_max_bits,
+            )?;
+            self.pairs = pairs;
+        }
+        {
+            self.distance_max_bits =
+                Self::init_huffman_codes(&self.distance_lens, &mut self.pairs)?;
+            pairs = std::mem::take(&mut self.pairs);
+            Self::build_huffman_codes(
+                &self.distance_lens,
+                &mut pairs,
+                &mut self.distance_hcodes,
+                self.distance_max_bits,
+            )?;
+            self.pairs = pairs;
+        }
+        // reverse codes for the encode direction
+        {
+            let _ = Self::init_huffman_codes(&self.lit_len_lens, &mut self.pairs)?;
+            pairs = std::mem::take(&mut self.pairs);
+            Self::build_huffman_reverse_codes(
+                &self.lit_len_lens,
+                &mut pairs,
+                &mut self.lit_len_rcodes,
+            )?;
+            self.pairs = pairs;
+        }
+        {
+            let _ = Self::init_huffman_codes(&self.distance_lens, &mut self.pairs)?;
+            pairs = std::mem::take(&mut self.pairs);
+            Self::build_huffman_reverse_codes(
+                &self.distance_lens,
+                &mut pairs,
+                &mut self.distance_rcodes,
+            )?;
+            self.pairs = pairs;
+        }
+        Ok(())
+    }
+
+    fn check_array_lengths(
+        num_lit_len: usize,
+        num_distance: usize,
+        num_codes: usize,
+    ) -> Result<()> {
+        if num_lit_len > 286 || num_distance > 30 || num_codes > 19 {
+            return Err(Error::Corrupt("dynamic huffman array lengths invalid".into()));
+        }
+        Ok(())
+    }
+
+    /// Read a dynamic Huffman block header from the deflate stream `br`, writing
+    /// its puff encoding into `buffer`. Returns bytes written to `buffer`.
+    pub fn build_dynamic_from_deflate(
+        &mut self,
+        br: &mut BitReader,
+        buffer: &mut [u8],
+    ) -> Result<usize> {
+        if buffer.len() < 3 {
+            return Err(Error::Corrupt("metadata buffer too small".into()));
+        }
+        let mut index = 0usize;
+        if !br.cache_bits(14) {
+            return Err(Error::Corrupt("eof reading dynamic header".into()));
+        }
+        buffer[index] = br.read_bits(5) as u8;
+        let num_lit_len = br.read_bits(5) as usize + 257;
+        br.drop_bits(5);
+        index += 1;
+
+        buffer[index] = br.read_bits(5) as u8;
+        let num_distance = br.read_bits(5) as usize + 1;
+        br.drop_bits(5);
+        index += 1;
+
+        buffer[index] = br.read_bits(4) as u8;
+        let num_codes = br.read_bits(4) as usize + 4;
+        br.drop_bits(4);
+        index += 1;
+
+        Self::check_array_lengths(num_lit_len, num_distance, num_codes)?;
+
+        let mut checked = false;
+        if buffer.len() - index < num_codes.div_ceil(2) {
+            return Err(Error::Corrupt("metadata buffer too small for codes".into()));
+        }
+        let mut idx = 0usize;
+        while idx < num_codes {
+            if !br.cache_bits(3) {
+                return Err(Error::Corrupt("eof reading code lengths".into()));
+            }
+            self.code_lens[PERMUTATIONS[idx] as usize] = br.read_bits(3) as u8;
+            if checked {
+                buffer[index] |= br.read_bits(3) as u8;
+                index += 1;
+            } else {
+                buffer[index] = (br.read_bits(3) as u8) << 4;
+            }
+            checked = !checked;
+            br.drop_bits(3);
+            idx += 1;
+        }
+        if checked {
+            index += 1;
+        }
+        while idx < 19 {
+            self.code_lens[PERMUTATIONS[idx] as usize] = 0;
+            idx += 1;
+        }
+
+        self.code_max_bits = Self::init_huffman_codes(&self.code_lens, &mut self.pairs)?;
+        let mut pairs = std::mem::take(&mut self.pairs);
+        Self::build_huffman_codes(
+            &self.code_lens,
+            &mut pairs,
+            &mut self.code_hcodes,
+            self.code_max_bits,
+        )?;
+        self.pairs = pairs;
+
+        // Read the lit/len + distance code-length arrays (RLE-coded).
+        let written = self.read_code_lengths_from_deflate(
+            br,
+            &mut buffer[index..],
+            self.code_max_bits,
+            num_lit_len + num_distance,
+        )?;
+        index += written;
+
+        let tmp = std::mem::take(&mut self.tmp_lens);
+        replace_bytes(&mut self.lit_len_lens, &tmp[..num_lit_len], "dynamic literal lengths")?;
+        replace_bytes(&mut self.distance_lens, &tmp[num_lit_len..], "dynamic distance lengths")?;
+        self.tmp_lens = tmp;
+
+        self.lit_len_max_bits = Self::init_huffman_codes(&self.lit_len_lens, &mut self.pairs)?;
+        let mut pairs = std::mem::take(&mut self.pairs);
+        Self::build_huffman_codes(
+            &self.lit_len_lens,
+            &mut pairs,
+            &mut self.lit_len_hcodes,
+            self.lit_len_max_bits,
+        )?;
+        self.pairs = pairs;
+
+        self.distance_max_bits = Self::init_huffman_codes(&self.distance_lens, &mut self.pairs)?;
+        let mut pairs = std::mem::take(&mut self.pairs);
+        Self::build_huffman_codes(
+            &self.distance_lens,
+            &mut pairs,
+            &mut self.distance_hcodes,
+            self.distance_max_bits,
+        )?;
+        self.pairs = pairs;
+
+        Ok(index)
+    }
+
+    fn read_code_lengths_from_deflate(
+        &mut self,
+        br: &mut BitReader,
+        buffer: &mut [u8],
+        max_bits: usize,
+        num_codes: usize,
+    ) -> Result<usize> {
+        let mut index = 0usize;
+        let mut lens = Vec::new();
+        lens.try_reserve_exact(num_codes)
+            .map_err(|error| Error::Allocation(format!("dynamic code lengths: {error}")))?;
+        let mut idx = 0usize;
+        while idx < num_codes {
+            if !br.cache_bits(max_bits) {
+                return Err(Error::Corrupt("eof reading code length codes".into()));
+            }
+            let bits = br.read_bits(max_bits);
+            let (code, nbits) = self.code_alphabet(bits)?;
+            if index >= buffer.len() {
+                return Err(Error::Corrupt("code length buffer overflow".into()));
+            }
+            br.drop_bits(nbits);
+            if code < 16 {
+                buffer[index] = code as u8;
+                index += 1;
+                lens.push(code as u8);
+                idx += 1;
+            } else {
+                if code >= 19 {
+                    return Err(Error::Corrupt("invalid code-length code".into()));
+                }
+                let (copy_num, copy_val) = match code {
+                    16 => {
+                        if idx == 0 {
+                            return Err(Error::Corrupt("repeat with no previous length".into()));
+                        }
+                        if !br.cache_bits(2) {
+                            return Err(Error::Corrupt("eof reading repeat".into()));
+                        }
+                        let n = 3 + br.read_bits(2) as usize;
+                        buffer[index] = 16 + br.read_bits(2) as u8;
+                        index += 1;
+                        let v = lens[idx - 1];
+                        br.drop_bits(2);
+                        (n, v)
+                    }
+                    17 => {
+                        if !br.cache_bits(3) {
+                            return Err(Error::Corrupt("eof reading repeat".into()));
+                        }
+                        let n = 3 + br.read_bits(3) as usize;
+                        buffer[index] = 20 + br.read_bits(3) as u8;
+                        index += 1;
+                        br.drop_bits(3);
+                        (n, 0)
+                    }
+                    18 => {
+                        if !br.cache_bits(7) {
+                            return Err(Error::Corrupt("eof reading repeat".into()));
+                        }
+                        let n = 11 + br.read_bits(7) as usize;
+                        buffer[index] = 28 + br.read_bits(7) as u8;
+                        index += 1;
+                        br.drop_bits(7);
+                        (n, 0)
+                    }
+                    _ => return Err(Error::Corrupt("invalid code-length code".into())),
+                };
+                if copy_num > num_codes - idx {
+                    return Err(Error::Corrupt("code-length repeat exceeds array".into()));
+                }
+                idx += copy_num;
+                for _ in 0..copy_num {
+                    lens.push(copy_val);
+                }
+            }
+        }
+        if lens.len() != num_codes {
+            return Err(Error::Corrupt("code length count mismatch".into()));
+        }
+        self.tmp_lens = lens;
+        Ok(index)
+    }
+
+    /// Write a dynamic Huffman block header into the deflate stream `bw` from
+    /// its puff encoding in `buffer`.
+    pub fn build_dynamic_from_puff(&mut self, buffer: &[u8], bw: &mut BitWriter) -> Result<()> {
+        if buffer.len() < 3 {
+            return Err(Error::Corrupt("metadata buffer too small".into()));
+        }
+        let mut index = 0usize;
+        let num_lit_len = buffer[index] as usize + 257;
+        bw.write_bits(5, buffer[index] as u32)?;
+        index += 1;
+
+        let num_distance = buffer[index] as usize + 1;
+        bw.write_bits(5, buffer[index] as u32)?;
+        index += 1;
+
+        let num_codes = buffer[index] as usize + 4;
+        bw.write_bits(4, buffer[index] as u32)?;
+        index += 1;
+
+        Self::check_array_lengths(num_lit_len, num_distance, num_codes)?;
+
+        if buffer.len() - index < num_codes.div_ceil(2) {
+            return Err(Error::Corrupt("metadata truncated".into()));
+        }
+        let mut checked = false;
+        let mut idx = 0usize;
+        while idx < num_codes {
+            let len = if checked {
+                let v = buffer[index] & 0x0F;
+                index += 1;
+                v
+            } else {
+                buffer[index] >> 4
+            };
+            checked = !checked;
+            self.code_lens[PERMUTATIONS[idx] as usize] = len;
+            bw.write_bits(3, len as u32)?;
+            idx += 1;
+        }
+        if checked {
+            index += 1;
+        }
+        while idx < 19 {
+            self.code_lens[PERMUTATIONS[idx] as usize] = 0;
+            idx += 1;
+        }
+
+        let _ = Self::init_huffman_codes(&self.code_lens, &mut self.pairs)?;
+        let mut pairs = std::mem::take(&mut self.pairs);
+        Self::build_huffman_reverse_codes(&self.code_lens, &mut pairs, &mut self.code_rcodes)?;
+        self.pairs = pairs;
+
+        let read =
+            self.write_code_lengths_to_deflate(&buffer[index..], bw, num_lit_len + num_distance)?;
+        index += read;
+
+        let tmp = std::mem::take(&mut self.tmp_lens);
+        replace_bytes(&mut self.lit_len_lens, &tmp[..num_lit_len], "dynamic literal lengths")?;
+        replace_bytes(&mut self.distance_lens, &tmp[num_lit_len..], "dynamic distance lengths")?;
+        self.tmp_lens = tmp;
+
+        let _ = Self::init_huffman_codes(&self.lit_len_lens, &mut self.pairs)?;
+        let mut pairs = std::mem::take(&mut self.pairs);
+        Self::build_huffman_reverse_codes(
+            &self.lit_len_lens,
+            &mut pairs,
+            &mut self.lit_len_rcodes,
+        )?;
+        self.pairs = pairs;
+        // lit_len_max_bits is unused when encoding, but keep it consistent.
+        self.lit_len_max_bits = Self::init_huffman_codes(&self.lit_len_lens, &mut self.pairs)?;
+        self.pairs.clear();
+
+        let _ = Self::init_huffman_codes(&self.distance_lens, &mut self.pairs)?;
+        let mut pairs = std::mem::take(&mut self.pairs);
+        Self::build_huffman_reverse_codes(
+            &self.distance_lens,
+            &mut pairs,
+            &mut self.distance_rcodes,
+        )?;
+        self.pairs = pairs;
+
+        if index != buffer.len() {
+            return Err(Error::Corrupt("metadata length mismatch".into()));
+        }
+        Ok(())
+    }
+
+    fn write_code_lengths_to_deflate(
+        &mut self,
+        buffer: &[u8],
+        bw: &mut BitWriter,
+        num_codes: usize,
+    ) -> Result<usize> {
+        let mut lens = Vec::new();
+        lens.try_reserve_exact(num_codes)
+            .map_err(|error| Error::Allocation(format!("dynamic code lengths: {error}")))?;
+        let mut index = 0usize;
+        let mut idx = 0usize;
+        while idx < num_codes {
+            if index >= buffer.len() {
+                return Err(Error::Corrupt("code length buffer underflow".into()));
+            }
+            let pcode = buffer[index];
+            index += 1;
+            if pcode > 155 {
+                return Err(Error::Corrupt("invalid puffed code length".into()));
+            }
+            let code: u16 = if pcode < 16 {
+                pcode as u16
+            } else if pcode < 20 {
+                16
+            } else if pcode < 28 {
+                17
+            } else {
+                18
+            };
+            let (hcode, nbits) = self.code_huffman(code)?;
+            bw.write_bits(nbits, hcode as u32)?;
+            if code < 16 {
+                lens.push(code as u8);
+                idx += 1;
+            } else {
+                let (copy_num, copy_val) = match code {
+                    16 => {
+                        if idx == 0 {
+                            return Err(Error::Corrupt("repeat with no previous length".into()));
+                        }
+                        bw.write_bits(2, (pcode - 16) as u32)?;
+                        (3 + (pcode - 16) as usize, lens[idx - 1])
+                    }
+                    17 => {
+                        bw.write_bits(3, (pcode - 20) as u32)?;
+                        (3 + (pcode - 20) as usize, 0)
+                    }
+                    18 => {
+                        bw.write_bits(7, (pcode - 28) as u32)?;
+                        (11 + (pcode - 28) as usize, 0)
+                    }
+                    _ => return Err(Error::Corrupt("invalid code-length code".into())),
+                };
+                if copy_num > num_codes - idx {
+                    return Err(Error::Corrupt("code-length repeat exceeds array".into()));
+                }
+                idx += copy_num;
+                for _ in 0..copy_num {
+                    lens.push(copy_val);
+                }
+            }
+        }
+        if lens.len() != num_codes {
+            return Err(Error::Corrupt("code length count mismatch".into()));
+        }
+        self.tmp_lens = lens;
+        Ok(index)
+    }
+}
diff --git a/src/puffin/mod.rs b/src/puffin/mod.rs
new file mode 100644
index 0000000..512460e
--- /dev/null
+++ b/src/puffin/mod.rs
@@ -0,0 +1,104 @@
+// Copyright 2017 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Adapted from puffdiff 0.1.0, a pure-Rust port of ChromiumOS Puffin.
+
+mod bit_io;
+mod huffer;
+mod huffman;
+mod patch;
+mod puff_io;
+mod puffer;
+mod stream;
+
+use std::error;
+use std::fmt;
+
+use crate::ExtractionCancelled;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct BitExtent {
+    offset: usize,
+    length: usize,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct ByteExtent {
+    offset: usize,
+    length: usize,
+}
+
+#[derive(Debug)]
+pub(crate) enum Error {
+    BadPatchHeader(String),
+    BadProto(String),
+    UnsupportedPatchType(i32),
+    InvalidMetadata(String),
+    Corrupt(String),
+    Bsdiff(String),
+    SizeMismatch { expected: usize, actual: usize },
+    Allocation(String),
+    Cancelled(ExtractionCancelled),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::BadPatchHeader(message) => {
+                write!(formatter, "invalid PUFFDIFF header: {message}")
+            }
+            Self::BadProto(message) => {
+                write!(formatter, "invalid PUFFDIFF protobuf: {message}")
+            }
+            Self::UnsupportedPatchType(patch_type) => {
+                write!(formatter, "unsupported PUFFDIFF patch type {patch_type}")
+            }
+            Self::InvalidMetadata(message) => {
+                write!(formatter, "invalid PUFFDIFF metadata: {message}")
+            }
+            Self::Corrupt(message) => write!(formatter, "corrupt Puffin stream: {message}"),
+            Self::Bsdiff(message) => write!(formatter, "inner BSDIFF patch is invalid: {message}"),
+            Self::SizeMismatch { expected, actual } => {
+                write!(formatter, "PUFFDIFF size mismatch: expected {expected}, got {actual}")
+            }
+            Self::Allocation(message) => write!(formatter, "unable to allocate {message}"),
+            Self::Cancelled(error) => error.fmt(formatter),
+        }
+    }
+}
+
+impl error::Error for Error {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match self {
+            Self::Cancelled(error) => Some(error),
+            _ => None,
+        }
+    }
+}
+
+type Result<T> = std::result::Result<T, Error>;
+
+fn check_cancelled(token: &crate::CancellationToken) -> Result<()> {
+    if token.is_cancelled() {
+        return Err(Error::Cancelled(ExtractionCancelled));
+    }
+    Ok(())
+}
+
+pub(crate) fn apply(
+    source: &[u8],
+    patch: &[u8],
+    destination_size: usize,
+    cancellation_token: &crate::CancellationToken,
+) -> Result<Vec<u8>> {
+    patch::apply(source, patch, destination_size, cancellation_token)
+}
+
+pub(crate) fn validate_bsdiff_resources(
+    patch: &[u8],
+    output_size: usize,
+    cancellation_token: &crate::CancellationToken,
+) -> Result<()> {
+    patch::validate_bsdiff_resources(patch, output_size, cancellation_token)
+}
diff --git a/src/puffin/patch.rs b/src/puffin/patch.rs
new file mode 100644
index 0000000..ac9389f
--- /dev/null
+++ b/src/puffin/patch.rs
@@ -0,0 +1,523 @@
+// Copyright 2017 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Adapted from puffdiff 0.1.0 and ChromiumOS Puffin's puffpatch.cc.
+
+use std::io::Read;
+
+use brotli::Decompressor as BrotliDecoder;
+use bzip2::read::BzDecoder;
+
+use crate::puffin::{BitExtent, ByteExtent, Error, Result, check_cancelled, stream};
+use crate::{CancellationToken, validate_bsdiff_output_len, zucchini};
+
+const MAGIC: &[u8; 4] = b"PUF1";
+const PATCH_TYPE_BSDIFF: i32 = 0;
+const DECODE_CHUNK_SIZE: usize = 32 * 1024;
+
+#[derive(Clone, Copy)]
+enum Compression {
+    None,
+    Bzip2,
+    Brotli,
+}
+
+struct StreamInfo {
+    deflates: Vec<BitExtent>,
+    puffs: Vec<ByteExtent>,
+    puff_length: usize,
+}
+
+impl StreamInfo {
+    fn empty() -> Self {
+        Self { deflates: Vec::new(), puffs: Vec::new(), puff_length: 0 }
+    }
+}
+
+struct Cursor<'a> {
+    bytes: &'a [u8],
+    position: usize,
+}
+
+impl<'a> Cursor<'a> {
+    fn new(bytes: &'a [u8]) -> Self {
+        Self { bytes, position: 0 }
+    }
+
+    fn at_end(&self) -> bool {
+        self.position == self.bytes.len()
+    }
+
+    fn varint(&mut self) -> Result<u64> {
+        let mut value = 0u64;
+        for index in 0..10 {
+            let byte = *self
+                .bytes
+                .get(self.position)
+                .ok_or_else(|| Error::BadProto("truncated protobuf varint".into()))?;
+            self.position += 1;
+            if index == 9 && byte > 1 {
+                return Err(Error::BadProto("protobuf varint overflows u64".into()));
+            }
+            value |= u64::from(byte & 0x7f) << (index * 7);
+            if byte & 0x80 == 0 {
+                return Ok(value);
+            }
+        }
+        Err(Error::BadProto("protobuf varint is too long".into()))
+    }
+
+    fn length_delimited(&mut self) -> Result<&'a [u8]> {
+        let length = usize::try_from(self.varint()?)
+            .map_err(|_| Error::BadProto("protobuf field length is too large".into()))?;
+        let end = self
+            .position
+            .checked_add(length)
+            .ok_or_else(|| Error::BadProto("protobuf field range overflows".into()))?;
+        let field = self.bytes.get(self.position..end).ok_or_else(|| {
+            Error::BadProto("length-delimited protobuf field overruns header".into())
+        })?;
+        self.position = end;
+        Ok(field)
+    }
+
+    fn skip(&mut self, wire_type: u8) -> Result<()> {
+        match wire_type {
+            0 => {
+                self.varint()?;
+            }
+            1 => self.advance(8)?,
+            2 => {
+                self.length_delimited()?;
+            }
+            5 => self.advance(4)?,
+            _ => {
+                return Err(Error::BadProto(format!("unsupported protobuf wire type {wire_type}")));
+            }
+        }
+        Ok(())
+    }
+
+    fn advance(&mut self, count: usize) -> Result<()> {
+        let end = self
+            .position
+            .checked_add(count)
+            .ok_or_else(|| Error::BadProto("protobuf field range overflows".into()))?;
+        if end > self.bytes.len() {
+            return Err(Error::BadProto("protobuf field overruns header".into()));
+        }
+        self.position = end;
+        Ok(())
+    }
+
+    fn key(&mut self) -> Result<(u64, u8)> {
+        let key = self.varint()?;
+        let field = key >> 3;
+        if field == 0 {
+            return Err(Error::BadProto("protobuf field number is zero".into()));
+        }
+        Ok((field, (key & 7) as u8))
+    }
+}
+
+fn parse_bit_extent(bytes: &[u8]) -> Result<(u64, u64)> {
+    let mut cursor = Cursor::new(bytes);
+    let mut offset = 0u64;
+    let mut length = 0u64;
+    while !cursor.at_end() {
+        let (field, wire_type) = cursor.key()?;
+        match (field, wire_type) {
+            (1, 0) => offset = cursor.varint()?,
+            (2, 0) => length = cursor.varint()?,
+            _ => cursor.skip(wire_type)?,
+        }
+    }
+    Ok((offset, length))
+}
+
+fn push_extent<T>(extents: &mut Vec<T>, extent: T) -> Result<()> {
+    extents
+        .try_reserve(1)
+        .map_err(|error| Error::Allocation(format!("PUFFDIFF extent metadata: {error}")))?;
+    extents.push(extent);
+    Ok(())
+}
+
+fn parse_stream_info(bytes: &[u8]) -> Result<StreamInfo> {
+    let mut info = StreamInfo::empty();
+    let mut cursor = Cursor::new(bytes);
+    while !cursor.at_end() {
+        let (field, wire_type) = cursor.key()?;
+        match (field, wire_type) {
+            (1, 2) => {
+                let (offset, length) = parse_bit_extent(cursor.length_delimited()?)?;
+                push_extent(
+                    &mut info.deflates,
+                    BitExtent {
+                        offset: usize::try_from(offset).map_err(|_| {
+                            Error::InvalidMetadata("deflate offset is too large".into())
+                        })?,
+                        length: usize::try_from(length).map_err(|_| {
+                            Error::InvalidMetadata("deflate length is too large".into())
+                        })?,
+                    },
+                )?;
+            }
+            (2, 2) => {
+                let (offset, length) = parse_bit_extent(cursor.length_delimited()?)?;
+                if offset % 8 != 0 || length % 8 != 0 {
+                    return Err(Error::InvalidMetadata("puff extent is not byte-aligned".into()));
+                }
+                push_extent(
+                    &mut info.puffs,
+                    ByteExtent {
+                        offset: usize::try_from(offset / 8).map_err(|_| {
+                            Error::InvalidMetadata("puff offset is too large".into())
+                        })?,
+                        length: usize::try_from(length / 8).map_err(|_| {
+                            Error::InvalidMetadata("puff length is too large".into())
+                        })?,
+                    },
+                )?;
+            }
+            (3, 0) => {
+                info.puff_length = usize::try_from(cursor.varint()?).map_err(|_| {
+                    Error::InvalidMetadata("puff stream length is too large".into())
+                })?;
+            }
+            _ => cursor.skip(wire_type)?,
+        }
+    }
+    Ok(info)
+}
+
+struct PatchHeader {
+    source: StreamInfo,
+    destination: StreamInfo,
+    patch_type: i32,
+}
+
+fn parse_header(bytes: &[u8]) -> Result<PatchHeader> {
+    let mut source = StreamInfo::empty();
+    let mut destination = StreamInfo::empty();
+    let mut patch_type = PATCH_TYPE_BSDIFF;
+    let mut cursor = Cursor::new(bytes);
+    while !cursor.at_end() {
+        let (field, wire_type) = cursor.key()?;
+        match (field, wire_type) {
+            (1, 0) => {
+                cursor.varint()?;
+            }
+            (2, 2) => source = parse_stream_info(cursor.length_delimited()?)?,
+            (3, 2) => destination = parse_stream_info(cursor.length_delimited()?)?,
+            (4, 0) => patch_type = cursor.varint()? as u32 as i32,
+            _ => cursor.skip(wire_type)?,
+        }
+    }
+    Ok(PatchHeader { source, destination, patch_type })
+}
+
+fn validate_extents<T>(
+    extents: &[T],
+    label: &str,
+    limit: usize,
+    parts: impl Fn(&T) -> (usize, usize),
+) -> Result<()> {
+    let mut previous_end = 0usize;
+    for (index, extent) in extents.iter().enumerate() {
+        let (offset, length) = parts(extent);
+        if length == 0 {
+            return Err(Error::InvalidMetadata(format!("{label} extent {index} is empty")));
+        }
+        let end = offset
+            .checked_add(length)
+            .ok_or_else(|| Error::InvalidMetadata(format!("{label} extent {index} overflows")))?;
+        if index != 0 && offset < previous_end {
+            return Err(Error::InvalidMetadata(format!("{label} extents overlap or are unsorted")));
+        }
+        if end > limit {
+            return Err(Error::InvalidMetadata(format!(
+                "{label} extent {index} exceeds its stream"
+            )));
+        }
+        previous_end = end;
+    }
+    Ok(())
+}
+
+fn validate_stream(info: &StreamInfo, raw_size: usize, label: &str) -> Result<()> {
+    if info.puff_length >= zucchini::OFFSET_BOUND {
+        return Err(Error::InvalidMetadata(format!(
+            "{label} puff length exceeds the maximum of {} bytes",
+            zucchini::OFFSET_BOUND - 1
+        )));
+    }
+    if info.deflates.len() != info.puffs.len() {
+        return Err(Error::InvalidMetadata(format!(
+            "{label} deflate and puff extent counts differ"
+        )));
+    }
+    validate_extents(&info.deflates, "deflate", usize::MAX, |extent| {
+        (extent.offset, extent.length)
+    })?;
+    validate_extents(&info.puffs, "puff", info.puff_length, |extent| {
+        (extent.offset, extent.length)
+    })?;
+
+    let computed_raw_size =
+        match (info.deflates.last(), info.puffs.last()) {
+            (Some(deflate), Some(puff)) => {
+                let deflate_end = deflate
+                    .offset
+                    .checked_add(deflate.length)
+                    .ok_or_else(|| Error::InvalidMetadata("deflate end overflows".into()))?;
+                let puff_end = puff
+                    .offset
+                    .checked_add(puff.length)
+                    .ok_or_else(|| Error::InvalidMetadata("puff end overflows".into()))?;
+                (deflate_end / 8)
+                    .checked_add(info.puff_length.checked_sub(puff_end).ok_or_else(|| {
+                        Error::InvalidMetadata("puff extent exceeds stream".into())
+                    })?)
+                    .ok_or_else(|| Error::InvalidMetadata(format!("{label} raw size overflows")))?
+            }
+            (None, None) => info.puff_length,
+            _ => {
+                return Err(Error::InvalidMetadata(format!(
+                    "{label} deflate and puff extent counts differ"
+                )));
+            }
+        };
+    if computed_raw_size != raw_size {
+        return Err(Error::InvalidMetadata(format!(
+            "{label} raw size mismatch: metadata describes {computed_raw_size} bytes, operation provides {raw_size}"
+        )));
+    }
+    let raw_bits = raw_size
+        .checked_mul(8)
+        .ok_or_else(|| Error::InvalidMetadata(format!("{label} raw bit length overflows")))?;
+    for (index, extent) in info.deflates.iter().enumerate() {
+        let end = extent
+            .offset
+            .checked_add(extent.length)
+            .ok_or_else(|| Error::InvalidMetadata("deflate extent end overflows".into()))?;
+        if end > raw_bits {
+            return Err(Error::InvalidMetadata(format!(
+                "deflate extent {index} exceeds its stream"
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn sign_magnitude_usize(bytes: &[u8], label: &str) -> Result<usize> {
+    let encoded = u64::from_le_bytes(
+        bytes
+            .get(..8)
+            .ok_or_else(|| Error::Bsdiff(format!("truncated {label}")))?
+            .try_into()
+            .map_err(|_| Error::Bsdiff(format!("invalid {label}")))?,
+    );
+    if encoded & (1 << 63) != 0 {
+        return Err(Error::Bsdiff(format!("negative {label}")));
+    }
+    usize::try_from(encoded).map_err(|_| Error::Bsdiff(format!("{label} is too large")))
+}
+
+fn compression(value: u8, label: &str) -> Result<Compression> {
+    match value {
+        0 => Ok(Compression::None),
+        1 => Ok(Compression::Bzip2),
+        2 => Ok(Compression::Brotli),
+        _ => Err(Error::Bsdiff(format!("unsupported {label} compression algorithm {value}"))),
+    }
+}
+
+fn check_decoded_bound(
+    mut reader: impl Read,
+    maximum: usize,
+    label: &str,
+    cancellation_token: &CancellationToken,
+) -> Result<()> {
+    let mut decoded = 0usize;
+    let mut buffer = [0u8; DECODE_CHUNK_SIZE];
+    loop {
+        check_cancelled(cancellation_token)?;
+        let remaining = maximum
+            .checked_sub(decoded)
+            .ok_or_else(|| Error::Bsdiff(format!("decoded {label} stream exceeds its bound")))?;
+        let read_size = buffer.len().min(remaining.saturating_add(1));
+        let count = reader
+            .read(&mut buffer[..read_size])
+            .map_err(|error| Error::Bsdiff(format!("unable to decode {label} stream: {error}")))?;
+        if count == 0 {
+            return Ok(());
+        }
+        if count > remaining {
+            return Err(Error::Bsdiff(format!(
+                "decoded {label} stream exceeds its bound of {maximum} bytes"
+            )));
+        }
+        decoded = decoded
+            .checked_add(count)
+            .ok_or_else(|| Error::Bsdiff(format!("decoded {label} length overflows")))?;
+    }
+}
+
+fn validate_compressed_stream(
+    algorithm: Compression,
+    bytes: &[u8],
+    maximum: usize,
+    label: &str,
+    cancellation_token: &CancellationToken,
+) -> Result<()> {
+    match algorithm {
+        Compression::None => {
+            if bytes.len() > maximum {
+                return Err(Error::Bsdiff(format!(
+                    "uncompressed {label} stream exceeds its bound of {maximum} bytes"
+                )));
+            }
+            Ok(())
+        }
+        Compression::Bzip2 => {
+            check_decoded_bound(BzDecoder::new(bytes), maximum, label, cancellation_token)
+        }
+        Compression::Brotli => check_decoded_bound(
+            BrotliDecoder::new(bytes, DECODE_CHUNK_SIZE),
+            maximum,
+            label,
+            cancellation_token,
+        ),
+    }
+}
+
+fn validate_inner_bsdiff_resources(
+    patch: &[u8],
+    output_size: usize,
+    cancellation_token: &CancellationToken,
+) -> Result<()> {
+    let header = patch
+        .get(..32)
+        .ok_or_else(|| Error::Bsdiff("patch data is shorter than 32 bytes".into()))?;
+    let algorithms = if &header[..8] == b"BSDIFF40" {
+        [Compression::Bzip2; 3]
+    } else if &header[..5] == b"BSDF2" {
+        [
+            compression(header[5], "control")?,
+            compression(header[6], "diff")?,
+            compression(header[7], "extra")?,
+        ]
+    } else {
+        return Err(Error::Bsdiff("invalid BSDIFF/BSDF2 magic header".into()));
+    };
+    let control_length = sign_magnitude_usize(&header[8..16], "control stream length")?;
+    let diff_length = sign_magnitude_usize(&header[16..24], "diff stream length")?;
+    let control_end = 32usize
+        .checked_add(control_length)
+        .ok_or_else(|| Error::Bsdiff("control stream range overflows".into()))?;
+    let diff_end = control_end
+        .checked_add(diff_length)
+        .ok_or_else(|| Error::Bsdiff("diff stream range overflows".into()))?;
+    let control = patch
+        .get(32..control_end)
+        .ok_or_else(|| Error::Bsdiff("control stream exceeds patch".into()))?;
+    let diff = patch
+        .get(control_end..diff_end)
+        .ok_or_else(|| Error::Bsdiff("diff stream exceeds patch".into()))?;
+    let extra = patch
+        .get(diff_end..)
+        .ok_or_else(|| Error::Bsdiff("extra stream offset exceeds patch".into()))?;
+    let control_bound =
+        output_size.saturating_mul(48).saturating_add(4096).min(zucchini::OFFSET_BOUND - 1);
+    validate_compressed_stream(
+        algorithms[0],
+        control,
+        control_bound,
+        "control",
+        cancellation_token,
+    )?;
+    validate_compressed_stream(algorithms[1], diff, output_size, "diff", cancellation_token)?;
+    validate_compressed_stream(algorithms[2], extra, output_size, "extra", cancellation_token)?;
+    Ok(())
+}
+
+pub(crate) fn validate_bsdiff_resources(
+    patch: &[u8],
+    output_size: usize,
+    cancellation_token: &CancellationToken,
+) -> Result<()> {
+    validate_inner_bsdiff_resources(patch, output_size, cancellation_token)
+}
+
+pub fn apply(
+    source: &[u8],
+    patch: &[u8],
+    destination_size: usize,
+    cancellation_token: &CancellationToken,
+) -> Result<Vec<u8>> {
+    check_cancelled(cancellation_token)?;
+    let prefix = patch
+        .get(..8)
+        .ok_or_else(|| Error::BadPatchHeader("patch is shorter than eight bytes".into()))?;
+    if &prefix[..4] != MAGIC {
+        return Err(Error::BadPatchHeader("missing PUF1 magic".into()));
+    }
+    let header_size =
+        usize::try_from(u32::from_be_bytes([prefix[4], prefix[5], prefix[6], prefix[7]]))
+            .map_err(|_| Error::BadPatchHeader("protobuf header is too large".into()))?;
+    let header_end = 8usize
+        .checked_add(header_size)
+        .ok_or_else(|| Error::BadPatchHeader("protobuf header range overflows".into()))?;
+    let header_bytes = patch
+        .get(8..header_end)
+        .ok_or_else(|| Error::BadPatchHeader("protobuf header overruns patch".into()))?;
+    let header = parse_header(header_bytes)?;
+    if header.patch_type != PATCH_TYPE_BSDIFF {
+        return Err(Error::UnsupportedPatchType(header.patch_type));
+    }
+    validate_stream(&header.source, source.len(), "source")?;
+    validate_stream(&header.destination, destination_size, "destination")?;
+    let raw_patch = patch
+        .get(header_end..)
+        .ok_or_else(|| Error::BadPatchHeader("inner patch offset is invalid".into()))?;
+
+    check_cancelled(cancellation_token)?;
+    let puffed_source = stream::puff(
+        source,
+        &header.source.deflates,
+        &header.source.puffs,
+        header.source.puff_length,
+        cancellation_token,
+    )?;
+
+    check_cancelled(cancellation_token)?;
+    validate_bsdiff_output_len(raw_patch, header.destination.puff_length)
+        .map_err(|error| Error::Bsdiff(error.to_string()))?;
+    validate_inner_bsdiff_resources(raw_patch, header.destination.puff_length, cancellation_token)?;
+    let mut puffed_destination = Vec::new();
+    puffed_destination
+        .try_reserve_exact(header.destination.puff_length)
+        .map_err(|error| Error::Allocation(format!("puffed destination: {error}")))?;
+    bsdiff_android::patch_bsdf2(&puffed_source, raw_patch, &mut puffed_destination)
+        .map_err(|error| Error::Bsdiff(error.to_string()))?;
+    if puffed_destination.len() != header.destination.puff_length {
+        return Err(Error::SizeMismatch {
+            expected: header.destination.puff_length,
+            actual: puffed_destination.len(),
+        });
+    }
+
+    check_cancelled(cancellation_token)?;
+    let destination = stream::huff(
+        &puffed_destination,
+        &header.destination.deflates,
+        &header.destination.puffs,
+        header.destination.puff_length,
+        destination_size,
+        cancellation_token,
+    )?;
+    check_cancelled(cancellation_token)?;
+    Ok(destination)
+}
diff --git a/src/puffin/puff_io.rs b/src/puffin/puff_io.rs
new file mode 100644
index 0000000..f1138c4
--- /dev/null
+++ b/src/puffin/puff_io.rs
@@ -0,0 +1,337 @@
+// Copyright 2017 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Adapted from puffdiff 0.1.0, a pure-Rust port of ChromiumOS Puffin.
+
+//! The "puff" intermediate serialization, ported from puffin `puff_data.h`,
+//! `puff_writer.cc` and `puff_reader.cc`.
+//!
+//! The byte layout produced here must match puffin exactly, because the bsdiff
+//! patch inside a PUFFDIFF op is computed against puffin's puffed bytes.
+
+use crate::puffin::{Error, Result};
+
+/// Maximum bytes a block-metadata blob can occupy: 1 header + 3 lengths +
+/// 286 lit/len code lengths + 30 distance + 19 code-length codes.
+pub const BLOCK_METADATA_MAX: usize = 1 + 3 + 286 + 30 + 19;
+
+const LITERALS_HEADER: u8 = 0x00;
+const LEN_DIST_HEADER: u8 = 0x80;
+const LITERALS_MAX_LENGTH: usize = (1 << 16) + 127; // 65663
+
+/// One decoded token exchanged between puffer/huffer and the puff buffer.
+pub enum PuffData<'a> {
+    Literal(u8),
+    Literals(&'a [u8]),
+    LenDist { length: usize, distance: usize },
+    BlockMetadata(&'a [u8]),
+    EndOfBlock,
+}
+
+#[inline]
+fn write_u16_be(buf: &mut [u8], value: u16) -> Result<()> {
+    let target =
+        buf.get_mut(..2).ok_or_else(|| Error::Corrupt("puff writer u16 overflow".into()))?;
+    target.copy_from_slice(&value.to_be_bytes());
+    Ok(())
+}
+
+#[inline]
+fn read_u16_be(buf: &[u8]) -> Result<u16> {
+    let bytes: [u8; 2] = buf
+        .get(..2)
+        .ok_or_else(|| Error::Corrupt("puff reader u16 overflow".into()))?
+        .try_into()
+        .map_err(|_| Error::Corrupt("puff reader u16 conversion failed".into()))?;
+    Ok(u16::from_be_bytes(bytes))
+}
+
+#[derive(PartialEq)]
+enum WState {
+    None,
+    Small,
+    Large,
+}
+
+/// Serializes `PuffData` tokens into the puff byte format.
+pub struct PuffWriter<'a> {
+    out: &'a mut [u8],
+    index: usize,
+    state: WState,
+    len_index: usize,
+    cur_literals_length: usize,
+}
+
+impl<'a> PuffWriter<'a> {
+    pub fn new(out: &'a mut [u8]) -> Self {
+        PuffWriter { out, index: 0, state: WState::None, len_index: 0, cur_literals_length: 0 }
+    }
+
+    fn insert_literal_bytes(&mut self, is_single: bool, byte: u8, bytes: &[u8]) -> Result<()> {
+        let length = if is_single { 1 } else { bytes.len() };
+        if !is_single && length == 0 {
+            return Ok(());
+        }
+        if self.state == WState::None {
+            self.need(1)?;
+            self.len_index = self.index;
+            self.index += 1;
+            self.state = WState::Small;
+        }
+        let combined_length = self
+            .cur_literals_length
+            .checked_add(length)
+            .ok_or_else(|| Error::Corrupt("puff literal length overflows".into()))?;
+        if combined_length > LITERALS_MAX_LENGTH {
+            return Err(Error::Corrupt("puff literal run is too long".into()));
+        }
+        if self.state == WState::Small && combined_length > 127 {
+            // Open two bytes of space for a large-literal length prefix by
+            // shifting the already-written literals forward.
+            self.need(2)?;
+            let literal_start = self
+                .len_index
+                .checked_add(1)
+                .ok_or_else(|| Error::Corrupt("puff literal offset overflows".into()))?;
+            let literal_end = literal_start
+                .checked_add(self.cur_literals_length)
+                .ok_or_else(|| Error::Corrupt("puff literal range overflows".into()))?;
+            let destination = self
+                .len_index
+                .checked_add(3)
+                .ok_or_else(|| Error::Corrupt("puff literal shift overflows".into()))?;
+            self.out.copy_within(literal_start..literal_end, destination);
+            self.index += 2;
+            self.state = WState::Large;
+        }
+
+        self.need(length)?;
+        let end = self
+            .index
+            .checked_add(length)
+            .ok_or_else(|| Error::Corrupt("puff writer literal range overflows".into()))?;
+        if is_single {
+            self.out[self.index] = byte;
+        } else {
+            self.out[self.index..end].copy_from_slice(bytes);
+        }
+        self.index = end;
+        self.cur_literals_length = combined_length;
+
+        if self.cur_literals_length == LITERALS_MAX_LENGTH {
+            self.flush_literals()?;
+        }
+        Ok(())
+    }
+
+    pub fn insert(&mut self, pd: &PuffData) -> Result<()> {
+        match pd {
+            PuffData::Literal(b) => self.insert_literal_bytes(true, *b, &[]),
+            PuffData::Literals(bytes) => self.insert_literal_bytes(false, 0, bytes),
+            PuffData::LenDist { length, distance } => {
+                self.flush_literals()?;
+                let (length, distance) = (*length, *distance);
+                if !(3..=258).contains(&length) || !(1..=32768).contains(&distance) {
+                    return Err(Error::Corrupt("len/dist out of range".into()));
+                }
+                if length < 130 {
+                    self.need(3)?;
+                    self.out[self.index] = LEN_DIST_HEADER | (length - 3) as u8;
+                    self.index += 1;
+                } else {
+                    self.need(4)?;
+                    self.out[self.index] = LEN_DIST_HEADER | 127;
+                    self.index += 1;
+                    self.out[self.index] = (length - 3 - 127) as u8;
+                    self.index += 1;
+                }
+                write_u16_be(&mut self.out[self.index..], (distance - 1) as u16)?;
+                self.index += 2;
+                self.len_index = self.index;
+                self.state = WState::None;
+                Ok(())
+            }
+            PuffData::BlockMetadata(meta) => {
+                self.flush_literals()?;
+                let length = meta.len();
+                if length == 0 || length > BLOCK_METADATA_MAX {
+                    return Err(Error::Corrupt("block metadata length invalid".into()));
+                }
+                self.need(length.checked_add(2).ok_or_else(|| {
+                    Error::Corrupt("block metadata output length overflows".into())
+                })?)?;
+                write_u16_be(&mut self.out[self.index..], (length - 1) as u16)?;
+                self.index += 2;
+                self.out[self.index..self.index + length].copy_from_slice(meta);
+                self.index += length;
+                self.len_index = self.index;
+                self.state = WState::None;
+                Ok(())
+            }
+            PuffData::EndOfBlock => {
+                self.flush_literals()?;
+                self.need(2)?;
+                self.out[self.index] = LEN_DIST_HEADER | 127;
+                self.index += 1;
+                self.out[self.index] = (259 - 3 - 127) as u8;
+                self.index += 1;
+                self.len_index = self.index;
+                self.state = WState::None;
+                Ok(())
+            }
+        }
+    }
+
+    fn need(&self, count: usize) -> Result<()> {
+        let end = self
+            .index
+            .checked_add(count)
+            .ok_or_else(|| Error::Corrupt("puff writer range overflows".into()))?;
+        if end > self.out.len() {
+            return Err(Error::Corrupt("puff writer output overflow".into()));
+        }
+        Ok(())
+    }
+
+    fn flush_literals(&mut self) -> Result<()> {
+        if self.cur_literals_length == 0 {
+            return Ok(());
+        }
+        match self.state {
+            WState::Small => {
+                if self.cur_literals_length != self.index - self.len_index - 1 {
+                    return Err(Error::Corrupt("small literal length mismatch".into()));
+                }
+                self.out[self.len_index] = LITERALS_HEADER | (self.cur_literals_length - 1) as u8;
+                self.len_index = self.index;
+                self.state = WState::None;
+            }
+            WState::Large => {
+                if self.cur_literals_length != self.index - self.len_index - 3 {
+                    return Err(Error::Corrupt("large literal length mismatch".into()));
+                }
+                self.out[self.len_index] = LITERALS_HEADER | 127;
+                write_u16_be(
+                    &mut self.out[self.len_index + 1..],
+                    (self.cur_literals_length - 127 - 1) as u16,
+                )?;
+                self.len_index = self.index;
+                self.state = WState::None;
+            }
+            WState::None => {}
+        }
+        self.cur_literals_length = 0;
+        Ok(())
+    }
+
+    pub fn flush(&mut self) -> Result<()> {
+        self.flush_literals()
+    }
+
+    pub fn size(&self) -> usize {
+        self.index
+    }
+}
+
+enum RState {
+    ReadingLenDist,
+    ReadingBlockMetadata,
+}
+
+/// Deserializes puff bytes back into `PuffData` tokens.
+pub struct PuffReader<'a> {
+    buf: &'a [u8],
+    index: usize,
+    state: RState,
+}
+
+impl<'a> PuffReader<'a> {
+    pub fn new(buf: &'a [u8]) -> Self {
+        PuffReader { buf, index: 0, state: RState::ReadingBlockMetadata }
+    }
+
+    pub fn bytes_left(&self) -> usize {
+        self.buf.len() - self.index
+    }
+
+    fn need(&self, n: usize) -> Result<()> {
+        let end = self
+            .index
+            .checked_add(n)
+            .ok_or_else(|| Error::Corrupt("puff reader range overflows".into()))?;
+        if end > self.buf.len() {
+            return Err(Error::Corrupt("puff reader out of range".into()));
+        }
+        Ok(())
+    }
+
+    pub fn get_next(&mut self) -> Result<PuffData<'a>> {
+        match self.state {
+            RState::ReadingLenDist => {
+                self.need(1)?;
+                let header = self.buf[self.index];
+                if header & 0x80 != 0 {
+                    // length/distance (or end of block)
+                    let mut length;
+                    if (header & 0x7F) < 127 {
+                        length = (header & 0x7F) as usize;
+                    } else {
+                        self.index += 1;
+                        self.need(1)?;
+                        length = self.buf[self.index] as usize + 127;
+                    }
+                    length += 3;
+                    if length > 259 {
+                        return Err(Error::Corrupt("len/dist length too large".into()));
+                    }
+                    self.index += 1;
+
+                    if length == 259 {
+                        self.state = RState::ReadingBlockMetadata;
+                        return Ok(PuffData::EndOfBlock);
+                    }
+
+                    self.need(2)?;
+                    let distance = read_u16_be(&self.buf[self.index..])?;
+                    if distance >= (1 << 15) {
+                        return Err(Error::Corrupt("distance too large".into()));
+                    }
+                    let distance = distance as usize + 1;
+                    self.index += 2;
+                    Ok(PuffData::LenDist { length, distance })
+                } else {
+                    // literals
+                    let mut length;
+                    if (header & 0x7F) < 127 {
+                        length = (header & 0x7F) as usize;
+                        self.index += 1;
+                    } else {
+                        self.index += 1;
+                        self.need(2)?;
+                        length = usize::from(read_u16_be(&self.buf[self.index..])?) + 127;
+                        self.index += 2;
+                    }
+                    length += 1;
+                    self.need(length)?;
+                    let slice = &self.buf[self.index..self.index + length];
+                    self.index += length;
+                    Ok(PuffData::Literals(slice))
+                }
+            }
+            RState::ReadingBlockMetadata => {
+                self.need(2)?;
+                let length = usize::from(read_u16_be(&self.buf[self.index..])?) + 1;
+                self.index += 2;
+                self.need(length)?;
+                if length > BLOCK_METADATA_MAX {
+                    return Err(Error::Corrupt("block metadata too large".into()));
+                }
+                let slice = &self.buf[self.index..self.index + length];
+                self.index += length;
+                self.state = RState::ReadingLenDist;
+                Ok(PuffData::BlockMetadata(slice))
+            }
+        }
+    }
+}
diff --git a/src/puffin/puffer.rs b/src/puffin/puffer.rs
new file mode 100644
index 0000000..aba3c9e
--- /dev/null
+++ b/src/puffin/puffer.rs
@@ -0,0 +1,159 @@
+// Copyright 2017 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Adapted from puffdiff 0.1.0, a pure-Rust port of ChromiumOS Puffin.
+
+//! Deflate -> puff transform, ported from puffin `puffer.cc`.
+
+use crate::CancellationToken;
+use crate::puffin::bit_io::BitReader;
+use crate::puffin::huffman::{
+    BlockType, DISTANCE_BASES, DISTANCE_EXTRA_BITS, HuffmanTable, LENGTH_BASES, LENGTH_EXTRA_BITS,
+};
+use crate::puffin::puff_io::{BLOCK_METADATA_MAX, PuffData, PuffWriter};
+use crate::puffin::{Error, Result, check_cancelled};
+
+/// Puff every deflate block in `br` into `pw`, until the input is exhausted.
+pub fn puff_deflate(
+    br: &mut BitReader,
+    pw: &mut PuffWriter,
+    cancellation_token: &CancellationToken,
+) -> Result<()> {
+    puff_deflate_impl(br, pw, cancellation_token)
+}
+
+fn puff_deflate_impl(
+    br: &mut BitReader,
+    pw: &mut PuffWriter,
+    cancellation_token: &CancellationToken,
+) -> Result<()> {
+    let mut fixed_ht = HuffmanTable::new()?;
+    let mut dyn_ht = HuffmanTable::new()?;
+    let mut fixed_built = false;
+    // Minimum deflate block is 8 bits (3-bit header + a 5-bit fixed symbol).
+    while br.cache_bits(8) {
+        check_cancelled(cancellation_token)?;
+        if !br.cache_bits(3) {
+            return Err(Error::Corrupt("eof reading block header".into()));
+        }
+        let final_bit = br.read_bits(1) as u8;
+        br.drop_bits(1);
+        let btype = br.read_bits(2) as u8;
+        br.drop_bits(2);
+
+        let block_header = (final_bit << 7) | (btype << 5);
+
+        let use_dynamic = match BlockType::from_bits(btype)? {
+            BlockType::Uncompressed => {
+                let skipped_bits = br.read_boundary_bits();
+                br.skip_boundary_bits();
+                if !br.cache_bits(32) {
+                    return Err(Error::Corrupt("eof reading uncompressed lengths".into()));
+                }
+                let len = br.read_bits(16);
+                br.drop_bits(16);
+                let nlen = br.read_bits(16);
+                br.drop_bits(16);
+                if (len ^ nlen) != 0xFFFF {
+                    return Err(Error::Corrupt("bad uncompressed LEN/NLEN".into()));
+                }
+
+                let header = block_header | skipped_bits;
+                pw.insert(&PuffData::BlockMetadata(&[header]))?;
+
+                let raw = br.get_bytes(len as usize)?;
+                pw.insert(&PuffData::Literals(raw))?;
+                pw.insert(&PuffData::EndOfBlock)?;
+                continue;
+            }
+            BlockType::Fixed => {
+                if !fixed_built {
+                    fixed_ht.build_fixed()?;
+                    fixed_built = true;
+                }
+                pw.insert(&PuffData::BlockMetadata(&[block_header]))?;
+                false
+            }
+            BlockType::Dynamic => {
+                let mut meta = [0u8; BLOCK_METADATA_MAX];
+                meta[0] = block_header;
+                let written = dyn_ht.build_dynamic_from_deflate(br, &mut meta[1..])?;
+                pw.insert(&PuffData::BlockMetadata(&meta[..written + 1]))?;
+                true
+            }
+        };
+
+        loop {
+            check_cancelled(cancellation_token)?;
+            let cur_ht: &HuffmanTable = if use_dynamic { &dyn_ht } else { &fixed_ht };
+            let mut max_bits = cur_ht.lit_len_max_bits();
+            if !br.cache_bits(max_bits) {
+                max_bits = cur_ht.end_of_block_bit_length()?;
+            }
+            if !br.cache_bits(max_bits) {
+                return Err(Error::Corrupt("eof reading lit/len".into()));
+            }
+            let bits = br.read_bits(max_bits);
+            let (lit_len_alphabet, nbits) = cur_ht.lit_len_alphabet(bits)?;
+            if nbits > br.cached_bits() {
+                return Err(Error::Corrupt("truncated lit/len Huffman code".into()));
+            }
+            br.drop_bits(nbits);
+
+            if lit_len_alphabet < 256 {
+                pw.insert(&PuffData::Literal(lit_len_alphabet as u8))?;
+            } else if lit_len_alphabet == 256 {
+                pw.insert(&PuffData::EndOfBlock)?;
+                break;
+            } else {
+                if lit_len_alphabet > 285 {
+                    return Err(Error::Corrupt("lit/len alphabet > 285".into()));
+                }
+                let len_code_start = (lit_len_alphabet - 257) as usize;
+                let extra_len = LENGTH_EXTRA_BITS[len_code_start] as usize;
+                let mut extra_val = 0u32;
+                if extra_len != 0 {
+                    if !br.cache_bits(extra_len) {
+                        return Err(Error::Corrupt("eof reading length extra".into()));
+                    }
+                    extra_val = br.read_bits(extra_len);
+                    br.drop_bits(extra_len);
+                }
+                let length = LENGTH_BASES[len_code_start] as usize + extra_val as usize;
+
+                let mut bits_to_cache = cur_ht.distance_max_bits();
+                if !br.cache_bits(bits_to_cache) {
+                    // Rare legacy corner case (crbug.com/915559): not enough
+                    // bits for a full-width distance code near the stream end.
+                    bits_to_cache = br.bits_remaining() as usize;
+                    if !br.cache_bits(bits_to_cache) {
+                        return Err(Error::Corrupt("eof reading distance".into()));
+                    }
+                }
+                let dbits = br.read_bits(bits_to_cache);
+                let (distance_alphabet, nbits) = cur_ht.distance_alphabet(dbits)?;
+                if nbits > br.cached_bits() {
+                    return Err(Error::Corrupt("truncated distance Huffman code".into()));
+                }
+                br.drop_bits(nbits);
+
+                let extra_len = DISTANCE_EXTRA_BITS[distance_alphabet as usize] as usize;
+                let mut extra_val = 0u32;
+                if extra_len != 0 {
+                    if !br.cache_bits(extra_len) {
+                        return Err(Error::Corrupt("eof reading distance extra".into()));
+                    }
+                    extra_val = br.read_bits(extra_len);
+                    br.drop_bits(extra_len);
+                }
+                let distance =
+                    DISTANCE_BASES[distance_alphabet as usize] as usize + extra_val as usize;
+                pw.insert(&PuffData::LenDist { length, distance })?;
+            }
+        }
+    }
+    pw.flush()?;
+    check_cancelled(cancellation_token)?;
+    Ok(())
+}
diff --git a/src/puffin/stream.rs b/src/puffin/stream.rs
new file mode 100644
index 0000000..4626b8c
--- /dev/null
+++ b/src/puffin/stream.rs
@@ -0,0 +1,481 @@
+// Copyright 2017 The ChromiumOS Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Adapted from puffdiff 0.1.0 and ChromiumOS Puffin's puffin_stream.cc.
+
+use crate::CancellationToken;
+use crate::puffin::bit_io::{BitReader, BitWriter};
+use crate::puffin::huffer::huff_deflate;
+use crate::puffin::puff_io::{PuffReader, PuffWriter};
+use crate::puffin::puffer::puff_deflate;
+use crate::puffin::{BitExtent, ByteExtent, Error, Result, check_cancelled};
+
+#[derive(Clone, Copy)]
+struct Extent {
+    offset: usize,
+    length: usize,
+}
+
+struct Driver<'a> {
+    source: Option<&'a [u8]>,
+    output: Vec<u8>,
+    output_position: usize,
+    deflates: Vec<Extent>,
+    puffs: Vec<Extent>,
+    upper_bounds: Vec<usize>,
+    current: usize,
+    puff_position: usize,
+    skip_bytes: usize,
+    deflate_bit_position: usize,
+    last_byte: u32,
+    extra_byte: usize,
+    max_puff_length: usize,
+}
+
+fn allocate_zeroed(length: usize, label: &str) -> Result<Vec<u8>> {
+    let mut bytes = Vec::new();
+    bytes
+        .try_reserve_exact(length)
+        .map_err(|error| Error::Allocation(format!("{label}: {error}")))?;
+    bytes.resize(length, 0);
+    Ok(bytes)
+}
+
+fn checked_end(extent: Extent, label: &str) -> Result<usize> {
+    extent
+        .offset
+        .checked_add(extent.length)
+        .ok_or_else(|| Error::Corrupt(format!("{label} extent end overflows")))
+}
+
+impl<'a> Driver<'a> {
+    fn new(
+        source: Option<&'a [u8]>,
+        raw_size: usize,
+        puff_size: usize,
+        deflates: &[BitExtent],
+        puffs: &[ByteExtent],
+    ) -> Result<Self> {
+        if deflates.len() != puffs.len() {
+            return Err(Error::Corrupt("deflate and puff extent counts differ".into()));
+        }
+
+        let mut driver_deflates = Vec::new();
+        driver_deflates
+            .try_reserve_exact(deflates.len().saturating_add(1))
+            .map_err(|error| Error::Allocation(format!("deflate stream metadata: {error}")))?;
+        driver_deflates.extend(
+            deflates.iter().map(|extent| Extent { offset: extent.offset, length: extent.length }),
+        );
+        driver_deflates.push(Extent {
+            offset: raw_size
+                .checked_mul(8)
+                .ok_or_else(|| Error::Corrupt("raw stream bit length overflows".into()))?,
+            length: 0,
+        });
+
+        let mut driver_puffs = Vec::new();
+        driver_puffs
+            .try_reserve_exact(puffs.len().saturating_add(1))
+            .map_err(|error| Error::Allocation(format!("puff stream metadata: {error}")))?;
+        driver_puffs.extend(
+            puffs.iter().map(|extent| Extent { offset: extent.offset, length: extent.length }),
+        );
+        driver_puffs.push(Extent { offset: puff_size, length: 0 });
+
+        let mut upper_bounds = Vec::new();
+        upper_bounds
+            .try_reserve_exact(driver_puffs.len())
+            .map_err(|error| Error::Allocation(format!("puff stream index: {error}")))?;
+        for puff in &driver_puffs {
+            upper_bounds.push(checked_end(*puff, "puff")?);
+        }
+
+        let output = if source.is_some() {
+            Vec::new()
+        } else {
+            allocate_zeroed(raw_size, "raw Puffin output")?
+        };
+        Ok(Self {
+            source,
+            output,
+            output_position: 0,
+            deflates: driver_deflates,
+            puffs: driver_puffs,
+            upper_bounds,
+            current: 0,
+            puff_position: 0,
+            skip_bytes: 0,
+            deflate_bit_position: 0,
+            last_byte: 0,
+            extra_byte: 0,
+            max_puff_length: puffs.iter().map(|extent| extent.length).max().unwrap_or(0),
+        })
+    }
+
+    fn seek_to_zero(&mut self, huffing: bool) -> Result<()> {
+        self.current = self
+            .upper_bounds
+            .iter()
+            .position(|&bound| bound > 0)
+            .ok_or_else(|| Error::Corrupt("empty Puffin stream index".into()))?;
+        let puff = self.puffs[self.current];
+        let deflate = self.deflates[self.current];
+        if puff.offset > 0 {
+            self.puff_position = 0;
+            let rounded_deflate = deflate
+                .offset
+                .checked_add(7)
+                .ok_or_else(|| Error::Corrupt("deflate offset rounding overflows".into()))?
+                / 8;
+            self.deflate_bit_position = rounded_deflate
+                .checked_sub(puff.offset)
+                .and_then(|offset| offset.checked_mul(8))
+                .ok_or_else(|| Error::Corrupt("initial raw region is inconsistent".into()))?;
+        } else {
+            self.puff_position = puff.offset;
+            self.deflate_bit_position = deflate.offset;
+        }
+        if huffing {
+            self.set_extra_byte()?;
+        }
+        Ok(())
+    }
+
+    fn set_extra_byte(&mut self) -> Result<()> {
+        let deflate = *self
+            .deflates
+            .get(self.current)
+            .ok_or_else(|| Error::Corrupt("deflate index is out of range".into()))?;
+        let Some(next) = self.deflates.get(self.current + 1).copied() else {
+            self.extra_byte = 0;
+            return Ok(());
+        };
+        let end_bit = checked_end(deflate, "deflate")?;
+        let rounded_end = end_bit
+            .checked_add(7)
+            .ok_or_else(|| Error::Corrupt("deflate end rounding overflows".into()))?
+            & !7usize;
+        self.extra_byte = usize::from(end_bit & 7 != 0 && rounded_end <= next.offset);
+        Ok(())
+    }
+
+    fn source_slice(&self, range: std::ops::Range<usize>) -> Result<&'a [u8]> {
+        self.source
+            .and_then(|source| source.get(range))
+            .ok_or_else(|| Error::Corrupt("read past end of raw stream".into()))
+    }
+
+    fn write(&mut self, bytes: &[u8]) -> Result<()> {
+        let end = self
+            .output_position
+            .checked_add(bytes.len())
+            .ok_or_else(|| Error::Corrupt("raw output position overflows".into()))?;
+        let destination = self
+            .output
+            .get_mut(self.output_position..end)
+            .ok_or_else(|| Error::Corrupt("write past end of raw stream".into()))?;
+        destination.copy_from_slice(bytes);
+        self.output_position = end;
+        Ok(())
+    }
+
+    fn run_puff(
+        &mut self,
+        output: &mut [u8],
+        cancellation_token: &CancellationToken,
+    ) -> Result<()> {
+        let mut bytes_read = 0usize;
+        while bytes_read < output.len() {
+            check_cancelled(cancellation_token)?;
+            let deflate = self.deflates[self.current];
+            let puff = self.puffs[self.current];
+            if self.puff_position < puff.offset {
+                let start_byte = self.deflate_bit_position / 8;
+                let end_byte =
+                    deflate.offset.checked_add(7).ok_or_else(|| {
+                        Error::Corrupt("deflate offset rounding overflows".into())
+                    })? / 8;
+                let available = end_byte
+                    .checked_sub(start_byte)
+                    .ok_or_else(|| Error::Corrupt("raw region runs backward".into()))?;
+                let count = (output.len() - bytes_read).min(available);
+                if count == 0 {
+                    return Err(Error::Corrupt("raw region makes no progress".into()));
+                }
+                let source_end = start_byte
+                    .checked_add(count)
+                    .ok_or_else(|| Error::Corrupt("raw source range overflows".into()))?;
+                let destination_end = bytes_read
+                    .checked_add(count)
+                    .ok_or_else(|| Error::Corrupt("puff output range overflows".into()))?;
+                output[bytes_read..destination_end]
+                    .copy_from_slice(self.source_slice(start_byte..source_end)?);
+                if source_end
+                    .checked_mul(8)
+                    .ok_or_else(|| Error::Corrupt("raw bit position overflows".into()))?
+                    > deflate.offset
+                {
+                    let mask = ((1u16 << (deflate.offset & 7)) - 1) as u8;
+                    output[destination_end - 1] &= mask;
+                }
+                if start_byte * 8 < self.deflate_bit_position {
+                    output[bytes_read] >>= self.deflate_bit_position & 7;
+                }
+                self.deflate_bit_position = (self.deflate_bit_position & !7usize)
+                    .checked_add(count * 8)
+                    .ok_or_else(|| Error::Corrupt("raw bit position overflows".into()))?
+                    .min(deflate.offset);
+                bytes_read = destination_end;
+                self.puff_position = self
+                    .puff_position
+                    .checked_add(count)
+                    .ok_or_else(|| Error::Corrupt("puff position overflows".into()))?;
+                if self.puff_position > puff.offset {
+                    return Err(Error::Corrupt("raw region overruns puff extent".into()));
+                }
+                continue;
+            }
+
+            let deflate_end = checked_end(deflate, "deflate")?;
+            let start_byte = deflate.offset / 8;
+            let end_byte = deflate_end
+                .checked_add(7)
+                .ok_or_else(|| Error::Corrupt("deflate end rounding overflows".into()))?
+                / 8;
+            let deflate_bytes = self.source_slice(start_byte..end_byte)?;
+            let direct = self.skip_bytes == 0 && output.len() - bytes_read >= puff.length;
+            let mut temporary = Vec::new();
+            let target = if direct {
+                let end = bytes_read
+                    .checked_add(puff.length)
+                    .ok_or_else(|| Error::Corrupt("puff output range overflows".into()))?;
+                &mut output[bytes_read..end]
+            } else {
+                temporary = allocate_zeroed(puff.length, "temporary puff buffer")?;
+                &mut temporary
+            };
+            let mut bit_reader = BitReader::new(deflate_bytes);
+            let skipped_bits = deflate.offset & 7;
+            if !bit_reader.cache_bits(skipped_bits) {
+                return Err(Error::Corrupt("deflate extent starts past its bytes".into()));
+            }
+            bit_reader.drop_bits(skipped_bits);
+            let mut puff_writer = PuffWriter::new(target);
+            puff_deflate(&mut bit_reader, &mut puff_writer, cancellation_token)?;
+            let expected_bits = skipped_bits
+                .checked_add(deflate.length)
+                .ok_or_else(|| Error::Corrupt("deflate bit length overflows".into()))?;
+            if bit_reader.offset_in_bits()? != expected_bits
+                || bit_reader.offset() != deflate_bytes.len()
+                || puff_writer.size() != puff.length
+            {
+                return Err(Error::Corrupt("puffed extent size does not match metadata".into()));
+            }
+            let copy_count = (output.len() - bytes_read).min(
+                puff.length
+                    .checked_sub(self.skip_bytes)
+                    .ok_or_else(|| Error::Corrupt("puff skip exceeds extent".into()))?,
+            );
+            if !direct {
+                let copy_end = self
+                    .skip_bytes
+                    .checked_add(copy_count)
+                    .ok_or_else(|| Error::Corrupt("puff copy range overflows".into()))?;
+                output[bytes_read..bytes_read + copy_count]
+                    .copy_from_slice(&temporary[self.skip_bytes..copy_end]);
+            }
+            self.skip_bytes += copy_count;
+            bytes_read += copy_count;
+            if self
+                .puff_position
+                .checked_add(self.skip_bytes)
+                .ok_or_else(|| Error::Corrupt("puff position overflows".into()))?
+                == checked_end(puff, "puff")?
+            {
+                self.puff_position += self.skip_bytes;
+                self.skip_bytes = 0;
+                self.deflate_bit_position = deflate_end;
+                self.current += 1;
+                if self.current >= self.puffs.len() {
+                    break;
+                }
+            } else if copy_count == 0 {
+                return Err(Error::Corrupt("puff extent makes no progress".into()));
+            }
+        }
+        if bytes_read != output.len() {
+            return Err(Error::Corrupt("puffer did not fill its output".into()));
+        }
+        Ok(())
+    }
+
+    fn run_huff(&mut self, input: &[u8], cancellation_token: &CancellationToken) -> Result<()> {
+        let puff_buffer_size = self
+            .max_puff_length
+            .checked_add(1)
+            .ok_or_else(|| Error::Corrupt("puff buffer size overflows".into()))?;
+        let mut puff_buffer = allocate_zeroed(puff_buffer_size, "huffer puff buffer")?;
+        let mut bytes_written = 0usize;
+        while bytes_written < input.len() {
+            check_cancelled(cancellation_token)?;
+            let deflate = self.deflates[self.current];
+            let puff = self.puffs[self.current];
+            if self.deflate_bit_position < (deflate.offset & !7usize) {
+                if self.deflate_bit_position & 7 != 0 {
+                    return Err(Error::Corrupt("raw output is not byte-aligned".into()));
+                }
+                let raw_count = (deflate.offset / 8)
+                    .checked_sub(self.deflate_bit_position / 8)
+                    .ok_or_else(|| Error::Corrupt("raw output region runs backward".into()))?;
+                let copy_count = raw_count.min(input.len() - bytes_written);
+                if copy_count == 0 {
+                    return Err(Error::Corrupt("raw output makes no progress".into()));
+                }
+                self.write(&input[bytes_written..bytes_written + copy_count])?;
+                bytes_written += copy_count;
+                self.puff_position += copy_count;
+                self.deflate_bit_position += copy_count * 8;
+                continue;
+            }
+
+            if self.deflate_bit_position < deflate.offset {
+                let byte = *input
+                    .get(bytes_written)
+                    .ok_or_else(|| Error::Corrupt("missing shared boundary byte".into()))?;
+                self.last_byte |= u32::from(byte) << (self.deflate_bit_position & 7);
+                bytes_written += 1;
+                self.skip_bytes = 0;
+                self.deflate_bit_position = deflate.offset;
+                self.puff_position += 1;
+                if self.puff_position != puff.offset {
+                    return Err(Error::Corrupt("puff boundary position does not match".into()));
+                }
+            }
+
+            let required = puff
+                .length
+                .checked_add(self.extra_byte)
+                .and_then(|length| length.checked_sub(self.skip_bytes))
+                .ok_or_else(|| Error::Corrupt("puff buffer accounting is invalid".into()))?;
+            let copy_count = (input.len() - bytes_written).min(required);
+            let copy_end = self
+                .skip_bytes
+                .checked_add(copy_count)
+                .ok_or_else(|| Error::Corrupt("puff buffer range overflows".into()))?;
+            let destination = puff_buffer
+                .get_mut(self.skip_bytes..copy_end)
+                .ok_or_else(|| Error::Corrupt("puff buffer is too small".into()))?;
+            destination.copy_from_slice(&input[bytes_written..bytes_written + copy_count]);
+            self.skip_bytes = copy_end;
+            bytes_written += copy_count;
+
+            if self.skip_bytes == puff.length + self.extra_byte {
+                let deflate_end = checked_end(deflate, "deflate")?;
+                let start_byte = deflate.offset / 8;
+                let end_byte = deflate_end
+                    .checked_add(7)
+                    .ok_or_else(|| Error::Corrupt("deflate end rounding overflows".into()))?
+                    / 8;
+                let mut deflate_buffer = allocate_zeroed(
+                    end_byte
+                        .checked_sub(start_byte)
+                        .ok_or_else(|| Error::Corrupt("deflate byte range runs backward".into()))?,
+                    "huffed deflate buffer",
+                )?;
+                let mut count = deflate_buffer.len();
+                {
+                    let mut bit_writer = BitWriter::new(&mut deflate_buffer);
+                    bit_writer.write_bits(deflate.offset & 7, self.last_byte)?;
+                    self.last_byte = 0;
+                    let puff_bytes = puff_buffer
+                        .get(..puff.length)
+                        .ok_or_else(|| Error::Corrupt("puff extent exceeds buffer".into()))?;
+                    let mut puff_reader = PuffReader::new(puff_bytes);
+                    huff_deflate(&mut puff_reader, &mut bit_writer, cancellation_token)?;
+                    let expected_bits = (deflate.offset & 7)
+                        .checked_add(deflate.length)
+                        .ok_or_else(|| Error::Corrupt("deflate bit length overflows".into()))?;
+                    if bit_writer.offset_in_bits()? != expected_bits
+                        || puff_reader.bytes_left() != 0
+                    {
+                        return Err(Error::Corrupt(
+                            "huffed deflate bit length does not match metadata".into(),
+                        ));
+                    }
+                    bit_writer.flush()?;
+                    if bit_writer.size() != count {
+                        return Err(Error::Corrupt(
+                            "huffed deflate size does not match metadata".into(),
+                        ));
+                    }
+                }
+                self.deflate_bit_position = deflate_end;
+                if self.extra_byte == 1 {
+                    let last = deflate_buffer
+                        .last_mut()
+                        .ok_or_else(|| Error::Corrupt("empty deflate buffer".into()))?;
+                    *last |= puff_buffer[puff.length] << (self.deflate_bit_position & 7);
+                    self.deflate_bit_position = self
+                        .deflate_bit_position
+                        .checked_add(7)
+                        .ok_or_else(|| Error::Corrupt("deflate position overflows".into()))?
+                        & !7usize;
+                } else if self.deflate_bit_position & 7 != 0 {
+                    self.last_byte = u32::from(
+                        *deflate_buffer
+                            .last()
+                            .ok_or_else(|| Error::Corrupt("empty deflate buffer".into()))?,
+                    );
+                    count -= 1;
+                }
+                self.write(&deflate_buffer[..count])?;
+                self.puff_position += self.skip_bytes;
+                self.skip_bytes = 0;
+                self.current += 1;
+                if self.current >= self.puffs.len() {
+                    break;
+                }
+                self.set_extra_byte()?;
+            } else if copy_count == 0 {
+                return Err(Error::Corrupt("huffer makes no progress".into()));
+            }
+        }
+        if bytes_written != input.len() || self.output_position != self.output.len() {
+            return Err(Error::Corrupt("huffer output size does not match destination".into()));
+        }
+        Ok(())
+    }
+}
+
+pub fn puff(
+    source: &[u8],
+    deflates: &[BitExtent],
+    puffs: &[ByteExtent],
+    puff_size: usize,
+    cancellation_token: &CancellationToken,
+) -> Result<Vec<u8>> {
+    let mut driver = Driver::new(Some(source), source.len(), puff_size, deflates, puffs)?;
+    driver.seek_to_zero(false)?;
+    let mut output = allocate_zeroed(puff_size, "puffed source")?;
+    driver.run_puff(&mut output, cancellation_token)?;
+    Ok(output)
+}
+
+pub fn huff(
+    puffed: &[u8],
+    deflates: &[BitExtent],
+    puffs: &[ByteExtent],
+    puff_size: usize,
+    raw_size: usize,
+    cancellation_token: &CancellationToken,
+) -> Result<Vec<u8>> {
+    if puffed.len() != puff_size {
+        return Err(Error::SizeMismatch { expected: puff_size, actual: puffed.len() });
+    }
+    let mut driver = Driver::new(None, raw_size, puff_size, deflates, puffs)?;
+    driver.seek_to_zero(true)?;
+    driver.run_huff(puffed, cancellation_token)?;
+    Ok(driver.output)
+}
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index bc1ebf2..fd46353 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -105,6 +105,148 @@ const BROTLI_INVALID_HEADER_PATCH: &[u8] = &[
     0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
 ];
 
+const PUFFIN_FIXTURES: &str = "tests/fixtures/puffin";
+
+fn run_puffdiff_extraction(source: &[u8], target: &[u8], patch: &[u8]) -> Result<Vec<u8>, String> {
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+
+    let source_split = source.len() / 2;
+    let mut source_partition = Vec::with_capacity(source.len() + 1);
+    source_partition.extend_from_slice(&source[..source_split]);
+    source_partition.push(0xa5);
+    source_partition.extend_from_slice(&source[source_split..]);
+    fs::write(source_dir.join("system.img"), &source_partition).unwrap();
+
+    let target_split = target.len() / 2;
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(1),
+        minor_version: Some(5),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(&source_partition)),
+            new_partition_info: Some(partition_info(target)),
+            operations: vec![InstallOperation {
+                operation_type: 9,
+                data_offset: Some(0),
+                data_length: Some(patch.len() as u64),
+                src_extents: vec![
+                    extent(0, source_split as u64),
+                    extent((source_split + 1) as u64, (source.len() - source_split) as u64),
+                ],
+                src_length: Some(source.len() as u64),
+                dst_extents: vec![
+                    extent(0, target_split as u64),
+                    extent(target_split as u64, (target.len() - target_split) as u64),
+                ],
+                dst_length: Some(target.len() as u64),
+                data_sha256_hash: Some(sha256(patch)),
+                src_sha256_hash: Some(sha256(source)),
+            }],
+            ..Default::default()
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, patch);
+
+    match ExtractOptions::new()
+        .source_dir(&source_dir)
+        .num_threads(2)
+        .extract(&payload, &output_dir)
+    {
+        Ok(()) => {
+            assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source_partition);
+            assert_eq!(fs::read_dir(&output_dir).unwrap().count(), 1);
+            Ok(fs::read(output_dir.join("system.img")).unwrap())
+        }
+        Err(error) => {
+            assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source_partition);
+            assert!(!output_dir.join("system.img").exists());
+            assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
+            Err(error.to_string())
+        }
+    }
+}
+
+fn puffin_fixture(name: &str) -> Vec<u8> {
+    fs::read(Path::new(PUFFIN_FIXTURES).join(name)).unwrap()
+}
+
+fn with_puffin_patch_type(patch: &[u8], patch_type: u8) -> Vec<u8> {
+    let header_len = u32::from_be_bytes(patch[4..8].try_into().unwrap()) as usize;
+    let mut changed = Vec::with_capacity(patch.len() + 2);
+    changed.extend_from_slice(&patch[..8 + header_len]);
+    changed.extend_from_slice(&[0x20, patch_type]);
+    changed.extend_from_slice(&patch[8 + header_len..]);
+    changed[4..8].copy_from_slice(&((header_len + 2) as u32).to_be_bytes());
+    changed
+}
+
+#[test]
+fn puffdiff_bsdiff_reconstructs_pinned_puffin_goldens() {
+    let source = puffin_fixture("deflates-sample1.bin");
+    for (patch_name, target_name) in [
+        ("patch-1-to-2.puf", "deflates-sample2.bin"),
+        ("patch-1-to-raw.puf", "raw-11-22-33-44.bin"),
+    ] {
+        let patch = puffin_fixture(patch_name);
+        let target = puffin_fixture(target_name);
+        let output = run_puffdiff_extraction(&source, &target, &patch).unwrap();
+        assert_eq!(output, target);
+    }
+}
+
+#[test]
+fn malformed_puffdiff_data_fails_without_publication_or_process_failure() {
+    let source = puffin_fixture("deflates-sample1.bin");
+    let target = puffin_fixture("deflates-sample2.bin");
+    let valid_patch = puffin_fixture("patch-1-to-2.puf");
+
+    let mut bad_magic = valid_patch.clone();
+    bad_magic[..4].copy_from_slice(b"BAD!");
+
+    let truncated_proto = [b"PUF1".as_slice(), &1u32.to_be_bytes(), &[0x80]].concat();
+
+    let mut non_byte_puff = valid_patch.clone();
+    let puff_length = non_byte_puff
+        .windows(6)
+        .position(|window| window == [0x12, 0x04, 0x08, 0x10, 0x10, 0x58])
+        .unwrap()
+        + 5;
+    non_byte_puff[puff_length] += 1;
+
+    let mut overlapping_deflates = valid_patch.clone();
+    let second_deflate_offset = overlapping_deflates
+        .windows(6)
+        .position(|window| window == [0x0a, 0x04, 0x08, 0x50, 0x10, 0x0a])
+        .unwrap()
+        + 3;
+    overlapping_deflates[second_deflate_offset] = 0x40;
+
+    let mut bad_inner_bsdiff = valid_patch.clone();
+    let header_len = u32::from_be_bytes(bad_inner_bsdiff[4..8].try_into().unwrap()) as usize;
+    bad_inner_bsdiff[8 + header_len] = b'X';
+
+    for (patch, expected_error) in [
+        (bad_magic, "missing PUF1 magic"),
+        (truncated_proto, "truncated protobuf varint"),
+        (non_byte_puff, "puff extent is not byte-aligned"),
+        (overlapping_deflates, "deflate extents overlap or are unsorted"),
+        (bad_inner_bsdiff, "inner BSDIFF patch is invalid"),
+        (with_puffin_patch_type(&valid_patch, 1), "unsupported PUFFDIFF patch type 1"),
+        (with_puffin_patch_type(&valid_patch, 2), "unsupported PUFFDIFF patch type 2"),
+    ] {
+        let error = run_puffdiff_extraction(&source, &target, &patch).unwrap_err();
+        assert!(error.contains(expected_error), "unexpected error: {error}");
+    }
+
+    let short_target = &target[..target.len() - 1];
+    let error = run_puffdiff_extraction(&source, short_target, &valid_patch).unwrap_err();
+    assert!(error.contains("destination raw size mismatch"), "unexpected error: {error}");
+}
+
 #[cfg(otadump_zucchini)]
 const ZUCCHINI_FIXTURES: &str = "tests/fixtures/zucchini";
 
diff --git a/tests/fixtures/puffin/LICENSE b/tests/fixtures/puffin/LICENSE
new file mode 100644
index 0000000..f6d41c6
--- /dev/null
+++ b/tests/fixtures/puffin/LICENSE
@@ -0,0 +1,27 @@
+// Copyright 2017 The ChromiumOS Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/tests/fixtures/puffin/README.md b/tests/fixtures/puffin/README.md
new file mode 100644
index 0000000..ba2e8d4
--- /dev/null
+++ b/tests/fixtures/puffin/README.md
@@ -0,0 +1,13 @@
+# Puffin fixtures
+
+These fixtures come from ChromiumOS Puffin commit `343e23db1b4d81045e91a10244244893f5acd73b`.
+The source files are `src/unittest_common.cc` and `src/patching_unittest.cc`.
+
+- `deflates-sample1.bin` is `kDeflatesSample1`.
+- `deflates-sample2.bin` is `kDeflatesSample2`.
+- `patch-1-to-2.puf` is `kPatch1To2`.
+- `patch-1-to-raw.puf` is `kPatch1ToNoDeflate`.
+- `raw-11-22-33-44.bin` is the expected output declared by `Patching1ToNoDeflateTest`.
+
+The files retain Puffin's BSD-3-Clause license in `LICENSE`.
+Verify them with `sha256sum -c SHA256SUMS` from this directory.
diff --git a/tests/fixtures/puffin/SHA256SUMS b/tests/fixtures/puffin/SHA256SUMS
new file mode 100644
index 0000000..5ef1182
--- /dev/null
+++ b/tests/fixtures/puffin/SHA256SUMS
@@ -0,0 +1,5 @@
+de0527c0d2d27f378cb79aec447172e0efcfff9cc45d0be05c313a87a2069280  deflates-sample1.bin
+649b17ae72a6d503a1176604d876923270cd467ae1d458a54e58575eda98766e  deflates-sample2.bin
+cb44443bb6312b8faac434d3bd7cf67419c78733b863a8c7ecf4815a071cb9bb  patch-1-to-2.puf
+20eef1e91c331d93f8d42f20b2875836aac05b2b2c96fb7d19e9a3a41043341f  patch-1-to-raw.puf
+bdbdce312f5762571faa17f3f4780235ed2c54f966c0f60dace1cddd2634f4f3  raw-11-22-33-44.bin
diff --git a/tests/fixtures/puffin/deflates-sample1.bin b/tests/fixtures/puffin/deflates-sample1.bin
new file mode 100644
index 0000000000000000000000000000000000000000..3bfad73a72fd1e3307444a8d7a66d2a7c0222dc9
GIT binary patch
literal 17
YcmWesN=`{iOJrp*W@bocVQ>ir03kmEUjP6A

literal 0
HcmV?d00001

diff --git a/tests/fixtures/puffin/deflates-sample2.bin b/tests/fixtures/puffin/deflates-sample2.bin
new file mode 100644
index 0000000000000000000000000000000000000000..a5ae9f565d494da1912b5ed3119fc6b8690e6083
GIT binary patch
literal 22
dcmYdJNlHs(WiU=-WM%mEpOJ}~g*BOl0RTip1q1*9

literal 0
HcmV?d00001

diff --git a/tests/fixtures/puffin/patch-1-to-2.puf b/tests/fixtures/puffin/patch-1-to-2.puf
new file mode 100644
index 0000000000000000000000000000000000000000..26659edfa475d86e35a8687c79394b7e4adfadeb
GIT binary patch
literal 266
zcmWFtbu(mOU<l-36jJA6;Sdlo0+Im&TtG5GKu8EA5&<MD1T=(LIaV+VSV+iAsc<oY
zm3asRaItdCU<9gT0;?(jlB^sjK&lj-f?eE<7#SHYfTn|h34~%$gwjq?8J32Qk!rz_
z7ZrBbF)%PEI8^X)FgP$MFc`A=I85qyTfXAK=WB{WU-mc~$%_}cS_Di0sYK}es1VP~
zz`*1v>cpV{)W^UC(yL^vEYQY0EksZ(9-;@N3ZaMn%IQ1?1_nkTRA5k)aBF(!v7AeY
J;n&RE0|2lnHe>(*

literal 0
HcmV?d00001

diff --git a/tests/fixtures/puffin/patch-1-to-raw.puf b/tests/fixtures/puffin/patch-1-to-raw.puf
new file mode 100644
index 0000000000000000000000000000000000000000..fc95db46a4d76d9a23d8090f1122ca30e62496fc
GIT binary patch
literal 185
zcmWFtbu(mOV9@7a6jJA6;Sdlo0+Im&TtG5GKu8EA5&<MD1T=(LIaV+VSV+iAF-fpE
z1-rNzF)}i00QG_ZAB19HfznP<8J32Qk!rz_yL#(&fr1VUE*uIB24^^pLQ*YuPtrWp
z(t0KPX9h@}c#*3`zyy#+gs$hSKK=m;6fiJwFfu5xC@?6_$}sj7wuwC{^3ch7-s<BY
E06fVi%K!iX

literal 0
HcmV?d00001

diff --git a/tests/fixtures/puffin/raw-11-22-33-44.bin b/tests/fixtures/puffin/raw-11-22-33-44.bin
new file mode 100644
index 0000000..d215705
--- /dev/null
+++ b/tests/fixtures/puffin/raw-11-22-33-44.bin
@@ -0,0 +1 @@
+!,
\ No newline at end of file

From 705bb20be61347653acf61ca8c282a09c4bb945b Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Fri, 11 Sep 2026 20:26:17 +0530
Subject: [PATCH 10/42] puffin: Apply Zucchini patch operations

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 README.md                                     |   4 +-
 src/lib.rs                                    |   2 +-
 src/puffin/mod.rs                             |   4 ++
 src/puffin/patch.rs                           |  48 ++++++++++++++----
 tests/delta_extraction.rs                     |  45 +++++++++++++++-
 tests/fixtures/puffin/LICENSE.zucchini        |  27 ++++++++++
 tests/fixtures/puffin/README.md               |  27 +++++++++-
 tests/fixtures/puffin/SHA256SUMS              |   1 +
 .../fixtures/puffin/patch-1-to-2-zucchini.puf | Bin 0 -> 176 bytes
 9 files changed, 142 insertions(+), 16 deletions(-)
 create mode 100644 tests/fixtures/puffin/LICENSE.zucchini
 create mode 100644 tests/fixtures/puffin/patch-1-to-2-zucchini.puf

diff --git a/README.md b/README.md
index 9cbc4b4..90dbc70 100644
--- a/README.md
+++ b/README.md
@@ -81,8 +81,8 @@ otadump ota.zip
 # Run on payload.bin file.
 otadump payload.bin
 
-# Apply a SOURCE_COPY, SOURCE_BSDIFF, BROTLI_BSDIFF, PUFFDIFF (inner BSDIFF),
-# or ZUCCHINI delta payload with matching base partition images.
+# Apply a SOURCE_COPY, SOURCE_BSDIFF, BROTLI_BSDIFF, PUFFDIFF (inner BSDIFF or
+# ZUCCHINI), or standalone ZUCCHINI delta payload with matching base images.
 # ZUCCHINI requires Linux x86-64 GNU.
 otadump delta.zip --output-dir output --source-dir source-images
 ```
diff --git a/src/lib.rs b/src/lib.rs
index 7dea119..66c69b5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1110,7 +1110,7 @@ impl Task<'_> {
     }
 }
 
-fn decode_zucchini_patch(
+pub(crate) fn decode_zucchini_patch(
     compressed_patch: &[u8],
     cancellation_token: &CancellationToken,
 ) -> Result<Vec<u8>> {
diff --git a/src/puffin/mod.rs b/src/puffin/mod.rs
index 512460e..5d1f25d 100644
--- a/src/puffin/mod.rs
+++ b/src/puffin/mod.rs
@@ -37,6 +37,7 @@ pub(crate) enum Error {
     InvalidMetadata(String),
     Corrupt(String),
     Bsdiff(String),
+    Zucchini(String),
     SizeMismatch { expected: usize, actual: usize },
     Allocation(String),
     Cancelled(ExtractionCancelled),
@@ -59,6 +60,9 @@ impl fmt::Display for Error {
             }
             Self::Corrupt(message) => write!(formatter, "corrupt Puffin stream: {message}"),
             Self::Bsdiff(message) => write!(formatter, "inner BSDIFF patch is invalid: {message}"),
+            Self::Zucchini(message) => {
+                write!(formatter, "inner ZUCCHINI patch is invalid: {message}")
+            }
             Self::SizeMismatch { expected, actual } => {
                 write!(formatter, "PUFFDIFF size mismatch: expected {expected}, got {actual}")
             }
diff --git a/src/puffin/patch.rs b/src/puffin/patch.rs
index ac9389f..fdc4c2a 100644
--- a/src/puffin/patch.rs
+++ b/src/puffin/patch.rs
@@ -10,10 +10,14 @@ use brotli::Decompressor as BrotliDecoder;
 use bzip2::read::BzDecoder;
 
 use crate::puffin::{BitExtent, ByteExtent, Error, Result, check_cancelled, stream};
-use crate::{CancellationToken, validate_bsdiff_output_len, zucchini};
+use crate::{
+    CancellationToken, ExtractionCancelled, decode_zucchini_patch, is_cancellation,
+    validate_bsdiff_output_len, zucchini,
+};
 
 const MAGIC: &[u8; 4] = b"PUF1";
 const PATCH_TYPE_BSDIFF: i32 = 0;
+const PATCH_TYPE_ZUCCHINI: i32 = 1;
 const DECODE_CHUNK_SIZE: usize = 32 * 1024;
 
 #[derive(Clone, Copy)]
@@ -474,7 +478,7 @@ pub fn apply(
         .get(8..header_end)
         .ok_or_else(|| Error::BadPatchHeader("protobuf header overruns patch".into()))?;
     let header = parse_header(header_bytes)?;
-    if header.patch_type != PATCH_TYPE_BSDIFF {
+    if !matches!(header.patch_type, PATCH_TYPE_BSDIFF | PATCH_TYPE_ZUCCHINI) {
         return Err(Error::UnsupportedPatchType(header.patch_type));
     }
     validate_stream(&header.source, source.len(), "source")?;
@@ -493,15 +497,37 @@ pub fn apply(
     )?;
 
     check_cancelled(cancellation_token)?;
-    validate_bsdiff_output_len(raw_patch, header.destination.puff_length)
-        .map_err(|error| Error::Bsdiff(error.to_string()))?;
-    validate_inner_bsdiff_resources(raw_patch, header.destination.puff_length, cancellation_token)?;
-    let mut puffed_destination = Vec::new();
-    puffed_destination
-        .try_reserve_exact(header.destination.puff_length)
-        .map_err(|error| Error::Allocation(format!("puffed destination: {error}")))?;
-    bsdiff_android::patch_bsdf2(&puffed_source, raw_patch, &mut puffed_destination)
-        .map_err(|error| Error::Bsdiff(error.to_string()))?;
+    let puffed_destination = if header.patch_type == PATCH_TYPE_BSDIFF {
+        validate_bsdiff_output_len(raw_patch, header.destination.puff_length)
+            .map_err(|error| Error::Bsdiff(error.to_string()))?;
+        validate_inner_bsdiff_resources(
+            raw_patch,
+            header.destination.puff_length,
+            cancellation_token,
+        )?;
+        let mut destination = Vec::new();
+        destination
+            .try_reserve_exact(header.destination.puff_length)
+            .map_err(|error| Error::Allocation(format!("puffed destination: {error}")))?;
+        bsdiff_android::patch_bsdf2(&puffed_source, raw_patch, &mut destination)
+            .map_err(|error| Error::Bsdiff(error.to_string()))?;
+        destination
+    } else {
+        let zucchini_patch =
+            decode_zucchini_patch(raw_patch, cancellation_token).map_err(|error| {
+                if is_cancellation(error.as_ref()) {
+                    Error::Cancelled(ExtractionCancelled)
+                } else {
+                    Error::Zucchini(error.to_string())
+                }
+            })?;
+        check_cancelled(cancellation_token)?;
+        let destination =
+            zucchini::apply(&puffed_source, &zucchini_patch, header.destination.puff_length)
+                .map_err(|error| Error::Zucchini(format!("apply failed: {error}")))?;
+        check_cancelled(cancellation_token)?;
+        destination
+    };
     if puffed_destination.len() != header.destination.puff_length {
         return Err(Error::SizeMismatch {
             expected: header.destination.puff_length,
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index fd46353..97b861f 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -184,6 +184,14 @@ fn with_puffin_patch_type(patch: &[u8], patch_type: u8) -> Vec<u8> {
     changed
 }
 
+fn with_puffin_inner_patch(patch: &[u8], inner_patch: &[u8]) -> Vec<u8> {
+    let header_len = u32::from_be_bytes(patch[4..8].try_into().unwrap()) as usize;
+    let mut changed = Vec::with_capacity(8 + header_len + inner_patch.len());
+    changed.extend_from_slice(&patch[..8 + header_len]);
+    changed.extend_from_slice(inner_patch);
+    changed
+}
+
 #[test]
 fn puffdiff_bsdiff_reconstructs_pinned_puffin_goldens() {
     let source = puffin_fixture("deflates-sample1.bin");
@@ -198,6 +206,18 @@ fn puffdiff_bsdiff_reconstructs_pinned_puffin_goldens() {
     }
 }
 
+#[test]
+#[cfg(otadump_zucchini)]
+fn puffdiff_zucchini_reconstructs_pinned_puffin_golden() {
+    let source = puffin_fixture("deflates-sample1.bin");
+    let target = puffin_fixture("deflates-sample2.bin");
+    let patch = puffin_fixture("patch-1-to-2-zucchini.puf");
+
+    let output = run_puffdiff_extraction(&source, &target, &patch).unwrap();
+
+    assert_eq!(output, target);
+}
+
 #[test]
 fn malformed_puffdiff_data_fails_without_publication_or_process_failure() {
     let source = puffin_fixture("deflates-sample1.bin");
@@ -235,7 +255,6 @@ fn malformed_puffdiff_data_fails_without_publication_or_process_failure() {
         (non_byte_puff, "puff extent is not byte-aligned"),
         (overlapping_deflates, "deflate extents overlap or are unsorted"),
         (bad_inner_bsdiff, "inner BSDIFF patch is invalid"),
-        (with_puffin_patch_type(&valid_patch, 1), "unsupported PUFFDIFF patch type 1"),
         (with_puffin_patch_type(&valid_patch, 2), "unsupported PUFFDIFF patch type 2"),
     ] {
         let error = run_puffdiff_extraction(&source, &target, &patch).unwrap_err();
@@ -247,6 +266,30 @@ fn malformed_puffdiff_data_fails_without_publication_or_process_failure() {
     assert!(error.contains("destination raw size mismatch"), "unexpected error: {error}");
 }
 
+#[test]
+#[cfg(otadump_zucchini)]
+fn malformed_puffdiff_zucchini_fails_without_publication_or_process_failure() {
+    let source = puffin_fixture("deflates-sample1.bin");
+    let target = puffin_fixture("deflates-sample2.bin");
+    let valid_patch = puffin_fixture("patch-1-to-2-zucchini.puf");
+    let malformed_zucchini =
+        fs::read(Path::new("tests/fixtures/zucchini/malformed-zucchini.zuc.br")).unwrap();
+
+    for (patch, expected_error) in [
+        (
+            with_puffin_inner_patch(&valid_patch, b"not a Brotli stream\n"),
+            "Unable to decode ZUCCHINI Brotli patch",
+        ),
+        (
+            with_puffin_inner_patch(&valid_patch, &malformed_zucchini),
+            "inner ZUCCHINI patch is invalid: apply failed: invalid ensemble patch",
+        ),
+    ] {
+        let error = run_puffdiff_extraction(&source, &target, &patch).unwrap_err();
+        assert!(error.contains(expected_error), "unexpected error: {error}");
+    }
+}
+
 #[cfg(otadump_zucchini)]
 const ZUCCHINI_FIXTURES: &str = "tests/fixtures/zucchini";
 
diff --git a/tests/fixtures/puffin/LICENSE.zucchini b/tests/fixtures/puffin/LICENSE.zucchini
new file mode 100644
index 0000000..a32e00c
--- /dev/null
+++ b/tests/fixtures/puffin/LICENSE.zucchini
@@ -0,0 +1,27 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/tests/fixtures/puffin/README.md b/tests/fixtures/puffin/README.md
index ba2e8d4..ce950fc 100644
--- a/tests/fixtures/puffin/README.md
+++ b/tests/fixtures/puffin/README.md
@@ -6,8 +6,33 @@ The source files are `src/unittest_common.cc` and `src/patching_unittest.cc`.
 - `deflates-sample1.bin` is `kDeflatesSample1`.
 - `deflates-sample2.bin` is `kDeflatesSample2`.
 - `patch-1-to-2.puf` is `kPatch1To2`.
+- `patch-1-to-2-zucchini.puf` reconstructs `deflates-sample2.bin` from `deflates-sample1.bin` through three actual deflate streams on each side.
 - `patch-1-to-raw.puf` is `kPatch1ToNoDeflate`.
 - `raw-11-22-33-44.bin` is the expected output declared by `Patching1ToNoDeflateTest`.
 
-The files retain Puffin's BSD-3-Clause license in `LICENSE`.
+The files retain Puffin's BSD-3-Clause license in `LICENSE` and Zucchini's BSD-3-Clause license in `LICENSE.zucchini`.
 Verify them with `sha256sum -c SHA256SUMS` from this directory.
+
+The Zucchini fixture uses Puffin at the commit above and AOSP Zucchini at `e256025d9d9c906caba814fd7b99a311ac8b8ec1`.
+Build the pinned AOSP host `puffin` target with the pinned Zucchini source.
+Generate and independently apply the PUF1 bytes with the upstream tool:
+
+```sh
+PUFFIN=/path/to/aosp/out/host/linux-x86/bin/puffin
+"$PUFFIN" \
+  --operation=puffdiff \
+  --src_file=deflates-sample1.bin \
+  --dst_file=deflates-sample2.bin \
+  --patch_file=patch-1-to-2-zucchini.puf \
+  --src_file_type=raw \
+  --dst_file_type=raw \
+  --src_deflates_bit=16:50,80:10,96:18 \
+  --dst_deflates_bit=0:50,72:80,152:18 \
+  --patch_algorithm=1
+"$PUFFIN" \
+  --operation=puffpatch \
+  --src_file=deflates-sample1.bin \
+  --dst_file=generated.bin \
+  --patch_file=patch-1-to-2-zucchini.puf
+cmp deflates-sample2.bin generated.bin
+```
diff --git a/tests/fixtures/puffin/SHA256SUMS b/tests/fixtures/puffin/SHA256SUMS
index 5ef1182..fe00d01 100644
--- a/tests/fixtures/puffin/SHA256SUMS
+++ b/tests/fixtures/puffin/SHA256SUMS
@@ -1,5 +1,6 @@
 de0527c0d2d27f378cb79aec447172e0efcfff9cc45d0be05c313a87a2069280  deflates-sample1.bin
 649b17ae72a6d503a1176604d876923270cd467ae1d458a54e58575eda98766e  deflates-sample2.bin
 cb44443bb6312b8faac434d3bd7cf67419c78733b863a8c7ecf4815a071cb9bb  patch-1-to-2.puf
+826cd5b1a815cda2d13c2ca5733a9f9e99e0030d27178f2e9d44e47d73d4a9a8  patch-1-to-2-zucchini.puf
 20eef1e91c331d93f8d42f20b2875836aac05b2b2c96fb7d19e9a3a41043341f  patch-1-to-raw.puf
 bdbdce312f5762571faa17f3f4780235ed2c54f966c0f60dace1cddd2634f4f3  raw-11-22-33-44.bin
diff --git a/tests/fixtures/puffin/patch-1-to-2-zucchini.puf b/tests/fixtures/puffin/patch-1-to-2-zucchini.puf
new file mode 100644
index 0000000000000000000000000000000000000000..948ff9dfb6b44e0cb7ef03408962e128d6c2a860
GIT binary patch
literal 176
zcmWFtbu(mOU<l@56jJA6;Sdlo0+Im&TtG5GKu8EA5&<MD1T=(LIaV+VSV+iAsc<oY
zm3asRaItdCU<9gT0;?(jlB^sjK&liK7{xOf7>=CUyw^seJKag(g2;XU-__n>lZ#qk
ze|6I1t4I)@`#O8N$Fz*T%AQooz80Tv+f*6S=AXJ7_POomb#pVG8~q1aykj_me#tjD
O3p{rEr(V!lAqfEaA2FW*

literal 0
HcmV?d00001


From a34540f8496f4a8e5e1db9efbf8b8e0edd69ef6c Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Sat, 12 Sep 2026 08:35:01 +0530
Subject: [PATCH 11/42] lz4: Vendor bit-exact native boundary

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 build.rs                                   |   42 +-
 native/lz4/LICENSE                         |   24 +
 native/lz4/README.md                       |   16 +
 native/lz4/SOURCE_INVENTORY.sha256         |    9 +
 native/lz4/src/lz4_ffi.c                   |   96 +
 native/lz4/src/lz4_ffi.h                   |   33 +
 native/lz4/vendor/lib/lz4.c                | 2829 ++++++++++++++++++++
 native/lz4/vendor/lib/lz4.h                |  884 ++++++
 native/lz4/vendor/lib/lz4hc.c              | 2192 +++++++++++++++
 native/lz4/vendor/lib/lz4hc.h              |  414 +++
 native/lz4/vendor/lib/xxhash.c             | 1030 +++++++
 native/lz4/vendor/lib/xxhash.h             |  328 +++
 src/lib.rs                                 |    1 +
 src/lz4.rs                                 |  487 ++++
 tests/fixtures/lz4/LICENSE                 |   25 +
 tests/fixtures/lz4/README.md               |   14 +
 tests/fixtures/lz4/SHA256SUMS              |    7 +
 tests/fixtures/lz4/lz4-no-postfix.lz4      |  Bin 0 -> 768 bytes
 tests/fixtures/lz4/lz4-no-postfix.raw      |    3 +
 tests/fixtures/lz4/lz4hc9-no-postfix.lz4   |  Bin 0 -> 1152 bytes
 tests/fixtures/lz4/lz4hc9-no-postfix.raw   |  Bin 0 -> 1536 bytes
 tests/fixtures/lz4/zero-padding-layout.lz4 |  Bin 0 -> 608 bytes
 tests/fixtures/lz4/zero-padding-layout.raw |    2 +
 23 files changed, 8430 insertions(+), 6 deletions(-)
 create mode 100644 native/lz4/LICENSE
 create mode 100644 native/lz4/README.md
 create mode 100644 native/lz4/SOURCE_INVENTORY.sha256
 create mode 100644 native/lz4/src/lz4_ffi.c
 create mode 100644 native/lz4/src/lz4_ffi.h
 create mode 100644 native/lz4/vendor/lib/lz4.c
 create mode 100644 native/lz4/vendor/lib/lz4.h
 create mode 100644 native/lz4/vendor/lib/lz4hc.c
 create mode 100644 native/lz4/vendor/lib/lz4hc.h
 create mode 100644 native/lz4/vendor/lib/xxhash.c
 create mode 100644 native/lz4/vendor/lib/xxhash.h
 create mode 100644 src/lz4.rs
 create mode 100644 tests/fixtures/lz4/LICENSE
 create mode 100644 tests/fixtures/lz4/README.md
 create mode 100644 tests/fixtures/lz4/SHA256SUMS
 create mode 100644 tests/fixtures/lz4/lz4-no-postfix.lz4
 create mode 100644 tests/fixtures/lz4/lz4-no-postfix.raw
 create mode 100644 tests/fixtures/lz4/lz4hc9-no-postfix.lz4
 create mode 100644 tests/fixtures/lz4/lz4hc9-no-postfix.raw
 create mode 100644 tests/fixtures/lz4/zero-padding-layout.lz4
 create mode 100644 tests/fixtures/lz4/zero-padding-layout.raw

diff --git a/build.rs b/build.rs
index 9060e65..80fedb8 100644
--- a/build.rs
+++ b/build.rs
@@ -41,14 +41,24 @@ const ZUCCHINI_SOURCES: &[&str] = &[
     "native/zucchini/vendor/libchrome/base/time/time_now_posix.cc",
 ];
 
+const LZ4_SOURCES: &[&str] = &[
+    "native/lz4/src/lz4_ffi.c",
+    "native/lz4/vendor/lib/lz4.c",
+    "native/lz4/vendor/lib/lz4hc.c",
+    "native/lz4/vendor/lib/xxhash.c",
+];
+
 fn main() {
+    println!("cargo:rustc-check-cfg=cfg(otadump_lz4)");
     println!("cargo:rustc-check-cfg=cfg(otadump_zucchini)");
     println!("cargo:rerun-if-changed=src/protos/chromeos_update_engine/update_metadata.proto");
     if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("linux")
         && std::env::var("CARGO_CFG_TARGET_ARCH").as_deref() == Ok("x86_64")
         && std::env::var("CARGO_CFG_TARGET_ENV").as_deref() == Ok("gnu")
     {
+        build_lz4();
         build_zucchini();
+        println!("cargo:rustc-cfg=otadump_lz4");
         println!("cargo:rustc-cfg=otadump_zucchini");
     }
 
@@ -63,14 +73,25 @@ fn main() {
         .expect("error compiling protobuf files");
 }
 
+fn build_lz4() {
+    let root = Path::new("native/lz4");
+    track_directory(root);
+
+    cc::Build::new()
+        .std("c99")
+        .opt_level(3)
+        .define("NDEBUG", None)
+        .warnings(true)
+        .warnings_into_errors(true)
+        .include(root.join("src"))
+        .include(root.join("vendor/lib"))
+        .files(LZ4_SOURCES)
+        .compile("otadump_lz4");
+}
+
 fn build_zucchini() {
     let root = Path::new("native/zucchini");
-    let mut tracked = Vec::new();
-    collect_files(root, &mut tracked);
-    tracked.sort();
-    for path in tracked {
-        println!("cargo:rerun-if-changed={}", path.display());
-    }
+    track_directory(root);
 
     let mut build = cc::Build::new();
     build
@@ -102,6 +123,15 @@ fn build_zucchini() {
     println!("cargo:rustc-link-arg=-static-libgcc");
 }
 
+fn track_directory(root: &Path) {
+    let mut tracked = Vec::new();
+    collect_files(root, &mut tracked);
+    tracked.sort();
+    for path in tracked {
+        println!("cargo:rerun-if-changed={}", path.display());
+    }
+}
+
 fn add_static_runtime(compiler: &cc::Tool, archive: &str, library: &str) {
     let output = compiler
         .to_command()
diff --git a/native/lz4/LICENSE b/native/lz4/LICENSE
new file mode 100644
index 0000000..4884916
--- /dev/null
+++ b/native/lz4/LICENSE
@@ -0,0 +1,24 @@
+LZ4 Library
+Copyright (c) 2011-2020, Yann Collet
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/native/lz4/README.md b/native/lz4/README.md
new file mode 100644
index 0000000..e053d47
--- /dev/null
+++ b/native/lz4/README.md
@@ -0,0 +1,16 @@
+# AOSP LZ4 boundary
+
+This directory vendors the LZ4 block operations used by Android `lz4diff`.
+The files under `vendor/lib` come from AOSP `platform/external/lz4` commit `734e07032602e9a72fcc9701028b0aee45147fcd`.
+They use the BSD-2-Clause license in `LICENSE`.
+
+`src/lz4_ffi.c` and `src/lz4_ffi.h` are project-owned BSD-2-Clause files.
+They provide a fixed C ABI for `LZ4_decompress_safe_partial`, `LZ4_compress_destSize`, and `LZ4_compress_HC_destSize`.
+The HC wrapper owns and frees its native stream state.
+No dictionary API is exposed.
+
+`build.rs` compiles only the three pinned library source units and the local wrapper on Linux x86_64 GNU.
+It uses C99, optimization level 3, `NDEBUG`, compiler warnings, and warnings as errors.
+The resulting archive links statically into `otadump`.
+
+Run `sha256sum -c SOURCE_INVENTORY.sha256` from this directory to verify the source inventory.
diff --git a/native/lz4/SOURCE_INVENTORY.sha256 b/native/lz4/SOURCE_INVENTORY.sha256
new file mode 100644
index 0000000..aede22b
--- /dev/null
+++ b/native/lz4/SOURCE_INVENTORY.sha256
@@ -0,0 +1,9 @@
+8b58c446121a109ccf32edc094bba3010a3d85e4ee3702950db55e4d3e87736c  LICENSE
+23242d5e48eb4d60ce0868d885dc6406b68a8590e5f191ca000cb8ba28367193  src/lz4_ffi.c
+65841c1381dc311dca4f8741684698c934ca6e465650ba25aa172d99844c1e26  src/lz4_ffi.h
+9396f7de527bc8435de9c7569fb7998e56545a84b4f3c2d808c0235c01774539  vendor/lib/lz4.c
+26b82efc53d1570f3b54eef02e9c4764c1ad374ff03cac04e2ced5ea4d4c552f  vendor/lib/lz4.h
+126cafafdb91767e6e55238298a910903851b35b2cee27ce80ae2280469ee232  vendor/lib/lz4hc.c
+e43824e8a9ba16f54100c4ccbccfa5782a858ca9ab83c48aac303fea3e76e21e  vendor/lib/lz4hc.h
+b667033dc735fb5ea5648e0a61a2e065e5ef5bbda53669730063bd856c643c48  vendor/lib/xxhash.c
+aefdd236f35130495c18764cabed3f7b216906855fc5e6a9025cd2040bc84444  vendor/lib/xxhash.h
diff --git a/native/lz4/src/lz4_ffi.c b/native/lz4/src/lz4_ffi.c
new file mode 100644
index 0000000..9b06636
--- /dev/null
+++ b/native/lz4/src/lz4_ffi.c
@@ -0,0 +1,96 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+#include "lz4_ffi.h"
+
+#include <stddef.h>
+
+#include "lz4.h"
+#include "lz4hc.h"
+
+enum {
+  OTADUMP_LZ4_OK = 0,
+  OTADUMP_LZ4_INVALID_ARGUMENT = 1,
+  OTADUMP_LZ4_COMPRESSION_FAILED = 2,
+  OTADUMP_LZ4_DECOMPRESSION_FAILED = 3,
+  OTADUMP_LZ4_ALLOCATION_FAILED = 4,
+};
+
+static otadump_lz4_result make_result(int32_t status, int32_t source_size,
+                                     int32_t output_size) {
+  otadump_lz4_result result = {status, source_size, output_size};
+  return result;
+}
+
+static int buffers_overlap(const uint8_t *source, int32_t source_size,
+                           const uint8_t *output, int32_t output_capacity) {
+  uintptr_t src_start = (uintptr_t)source;
+  uintptr_t src_end = src_start + (size_t)source_size;
+  uintptr_t dst_start = (uintptr_t)output;
+  uintptr_t dst_end = dst_start + (size_t)output_capacity;
+  return src_start < dst_end && dst_start < src_end;
+}
+
+static int valid_buffers(const uint8_t *source, int32_t source_size,
+                         uint8_t *output, int32_t output_capacity) {
+  return source != NULL && output != NULL && source_size > 0 &&
+         output_capacity > 0 && source_size <= LZ4_MAX_INPUT_SIZE &&
+         output_capacity <= LZ4_MAX_INPUT_SIZE &&
+         !buffers_overlap(source, source_size, output, output_capacity);
+}
+
+otadump_lz4_result otadump_lz4_decompress_safe_partial(
+    const uint8_t *source, int32_t source_size, uint8_t *output,
+    int32_t output_capacity, int32_t target_output_size) {
+  int written;
+  if (!valid_buffers(source, source_size, output, output_capacity) ||
+      target_output_size <= 0 || target_output_size > output_capacity) {
+    return make_result(OTADUMP_LZ4_INVALID_ARGUMENT, 0, 0);
+  }
+  written = LZ4_decompress_safe_partial(
+      (const char *)source, (char *)output, source_size, target_output_size,
+      output_capacity);
+  if (written < 0) {
+    return make_result(OTADUMP_LZ4_DECOMPRESSION_FAILED, 0, 0);
+  }
+  return make_result(OTADUMP_LZ4_OK, source_size, written);
+}
+
+otadump_lz4_result otadump_lz4_compress_dest_size(
+    const uint8_t *source, int32_t source_size, uint8_t *output,
+    int32_t output_capacity) {
+  int consumed = source_size;
+  int written;
+  if (!valid_buffers(source, source_size, output, output_capacity)) {
+    return make_result(OTADUMP_LZ4_INVALID_ARGUMENT, 0, 0);
+  }
+  written = LZ4_compress_destSize((const char *)source, (char *)output,
+                                  &consumed, output_capacity);
+  if (written <= 0) {
+    return make_result(OTADUMP_LZ4_COMPRESSION_FAILED, consumed, 0);
+  }
+  return make_result(OTADUMP_LZ4_OK, consumed, written);
+}
+
+otadump_lz4_result otadump_lz4_compress_hc_dest_size(
+    const uint8_t *source, int32_t source_size, uint8_t *output,
+    int32_t output_capacity, int32_t compression_level) {
+  LZ4_streamHC_t *stream;
+  int consumed = source_size;
+  int written;
+  if (!valid_buffers(source, source_size, output, output_capacity) ||
+      compression_level < LZ4HC_CLEVEL_MIN ||
+      compression_level > LZ4HC_CLEVEL_MAX) {
+    return make_result(OTADUMP_LZ4_INVALID_ARGUMENT, 0, 0);
+  }
+  stream = LZ4_createStreamHC();
+  if (stream == NULL) {
+    return make_result(OTADUMP_LZ4_ALLOCATION_FAILED, 0, 0);
+  }
+  written = LZ4_compress_HC_destSize(stream, (const char *)source,
+                                     (char *)output, &consumed,
+                                     output_capacity, compression_level);
+  LZ4_freeStreamHC(stream);
+  if (written <= 0) {
+    return make_result(OTADUMP_LZ4_COMPRESSION_FAILED, consumed, 0);
+  }
+  return make_result(OTADUMP_LZ4_OK, consumed, written);
+}
diff --git a/native/lz4/src/lz4_ffi.h b/native/lz4/src/lz4_ffi.h
new file mode 100644
index 0000000..2f08442
--- /dev/null
+++ b/native/lz4/src/lz4_ffi.h
@@ -0,0 +1,33 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+#ifndef OTADUMP_LZ4_FFI_H
+#define OTADUMP_LZ4_FFI_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  int32_t status;
+  int32_t source_size;
+  int32_t output_size;
+} otadump_lz4_result;
+
+otadump_lz4_result otadump_lz4_decompress_safe_partial(
+    const uint8_t *source, int32_t source_size, uint8_t *output,
+    int32_t output_capacity, int32_t target_output_size);
+
+otadump_lz4_result otadump_lz4_compress_dest_size(
+    const uint8_t *source, int32_t source_size, uint8_t *output,
+    int32_t output_capacity);
+
+otadump_lz4_result otadump_lz4_compress_hc_dest_size(
+    const uint8_t *source, int32_t source_size, uint8_t *output,
+    int32_t output_capacity, int32_t compression_level);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/native/lz4/vendor/lib/lz4.c b/native/lz4/vendor/lib/lz4.c
new file mode 100644
index 0000000..a2f7abe
--- /dev/null
+++ b/native/lz4/vendor/lib/lz4.c
@@ -0,0 +1,2829 @@
+/*
+   LZ4 - Fast LZ compression algorithm
+   Copyright (C) 2011-2023, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+    - LZ4 homepage : http://www.lz4.org
+    - LZ4 source repository : https://github.com/lz4/lz4
+*/
+
+/*-************************************
+*  Tuning parameters
+**************************************/
+/*
+ * LZ4_HEAPMODE :
+ * Select how stateless compression functions like `LZ4_compress_default()`
+ * allocate memory for their hash table,
+ * in memory stack (0:default, fastest), or in memory heap (1:requires malloc()).
+ */
+#ifndef LZ4_HEAPMODE
+#  define LZ4_HEAPMODE 0
+#endif
+
+/*
+ * LZ4_ACCELERATION_DEFAULT :
+ * Select "acceleration" for LZ4_compress_fast() when parameter value <= 0
+ */
+#define LZ4_ACCELERATION_DEFAULT 1
+/*
+ * LZ4_ACCELERATION_MAX :
+ * Any "acceleration" value higher than this threshold
+ * get treated as LZ4_ACCELERATION_MAX instead (fix #876)
+ */
+#define LZ4_ACCELERATION_MAX 65537
+
+
+/*-************************************
+*  CPU Feature Detection
+**************************************/
+/* LZ4_FORCE_MEMORY_ACCESS
+ * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
+ * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
+ * The below switch allow to select different access method for improved performance.
+ * Method 0 (default) : use `memcpy()`. Safe and portable.
+ * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
+ *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
+ * Method 2 : direct access. This method is portable but violate C standard.
+ *            It can generate buggy code on targets which assembly generation depends on alignment.
+ *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
+ * See https://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
+ * Prefer these methods in priority order (0 > 1 > 2)
+ */
+#ifndef LZ4_FORCE_MEMORY_ACCESS   /* can be defined externally */
+#  if defined(__GNUC__) && \
+  ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) \
+  || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
+#    define LZ4_FORCE_MEMORY_ACCESS 2
+#  elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || defined(__GNUC__) || defined(_MSC_VER)
+#    define LZ4_FORCE_MEMORY_ACCESS 1
+#  endif
+#endif
+
+/*
+ * LZ4_FORCE_SW_BITCOUNT
+ * Define this parameter if your target system or compiler does not support hardware bit count
+ */
+#if defined(_MSC_VER) && defined(_WIN32_WCE)   /* Visual Studio for WinCE doesn't support Hardware bit count */
+#  undef  LZ4_FORCE_SW_BITCOUNT  /* avoid double def */
+#  define LZ4_FORCE_SW_BITCOUNT
+#endif
+
+
+
+/*-************************************
+*  Dependency
+**************************************/
+/*
+ * LZ4_SRC_INCLUDED:
+ * Amalgamation flag, whether lz4.c is included
+ */
+#ifndef LZ4_SRC_INCLUDED
+#  define LZ4_SRC_INCLUDED 1
+#endif
+
+#ifndef LZ4_DISABLE_DEPRECATE_WARNINGS
+#  define LZ4_DISABLE_DEPRECATE_WARNINGS /* due to LZ4_decompress_safe_withPrefix64k */
+#endif
+
+#ifndef LZ4_STATIC_LINKING_ONLY
+#  define LZ4_STATIC_LINKING_ONLY
+#endif
+#include "lz4.h"
+/* see also "memory routines" below */
+
+
+/*-************************************
+*  Compiler Options
+**************************************/
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)  /* Visual Studio 2005+ */
+#  include <intrin.h>               /* only present in VS2005+ */
+#  pragma warning(disable : 4127)   /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 6237)   /* disable: C6237: conditional expression is always 0 */
+#  pragma warning(disable : 6239)   /* disable: C6239: (<non-zero constant> && <expression>) always evaluates to the result of <expression> */
+#  pragma warning(disable : 6240)   /* disable: C6240: (<expression> && <non-zero constant>) always evaluates to the result of <expression> */
+#  pragma warning(disable : 6326)   /* disable: C6326: Potential comparison of a constant with another constant */
+#endif  /* _MSC_VER */
+
+#ifndef LZ4_FORCE_INLINE
+#  if defined (_MSC_VER) && !defined (__clang__)    /* MSVC */
+#    define LZ4_FORCE_INLINE static __forceinline
+#  else
+#    if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#      if defined (__GNUC__) || defined (__clang__)
+#        define LZ4_FORCE_INLINE static inline __attribute__((always_inline))
+#      else
+#        define LZ4_FORCE_INLINE static inline
+#      endif
+#    else
+#      define LZ4_FORCE_INLINE static
+#    endif /* __STDC_VERSION__ */
+#  endif  /* _MSC_VER */
+#endif /* LZ4_FORCE_INLINE */
+
+/* LZ4_FORCE_O2 and LZ4_FORCE_INLINE
+ * gcc on ppc64le generates an unrolled SIMDized loop for LZ4_wildCopy8,
+ * together with a simple 8-byte copy loop as a fall-back path.
+ * However, this optimization hurts the decompression speed by >30%,
+ * because the execution does not go to the optimized loop
+ * for typical compressible data, and all of the preamble checks
+ * before going to the fall-back path become useless overhead.
+ * This optimization happens only with the -O3 flag, and -O2 generates
+ * a simple 8-byte copy loop.
+ * With gcc on ppc64le, all of the LZ4_decompress_* and LZ4_wildCopy8
+ * functions are annotated with __attribute__((optimize("O2"))),
+ * and also LZ4_wildCopy8 is forcibly inlined, so that the O2 attribute
+ * of LZ4_wildCopy8 does not affect the compression speed.
+ */
+#if defined(__PPC64__) && defined(__LITTLE_ENDIAN__) && defined(__GNUC__) && !defined(__clang__)
+#  define LZ4_FORCE_O2  __attribute__((optimize("O2")))
+#  undef LZ4_FORCE_INLINE
+#  define LZ4_FORCE_INLINE  static __inline __attribute__((optimize("O2"),always_inline))
+#else
+#  define LZ4_FORCE_O2
+#endif
+
+#if (defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__)
+#  define expect(expr,value)    (__builtin_expect ((expr),(value)) )
+#else
+#  define expect(expr,value)    (expr)
+#endif
+
+#ifndef likely
+#define likely(expr)     expect((expr) != 0, 1)
+#endif
+#ifndef unlikely
+#define unlikely(expr)   expect((expr) != 0, 0)
+#endif
+
+/* Should the alignment test prove unreliable, for some reason,
+ * it can be disabled by setting LZ4_ALIGN_TEST to 0 */
+#ifndef LZ4_ALIGN_TEST  /* can be externally provided */
+# define LZ4_ALIGN_TEST 1
+#endif
+
+
+/*-************************************
+*  Memory routines
+**************************************/
+
+/*! LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION :
+ *  Disable relatively high-level LZ4/HC functions that use dynamic memory
+ *  allocation functions (malloc(), calloc(), free()).
+ *
+ *  Note that this is a compile-time switch. And since it disables
+ *  public/stable LZ4 v1 API functions, we don't recommend using this
+ *  symbol to generate a library for distribution.
+ *
+ *  The following public functions are removed when this symbol is defined.
+ *  - lz4   : LZ4_createStream, LZ4_freeStream,
+ *            LZ4_createStreamDecode, LZ4_freeStreamDecode, LZ4_create (deprecated)
+ *  - lz4hc : LZ4_createStreamHC, LZ4_freeStreamHC,
+ *            LZ4_createHC (deprecated), LZ4_freeHC  (deprecated)
+ *  - lz4frame, lz4file : All LZ4F_* functions
+ */
+#if defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
+#  define ALLOC(s)          lz4_error_memory_allocation_is_disabled
+#  define ALLOC_AND_ZERO(s) lz4_error_memory_allocation_is_disabled
+#  define FREEMEM(p)        lz4_error_memory_allocation_is_disabled
+#elif defined(LZ4_USER_MEMORY_FUNCTIONS)
+/* memory management functions can be customized by user project.
+ * Below functions must exist somewhere in the Project
+ * and be available at link time */
+void* LZ4_malloc(size_t s);
+void* LZ4_calloc(size_t n, size_t s);
+void  LZ4_free(void* p);
+# define ALLOC(s)          LZ4_malloc(s)
+# define ALLOC_AND_ZERO(s) LZ4_calloc(1,s)
+# define FREEMEM(p)        LZ4_free(p)
+#else
+# include <stdlib.h>   /* malloc, calloc, free */
+# define ALLOC(s)          malloc(s)
+# define ALLOC_AND_ZERO(s) calloc(1,s)
+# define FREEMEM(p)        free(p)
+#endif
+
+#if ! LZ4_FREESTANDING
+#  include <string.h>   /* memset, memcpy */
+#endif
+#if !defined(LZ4_memset)
+#  define LZ4_memset(p,v,s) memset((p),(v),(s))
+#endif
+#define MEM_INIT(p,v,s)   LZ4_memset((p),(v),(s))
+
+
+/*-************************************
+*  Common Constants
+**************************************/
+#define MINMATCH 4
+
+#define WILDCOPYLENGTH 8
+#define LASTLITERALS   5   /* see ../doc/lz4_Block_format.md#parsing-restrictions */
+#define MFLIMIT       12   /* see ../doc/lz4_Block_format.md#parsing-restrictions */
+#define MATCH_SAFEGUARD_DISTANCE  ((2*WILDCOPYLENGTH) - MINMATCH)   /* ensure it's possible to write 2 x wildcopyLength without overflowing output buffer */
+#define FASTLOOP_SAFE_DISTANCE 64
+static const int LZ4_minLength = (MFLIMIT+1);
+
+#define KB *(1 <<10)
+#define MB *(1 <<20)
+#define GB *(1U<<30)
+
+#define LZ4_DISTANCE_ABSOLUTE_MAX 65535
+#if (LZ4_DISTANCE_MAX > LZ4_DISTANCE_ABSOLUTE_MAX)   /* max supported by LZ4 format */
+#  error "LZ4_DISTANCE_MAX is too big : must be <= 65535"
+#endif
+
+#define ML_BITS  4
+#define ML_MASK  ((1U<<ML_BITS)-1)
+#define RUN_BITS (8-ML_BITS)
+#define RUN_MASK ((1U<<RUN_BITS)-1)
+
+
+/*-************************************
+*  Error detection
+**************************************/
+#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=1)
+#  include <assert.h>
+#else
+#  ifndef assert
+#    define assert(condition) ((void)0)
+#  endif
+#endif
+
+#define LZ4_STATIC_ASSERT(c)   { enum { LZ4_static_assert = 1/(int)(!!(c)) }; }   /* use after variable declarations */
+
+#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=2)
+#  include <stdio.h>
+   static int g_debuglog_enable = 1;
+#  define DEBUGLOG(l, ...) {                          \
+        if ((g_debuglog_enable) && (l<=LZ4_DEBUG)) {  \
+            fprintf(stderr, __FILE__  " %i: ", __LINE__); \
+            fprintf(stderr, __VA_ARGS__);             \
+            fprintf(stderr, " \n");                   \
+    }   }
+#else
+#  define DEBUGLOG(l, ...) {}    /* disabled */
+#endif
+
+static int LZ4_isAligned(const void* ptr, size_t alignment)
+{
+    return ((size_t)ptr & (alignment -1)) == 0;
+}
+
+
+/*-************************************
+*  Types
+**************************************/
+#include <limits.h>
+#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+# include <stdint.h>
+  typedef  uint8_t BYTE;
+  typedef uint16_t U16;
+  typedef uint32_t U32;
+  typedef  int32_t S32;
+  typedef uint64_t U64;
+  typedef uintptr_t uptrval;
+#else
+# if UINT_MAX != 4294967295UL
+#   error "LZ4 code (when not C++ or C99) assumes that sizeof(int) == 4"
+# endif
+  typedef unsigned char       BYTE;
+  typedef unsigned short      U16;
+  typedef unsigned int        U32;
+  typedef   signed int        S32;
+  typedef unsigned long long  U64;
+  typedef size_t              uptrval;   /* generally true, except OpenVMS-64 */
+#endif
+
+#if defined(__x86_64__)
+  typedef U64    reg_t;   /* 64-bits in x32 mode */
+#else
+  typedef size_t reg_t;   /* 32-bits in x32 mode */
+#endif
+
+typedef enum {
+    notLimited = 0,
+    limitedOutput = 1,
+    fillOutput = 2
+} limitedOutput_directive;
+
+
+/*-************************************
+*  Reading and writing into memory
+**************************************/
+
+/**
+ * LZ4 relies on memcpy with a constant size being inlined. In freestanding
+ * environments, the compiler can't assume the implementation of memcpy() is
+ * standard compliant, so it can't apply its specialized memcpy() inlining
+ * logic. When possible, use __builtin_memcpy() to tell the compiler to analyze
+ * memcpy() as if it were standard compliant, so it can inline it in freestanding
+ * environments. This is needed when decompressing the Linux Kernel, for example.
+ */
+#if !defined(LZ4_memcpy)
+#  if defined(__GNUC__) && (__GNUC__ >= 4)
+#    define LZ4_memcpy(dst, src, size) __builtin_memcpy(dst, src, size)
+#  else
+#    define LZ4_memcpy(dst, src, size) memcpy(dst, src, size)
+#  endif
+#endif
+
+#if !defined(LZ4_memmove)
+#  if defined(__GNUC__) && (__GNUC__ >= 4)
+#    define LZ4_memmove __builtin_memmove
+#  else
+#    define LZ4_memmove memmove
+#  endif
+#endif
+
+static unsigned LZ4_isLittleEndian(void)
+{
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental */
+    return one.c[0];
+}
+
+#if defined(__GNUC__) || defined(__INTEL_COMPILER)
+#define LZ4_PACK( __Declaration__ ) __Declaration__ __attribute__((__packed__))
+#elif defined(_MSC_VER)
+#define LZ4_PACK( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop))
+#endif
+
+#if defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==2)
+/* lie to the compiler about data alignment; use with caution */
+
+static U16 LZ4_read16(const void* memPtr) { return *(const U16*) memPtr; }
+static U32 LZ4_read32(const void* memPtr) { return *(const U32*) memPtr; }
+static reg_t LZ4_read_ARCH(const void* memPtr) { return *(const reg_t*) memPtr; }
+
+static void LZ4_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
+static void LZ4_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
+
+#elif defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==1)
+
+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
+/* currently only defined for gcc and icc */
+LZ4_PACK(typedef struct { U16 u16; }) LZ4_unalign16;
+LZ4_PACK(typedef struct { U32 u32; }) LZ4_unalign32;
+LZ4_PACK(typedef struct { reg_t uArch; }) LZ4_unalignST;
+
+static U16 LZ4_read16(const void* ptr) { return ((const LZ4_unalign16*)ptr)->u16; }
+static U32 LZ4_read32(const void* ptr) { return ((const LZ4_unalign32*)ptr)->u32; }
+static reg_t LZ4_read_ARCH(const void* ptr) { return ((const LZ4_unalignST*)ptr)->uArch; }
+
+static void LZ4_write16(void* memPtr, U16 value) { ((LZ4_unalign16*)memPtr)->u16 = value; }
+static void LZ4_write32(void* memPtr, U32 value) { ((LZ4_unalign32*)memPtr)->u32 = value; }
+
+#else  /* safe and portable access using memcpy() */
+
+static U16 LZ4_read16(const void* memPtr)
+{
+    U16 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+static U32 LZ4_read32(const void* memPtr)
+{
+    U32 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+static reg_t LZ4_read_ARCH(const void* memPtr)
+{
+    reg_t val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+static void LZ4_write16(void* memPtr, U16 value)
+{
+    LZ4_memcpy(memPtr, &value, sizeof(value));
+}
+
+static void LZ4_write32(void* memPtr, U32 value)
+{
+    LZ4_memcpy(memPtr, &value, sizeof(value));
+}
+
+#endif /* LZ4_FORCE_MEMORY_ACCESS */
+
+
+static U16 LZ4_readLE16(const void* memPtr)
+{
+    if (LZ4_isLittleEndian()) {
+        return LZ4_read16(memPtr);
+    } else {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U16)((U16)p[0] | (p[1]<<8));
+    }
+}
+
+#ifdef LZ4_STATIC_LINKING_ONLY_ENDIANNESS_INDEPENDENT_OUTPUT
+static U32 LZ4_readLE32(const void* memPtr)
+{
+    if (LZ4_isLittleEndian()) {
+        return LZ4_read32(memPtr);
+    } else {
+        const BYTE* p = (const BYTE*)memPtr;
+        return (U32)p[0] | (p[1]<<8) | (p[2]<<16) | (p[3]<<24);
+    }
+}
+#endif
+
+static void LZ4_writeLE16(void* memPtr, U16 value)
+{
+    if (LZ4_isLittleEndian()) {
+        LZ4_write16(memPtr, value);
+    } else {
+        BYTE* p = (BYTE*)memPtr;
+        p[0] = (BYTE) value;
+        p[1] = (BYTE)(value>>8);
+    }
+}
+
+/* customized variant of memcpy, which can overwrite up to 8 bytes beyond dstEnd */
+LZ4_FORCE_INLINE
+void LZ4_wildCopy8(void* dstPtr, const void* srcPtr, void* dstEnd)
+{
+    BYTE* d = (BYTE*)dstPtr;
+    const BYTE* s = (const BYTE*)srcPtr;
+    BYTE* const e = (BYTE*)dstEnd;
+
+    do { LZ4_memcpy(d,s,8); d+=8; s+=8; } while (d<e);
+}
+
+static const unsigned inc32table[8] = {0, 1, 2,  1,  0,  4, 4, 4};
+static const int      dec64table[8] = {0, 0, 0, -1, -4,  1, 2, 3};
+
+
+#ifndef LZ4_FAST_DEC_LOOP
+#  if defined __i386__ || defined _M_IX86 || defined __x86_64__ || defined _M_X64
+#    define LZ4_FAST_DEC_LOOP 1
+#  elif defined(__aarch64__) && defined(__APPLE__)
+#    define LZ4_FAST_DEC_LOOP 1
+#  elif defined(__aarch64__) && !defined(__clang__)
+     /* On non-Apple aarch64, we disable this optimization for clang because
+      * on certain mobile chipsets, performance is reduced with clang. For
+      * more information refer to https://github.com/lz4/lz4/pull/707 */
+#    define LZ4_FAST_DEC_LOOP 1
+#  else
+#    define LZ4_FAST_DEC_LOOP 0
+#  endif
+#endif
+
+#if LZ4_FAST_DEC_LOOP
+
+LZ4_FORCE_INLINE void
+LZ4_memcpy_using_offset_base(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
+{
+    assert(srcPtr + offset == dstPtr);
+    if (offset < 8) {
+        LZ4_write32(dstPtr, 0);   /* silence an msan warning when offset==0 */
+        dstPtr[0] = srcPtr[0];
+        dstPtr[1] = srcPtr[1];
+        dstPtr[2] = srcPtr[2];
+        dstPtr[3] = srcPtr[3];
+        srcPtr += inc32table[offset];
+        LZ4_memcpy(dstPtr+4, srcPtr, 4);
+        srcPtr -= dec64table[offset];
+        dstPtr += 8;
+    } else {
+        LZ4_memcpy(dstPtr, srcPtr, 8);
+        dstPtr += 8;
+        srcPtr += 8;
+    }
+
+    LZ4_wildCopy8(dstPtr, srcPtr, dstEnd);
+}
+
+/* customized variant of memcpy, which can overwrite up to 32 bytes beyond dstEnd
+ * this version copies two times 16 bytes (instead of one time 32 bytes)
+ * because it must be compatible with offsets >= 16. */
+LZ4_FORCE_INLINE void
+LZ4_wildCopy32(void* dstPtr, const void* srcPtr, void* dstEnd)
+{
+    BYTE* d = (BYTE*)dstPtr;
+    const BYTE* s = (const BYTE*)srcPtr;
+    BYTE* const e = (BYTE*)dstEnd;
+
+    do { LZ4_memcpy(d,s,16); LZ4_memcpy(d+16,s+16,16); d+=32; s+=32; } while (d<e);
+}
+
+/* LZ4_memcpy_using_offset()  presumes :
+ * - dstEnd >= dstPtr + MINMATCH
+ * - there is at least 12 bytes available to write after dstEnd */
+LZ4_FORCE_INLINE void
+LZ4_memcpy_using_offset(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
+{
+    BYTE v[8];
+
+    assert(dstEnd >= dstPtr + MINMATCH);
+
+    switch(offset) {
+    case 1:
+        MEM_INIT(v, *srcPtr, 8);
+        break;
+    case 2:
+        LZ4_memcpy(v, srcPtr, 2);
+        LZ4_memcpy(&v[2], srcPtr, 2);
+#if defined(_MSC_VER) && (_MSC_VER <= 1937) /* MSVC 2022 ver 17.7 or earlier */
+#  pragma warning(push)
+#  pragma warning(disable : 6385) /* warning C6385: Reading invalid data from 'v'. */
+#endif
+        LZ4_memcpy(&v[4], v, 4);
+#if defined(_MSC_VER) && (_MSC_VER <= 1937) /* MSVC 2022 ver 17.7 or earlier */
+#  pragma warning(pop)
+#endif
+        break;
+    case 4:
+        LZ4_memcpy(v, srcPtr, 4);
+        LZ4_memcpy(&v[4], srcPtr, 4);
+        break;
+    default:
+        LZ4_memcpy_using_offset_base(dstPtr, srcPtr, dstEnd, offset);
+        return;
+    }
+
+    LZ4_memcpy(dstPtr, v, 8);
+    dstPtr += 8;
+    while (dstPtr < dstEnd) {
+        LZ4_memcpy(dstPtr, v, 8);
+        dstPtr += 8;
+    }
+}
+#endif
+
+
+/*-************************************
+*  Common functions
+**************************************/
+static unsigned LZ4_NbCommonBytes (reg_t val)
+{
+    assert(val != 0);
+    if (LZ4_isLittleEndian()) {
+        if (sizeof(val) == 8) {
+#       if defined(_MSC_VER) && (_MSC_VER >= 1800) && (defined(_M_AMD64) && !defined(_M_ARM64EC)) && !defined(LZ4_FORCE_SW_BITCOUNT)
+/*-*************************************************************************************************
+* ARM64EC is a Microsoft-designed ARM64 ABI compatible with AMD64 applications on ARM64 Windows 11.
+* The ARM64EC ABI does not support AVX/AVX2/AVX512 instructions, nor their relevant intrinsics
+* including _tzcnt_u64. Therefore, we need to neuter the _tzcnt_u64 code path for ARM64EC.
+****************************************************************************************************/
+#         if defined(__clang__) && (__clang_major__ < 10)
+            /* Avoid undefined clang-cl intrinsics issue.
+             * See https://github.com/lz4/lz4/pull/1017 for details. */
+            return (unsigned)__builtin_ia32_tzcnt_u64(val) >> 3;
+#         else
+            /* x64 CPUS without BMI support interpret `TZCNT` as `REP BSF` */
+            return (unsigned)_tzcnt_u64(val) >> 3;
+#         endif
+#       elif defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
+            unsigned long r = 0;
+            _BitScanForward64(&r, (U64)val);
+            return (unsigned)r >> 3;
+#       elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
+                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
+                                        !defined(LZ4_FORCE_SW_BITCOUNT)
+            return (unsigned)__builtin_ctzll((U64)val) >> 3;
+#       else
+            const U64 m = 0x0101010101010101ULL;
+            val ^= val - 1;
+            return (unsigned)(((U64)((val & (m - 1)) * m)) >> 56);
+#       endif
+        } else /* 32 bits */ {
+#       if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(LZ4_FORCE_SW_BITCOUNT)
+            unsigned long r;
+            _BitScanForward(&r, (U32)val);
+            return (unsigned)r >> 3;
+#       elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
+                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
+                        !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT)
+            return (unsigned)__builtin_ctz((U32)val) >> 3;
+#       else
+            const U32 m = 0x01010101;
+            return (unsigned)((((val - 1) ^ val) & (m - 1)) * m) >> 24;
+#       endif
+        }
+    } else   /* Big Endian CPU */ {
+        if (sizeof(val)==8) {
+#       if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
+                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
+                        !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT)
+            return (unsigned)__builtin_clzll((U64)val) >> 3;
+#       else
+#if 1
+            /* this method is probably faster,
+             * but adds a 128 bytes lookup table */
+            static const unsigned char ctz7_tab[128] = {
+                7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
+            };
+            U64 const mask = 0x0101010101010101ULL;
+            U64 const t = (((val >> 8) - mask) | val) & mask;
+            return ctz7_tab[(t * 0x0080402010080402ULL) >> 57];
+#else
+            /* this method doesn't consume memory space like the previous one,
+             * but it contains several branches,
+             * that may end up slowing execution */
+            static const U32 by32 = sizeof(val)*4;  /* 32 on 64 bits (goal), 16 on 32 bits.
+            Just to avoid some static analyzer complaining about shift by 32 on 32-bits target.
+            Note that this code path is never triggered in 32-bits mode. */
+            unsigned r;
+            if (!(val>>by32)) { r=4; } else { r=0; val>>=by32; }
+            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
+            r += (!val);
+            return r;
+#endif
+#       endif
+        } else /* 32 bits */ {
+#       if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
+                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
+                                        !defined(LZ4_FORCE_SW_BITCOUNT)
+            return (unsigned)__builtin_clz((U32)val) >> 3;
+#       else
+            val >>= 8;
+            val = ((((val + 0x00FFFF00) | 0x00FFFFFF) + val) |
+              (val + 0x00FF0000)) >> 24;
+            return (unsigned)val ^ 3;
+#       endif
+        }
+    }
+}
+
+
+#define STEPSIZE sizeof(reg_t)
+LZ4_FORCE_INLINE
+unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
+{
+    const BYTE* const pStart = pIn;
+
+    if (likely(pIn < pInLimit-(STEPSIZE-1))) {
+        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
+        if (!diff) {
+            pIn+=STEPSIZE; pMatch+=STEPSIZE;
+        } else {
+            return LZ4_NbCommonBytes(diff);
+    }   }
+
+    while (likely(pIn < pInLimit-(STEPSIZE-1))) {
+        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
+        if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }
+        pIn += LZ4_NbCommonBytes(diff);
+        return (unsigned)(pIn - pStart);
+    }
+
+    if ((STEPSIZE==8) && (pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; }
+    if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; }
+    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
+    return (unsigned)(pIn - pStart);
+}
+
+
+#ifndef LZ4_COMMONDEFS_ONLY
+/*-************************************
+*  Local Constants
+**************************************/
+static const int LZ4_64Klimit = ((64 KB) + (MFLIMIT-1));
+static const U32 LZ4_skipTrigger = 6;  /* Increase this value ==> compression run slower on incompressible data */
+
+
+/*-************************************
+*  Local Structures and types
+**************************************/
+typedef enum { clearedTable = 0, byPtr, byU32, byU16 } tableType_t;
+
+/**
+ * This enum distinguishes several different modes of accessing previous
+ * content in the stream.
+ *
+ * - noDict        : There is no preceding content.
+ * - withPrefix64k : Table entries up to ctx->dictSize before the current blob
+ *                   blob being compressed are valid and refer to the preceding
+ *                   content (of length ctx->dictSize), which is available
+ *                   contiguously preceding in memory the content currently
+ *                   being compressed.
+ * - usingExtDict  : Like withPrefix64k, but the preceding content is somewhere
+ *                   else in memory, starting at ctx->dictionary with length
+ *                   ctx->dictSize.
+ * - usingDictCtx  : Everything concerning the preceding content is
+ *                   in a separate context, pointed to by ctx->dictCtx.
+ *                   ctx->dictionary, ctx->dictSize, and table entries
+ *                   in the current context that refer to positions
+ *                   preceding the beginning of the current compression are
+ *                   ignored. Instead, ctx->dictCtx->dictionary and ctx->dictCtx
+ *                   ->dictSize describe the location and size of the preceding
+ *                   content, and matches are found by looking in the ctx
+ *                   ->dictCtx->hashTable.
+ */
+typedef enum { noDict = 0, withPrefix64k, usingExtDict, usingDictCtx } dict_directive;
+typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive;
+
+
+/*-************************************
+*  Local Utils
+**************************************/
+int LZ4_versionNumber (void) { return LZ4_VERSION_NUMBER; }
+const char* LZ4_versionString(void) { return LZ4_VERSION_STRING; }
+int LZ4_compressBound(int isize)  { return LZ4_COMPRESSBOUND(isize); }
+int LZ4_sizeofState(void) { return sizeof(LZ4_stream_t); }
+
+
+/*-****************************************
+*  Internal Definitions, used only in Tests
+*******************************************/
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize);
+
+int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,
+                                     int compressedSize, int maxOutputSize,
+                                     const void* dictStart, size_t dictSize);
+int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest,
+                                     int compressedSize, int targetOutputSize, int dstCapacity,
+                                     const void* dictStart, size_t dictSize);
+#if defined (__cplusplus)
+}
+#endif
+
+/*-******************************
+*  Compression functions
+********************************/
+LZ4_FORCE_INLINE U32 LZ4_hash4(U32 sequence, tableType_t const tableType)
+{
+    if (tableType == byU16)
+        return ((sequence * 2654435761U) >> ((MINMATCH*8)-(LZ4_HASHLOG+1)));
+    else
+        return ((sequence * 2654435761U) >> ((MINMATCH*8)-LZ4_HASHLOG));
+}
+
+LZ4_FORCE_INLINE U32 LZ4_hash5(U64 sequence, tableType_t const tableType)
+{
+    const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG;
+    if (LZ4_isLittleEndian()) {
+        const U64 prime5bytes = 889523592379ULL;
+        return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog));
+    } else {
+        const U64 prime8bytes = 11400714785074694791ULL;
+        return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog));
+    }
+}
+
+LZ4_FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType)
+{
+    if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType);
+
+#ifdef LZ4_STATIC_LINKING_ONLY_ENDIANNESS_INDEPENDENT_OUTPUT
+    return LZ4_hash4(LZ4_readLE32(p), tableType);
+#else
+    return LZ4_hash4(LZ4_read32(p), tableType);
+#endif
+}
+
+LZ4_FORCE_INLINE void LZ4_clearHash(U32 h, void* tableBase, tableType_t const tableType)
+{
+    switch (tableType)
+    {
+    default: /* fallthrough */
+    case clearedTable: { /* illegal! */ assert(0); return; }
+    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = NULL; return; }
+    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = 0; return; }
+    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = 0; return; }
+    }
+}
+
+LZ4_FORCE_INLINE void LZ4_putIndexOnHash(U32 idx, U32 h, void* tableBase, tableType_t const tableType)
+{
+    switch (tableType)
+    {
+    default: /* fallthrough */
+    case clearedTable: /* fallthrough */
+    case byPtr: { /* illegal! */ assert(0); return; }
+    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = idx; return; }
+    case byU16: { U16* hashTable = (U16*) tableBase; assert(idx < 65536); hashTable[h] = (U16)idx; return; }
+    }
+}
+
+/* LZ4_putPosition*() : only used in byPtr mode */
+LZ4_FORCE_INLINE void LZ4_putPositionOnHash(const BYTE* p, U32 h,
+                                  void* tableBase, tableType_t const tableType)
+{
+    const BYTE** const hashTable = (const BYTE**)tableBase;
+    assert(tableType == byPtr); (void)tableType;
+    hashTable[h] = p;
+}
+
+LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType)
+{
+    U32 const h = LZ4_hashPosition(p, tableType);
+    LZ4_putPositionOnHash(p, h, tableBase, tableType);
+}
+
+/* LZ4_getIndexOnHash() :
+ * Index of match position registered in hash table.
+ * hash position must be calculated by using base+index, or dictBase+index.
+ * Assumption 1 : only valid if tableType == byU32 or byU16.
+ * Assumption 2 : h is presumed valid (within limits of hash table)
+ */
+LZ4_FORCE_INLINE U32 LZ4_getIndexOnHash(U32 h, const void* tableBase, tableType_t tableType)
+{
+    LZ4_STATIC_ASSERT(LZ4_MEMORY_USAGE > 2);
+    if (tableType == byU32) {
+        const U32* const hashTable = (const U32*) tableBase;
+        assert(h < (1U << (LZ4_MEMORY_USAGE-2)));
+        return hashTable[h];
+    }
+    if (tableType == byU16) {
+        const U16* const hashTable = (const U16*) tableBase;
+        assert(h < (1U << (LZ4_MEMORY_USAGE-1)));
+        return hashTable[h];
+    }
+    assert(0); return 0;  /* forbidden case */
+}
+
+static const BYTE* LZ4_getPositionOnHash(U32 h, const void* tableBase, tableType_t tableType)
+{
+    assert(tableType == byPtr); (void)tableType;
+    { const BYTE* const* hashTable = (const BYTE* const*) tableBase; return hashTable[h]; }
+}
+
+LZ4_FORCE_INLINE const BYTE*
+LZ4_getPosition(const BYTE* p,
+                const void* tableBase, tableType_t tableType)
+{
+    U32 const h = LZ4_hashPosition(p, tableType);
+    return LZ4_getPositionOnHash(h, tableBase, tableType);
+}
+
+LZ4_FORCE_INLINE void
+LZ4_prepareTable(LZ4_stream_t_internal* const cctx,
+           const int inputSize,
+           const tableType_t tableType) {
+    /* If the table hasn't been used, it's guaranteed to be zeroed out, and is
+     * therefore safe to use no matter what mode we're in. Otherwise, we figure
+     * out if it's safe to leave as is or whether it needs to be reset.
+     */
+    if ((tableType_t)cctx->tableType != clearedTable) {
+        assert(inputSize >= 0);
+        if ((tableType_t)cctx->tableType != tableType
+          || ((tableType == byU16) && cctx->currentOffset + (unsigned)inputSize >= 0xFFFFU)
+          || ((tableType == byU32) && cctx->currentOffset > 1 GB)
+          || tableType == byPtr
+          || inputSize >= 4 KB)
+        {
+            DEBUGLOG(4, "LZ4_prepareTable: Resetting table in %p", cctx);
+            MEM_INIT(cctx->hashTable, 0, LZ4_HASHTABLESIZE);
+            cctx->currentOffset = 0;
+            cctx->tableType = (U32)clearedTable;
+        } else {
+            DEBUGLOG(4, "LZ4_prepareTable: Re-use hash table (no reset)");
+        }
+    }
+
+    /* Adding a gap, so all previous entries are > LZ4_DISTANCE_MAX back,
+     * is faster than compressing without a gap.
+     * However, compressing with currentOffset == 0 is faster still,
+     * so we preserve that case.
+     */
+    if (cctx->currentOffset != 0 && tableType == byU32) {
+        DEBUGLOG(5, "LZ4_prepareTable: adding 64KB to currentOffset");
+        cctx->currentOffset += 64 KB;
+    }
+
+    /* Finally, clear history */
+    cctx->dictCtx = NULL;
+    cctx->dictionary = NULL;
+    cctx->dictSize = 0;
+}
+
+/** LZ4_compress_generic_validated() :
+ *  inlined, to ensure branches are decided at compilation time.
+ *  The following conditions are presumed already validated:
+ *  - source != NULL
+ *  - inputSize > 0
+ */
+LZ4_FORCE_INLINE int LZ4_compress_generic_validated(
+                 LZ4_stream_t_internal* const cctx,
+                 const char* const source,
+                 char* const dest,
+                 const int inputSize,
+                 int*  inputConsumed, /* only written when outputDirective == fillOutput */
+                 const int maxOutputSize,
+                 const limitedOutput_directive outputDirective,
+                 const tableType_t tableType,
+                 const dict_directive dictDirective,
+                 const dictIssue_directive dictIssue,
+                 const int acceleration)
+{
+    int result;
+    const BYTE* ip = (const BYTE*)source;
+
+    U32 const startIndex = cctx->currentOffset;
+    const BYTE* base = (const BYTE*)source - startIndex;
+    const BYTE* lowLimit;
+
+    const LZ4_stream_t_internal* dictCtx = (const LZ4_stream_t_internal*) cctx->dictCtx;
+    const BYTE* const dictionary =
+        dictDirective == usingDictCtx ? dictCtx->dictionary : cctx->dictionary;
+    const U32 dictSize =
+        dictDirective == usingDictCtx ? dictCtx->dictSize : cctx->dictSize;
+    const U32 dictDelta =
+        (dictDirective == usingDictCtx) ? startIndex - dictCtx->currentOffset : 0;   /* make indexes in dictCtx comparable with indexes in current context */
+
+    int const maybe_extMem = (dictDirective == usingExtDict) || (dictDirective == usingDictCtx);
+    U32 const prefixIdxLimit = startIndex - dictSize;   /* used when dictDirective == dictSmall */
+    const BYTE* const dictEnd = dictionary ? dictionary + dictSize : dictionary;
+    const BYTE* anchor = (const BYTE*) source;
+    const BYTE* const iend = ip + inputSize;
+    const BYTE* const mflimitPlusOne = iend - MFLIMIT + 1;
+    const BYTE* const matchlimit = iend - LASTLITERALS;
+
+    /* the dictCtx currentOffset is indexed on the start of the dictionary,
+     * while a dictionary in the current context precedes the currentOffset */
+    const BYTE* dictBase = (dictionary == NULL) ? NULL :
+                           (dictDirective == usingDictCtx) ?
+                            dictionary + dictSize - dictCtx->currentOffset :
+                            dictionary + dictSize - startIndex;
+
+    BYTE* op = (BYTE*) dest;
+    BYTE* const olimit = op + maxOutputSize;
+
+    U32 offset = 0;
+    U32 forwardH;
+
+    DEBUGLOG(5, "LZ4_compress_generic_validated: srcSize=%i, tableType=%u", inputSize, tableType);
+    assert(ip != NULL);
+    if (tableType == byU16) assert(inputSize<LZ4_64Klimit);  /* Size too large (not within 64K limit) */
+    if (tableType == byPtr) assert(dictDirective==noDict);   /* only supported use case with byPtr */
+    /* If init conditions are not met, we don't have to mark stream
+     * as having dirty context, since no action was taken yet */
+    if (outputDirective == fillOutput && maxOutputSize < 1) { return 0; } /* Impossible to store anything */
+    assert(acceleration >= 1);
+
+    lowLimit = (const BYTE*)source - (dictDirective == withPrefix64k ? dictSize : 0);
+
+    /* Update context state */
+    if (dictDirective == usingDictCtx) {
+        /* Subsequent linked blocks can't use the dictionary. */
+        /* Instead, they use the block we just compressed. */
+        cctx->dictCtx = NULL;
+        cctx->dictSize = (U32)inputSize;
+    } else {
+        cctx->dictSize += (U32)inputSize;
+    }
+    cctx->currentOffset += (U32)inputSize;
+    cctx->tableType = (U32)tableType;
+
+    if (inputSize<LZ4_minLength) goto _last_literals;        /* Input too small, no compression (all literals) */
+
+    /* First Byte */
+    {   U32 const h = LZ4_hashPosition(ip, tableType);
+        if (tableType == byPtr) {
+            LZ4_putPositionOnHash(ip, h, cctx->hashTable, byPtr);
+        } else {
+            LZ4_putIndexOnHash(startIndex, h, cctx->hashTable, tableType);
+    }   }
+    ip++; forwardH = LZ4_hashPosition(ip, tableType);
+
+    /* Main Loop */
+    for ( ; ; ) {
+        const BYTE* match;
+        BYTE* token;
+        const BYTE* filledIp;
+
+        /* Find a match */
+        if (tableType == byPtr) {
+            const BYTE* forwardIp = ip;
+            int step = 1;
+            int searchMatchNb = acceleration << LZ4_skipTrigger;
+            do {
+                U32 const h = forwardH;
+                ip = forwardIp;
+                forwardIp += step;
+                step = (searchMatchNb++ >> LZ4_skipTrigger);
+
+                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
+                assert(ip < mflimitPlusOne);
+
+                match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType);
+                forwardH = LZ4_hashPosition(forwardIp, tableType);
+                LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType);
+
+            } while ( (match+LZ4_DISTANCE_MAX < ip)
+                   || (LZ4_read32(match) != LZ4_read32(ip)) );
+
+        } else {   /* byU32, byU16 */
+
+            const BYTE* forwardIp = ip;
+            int step = 1;
+            int searchMatchNb = acceleration << LZ4_skipTrigger;
+            do {
+                U32 const h = forwardH;
+                U32 const current = (U32)(forwardIp - base);
+                U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
+                assert(matchIndex <= current);
+                assert(forwardIp - base < (ptrdiff_t)(2 GB - 1));
+                ip = forwardIp;
+                forwardIp += step;
+                step = (searchMatchNb++ >> LZ4_skipTrigger);
+
+                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
+                assert(ip < mflimitPlusOne);
+
+                if (dictDirective == usingDictCtx) {
+                    if (matchIndex < startIndex) {
+                        /* there was no match, try the dictionary */
+                        assert(tableType == byU32);
+                        matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
+                        match = dictBase + matchIndex;
+                        matchIndex += dictDelta;   /* make dictCtx index comparable with current context */
+                        lowLimit = dictionary;
+                    } else {
+                        match = base + matchIndex;
+                        lowLimit = (const BYTE*)source;
+                    }
+                } else if (dictDirective == usingExtDict) {
+                    if (matchIndex < startIndex) {
+                        DEBUGLOG(7, "extDict candidate: matchIndex=%5u  <  startIndex=%5u", matchIndex, startIndex);
+                        assert(startIndex - matchIndex >= MINMATCH);
+                        assert(dictBase);
+                        match = dictBase + matchIndex;
+                        lowLimit = dictionary;
+                    } else {
+                        match = base + matchIndex;
+                        lowLimit = (const BYTE*)source;
+                    }
+                } else {   /* single continuous memory segment */
+                    match = base + matchIndex;
+                }
+                forwardH = LZ4_hashPosition(forwardIp, tableType);
+                LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
+
+                DEBUGLOG(7, "candidate at pos=%u  (offset=%u \n", matchIndex, current - matchIndex);
+                if ((dictIssue == dictSmall) && (matchIndex < prefixIdxLimit)) { continue; }    /* match outside of valid area */
+                assert(matchIndex < current);
+                if ( ((tableType != byU16) || (LZ4_DISTANCE_MAX < LZ4_DISTANCE_ABSOLUTE_MAX))
+                  && (matchIndex+LZ4_DISTANCE_MAX < current)) {
+                    continue;
+                } /* too far */
+                assert((current - matchIndex) <= LZ4_DISTANCE_MAX);  /* match now expected within distance */
+
+                if (LZ4_read32(match) == LZ4_read32(ip)) {
+                    if (maybe_extMem) offset = current - matchIndex;
+                    break;   /* match found */
+                }
+
+            } while(1);
+        }
+
+        /* Catch up */
+        filledIp = ip;
+        assert(ip > anchor); /* this is always true as ip has been advanced before entering the main loop */
+        if ((match > lowLimit) && unlikely(ip[-1] == match[-1])) {
+            do { ip--; match--; } while (((ip > anchor) & (match > lowLimit)) && (unlikely(ip[-1] == match[-1])));
+        }
+
+        /* Encode Literals */
+        {   unsigned const litLength = (unsigned)(ip - anchor);
+            token = op++;
+            if ((outputDirective == limitedOutput) &&  /* Check output buffer overflow */
+                (unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength/255) > olimit)) ) {
+                return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
+            }
+            if ((outputDirective == fillOutput) &&
+                (unlikely(op + (litLength+240)/255 /* litlen */ + litLength /* literals */ + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit))) {
+                op--;
+                goto _last_literals;
+            }
+            if (litLength >= RUN_MASK) {
+                unsigned len = litLength - RUN_MASK;
+                *token = (RUN_MASK<<ML_BITS);
+                for(; len >= 255 ; len-=255) *op++ = 255;
+                *op++ = (BYTE)len;
+            }
+            else *token = (BYTE)(litLength<<ML_BITS);
+
+            /* Copy Literals */
+            LZ4_wildCopy8(op, anchor, op+litLength);
+            op+=litLength;
+            DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
+                        (int)(anchor-(const BYTE*)source), litLength, (int)(ip-(const BYTE*)source));
+        }
+
+_next_match:
+        /* at this stage, the following variables must be correctly set :
+         * - ip : at start of LZ operation
+         * - match : at start of previous pattern occurrence; can be within current prefix, or within extDict
+         * - offset : if maybe_ext_memSegment==1 (constant)
+         * - lowLimit : must be == dictionary to mean "match is within extDict"; must be == source otherwise
+         * - token and *token : position to write 4-bits for match length; higher 4-bits for literal length supposed already written
+         */
+
+        if ((outputDirective == fillOutput) &&
+            (op + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit)) {
+            /* the match was too close to the end, rewind and go to last literals */
+            op = token;
+            goto _last_literals;
+        }
+
+        /* Encode Offset */
+        if (maybe_extMem) {   /* static test */
+            DEBUGLOG(6, "             with offset=%u  (ext if > %i)", offset, (int)(ip - (const BYTE*)source));
+            assert(offset <= LZ4_DISTANCE_MAX && offset > 0);
+            LZ4_writeLE16(op, (U16)offset); op+=2;
+        } else  {
+            DEBUGLOG(6, "             with offset=%u  (same segment)", (U32)(ip - match));
+            assert(ip-match <= LZ4_DISTANCE_MAX);
+            LZ4_writeLE16(op, (U16)(ip - match)); op+=2;
+        }
+
+        /* Encode MatchLength */
+        {   unsigned matchCode;
+
+            if ( (dictDirective==usingExtDict || dictDirective==usingDictCtx)
+              && (lowLimit==dictionary) /* match within extDict */ ) {
+                const BYTE* limit = ip + (dictEnd-match);
+                assert(dictEnd > match);
+                if (limit > matchlimit) limit = matchlimit;
+                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, limit);
+                ip += (size_t)matchCode + MINMATCH;
+                if (ip==limit) {
+                    unsigned const more = LZ4_count(limit, (const BYTE*)source, matchlimit);
+                    matchCode += more;
+                    ip += more;
+                }
+                DEBUGLOG(6, "             with matchLength=%u starting in extDict", matchCode+MINMATCH);
+            } else {
+                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
+                ip += (size_t)matchCode + MINMATCH;
+                DEBUGLOG(6, "             with matchLength=%u", matchCode+MINMATCH);
+            }
+
+            if ((outputDirective) &&    /* Check output buffer overflow */
+                (unlikely(op + (1 + LASTLITERALS) + (matchCode+240)/255 > olimit)) ) {
+                if (outputDirective == fillOutput) {
+                    /* Match description too long : reduce it */
+                    U32 newMatchCode = 15 /* in token */ - 1 /* to avoid needing a zero byte */ + ((U32)(olimit - op) - 1 - LASTLITERALS) * 255;
+                    ip -= matchCode - newMatchCode;
+                    assert(newMatchCode < matchCode);
+                    matchCode = newMatchCode;
+                    if (unlikely(ip <= filledIp)) {
+                        /* We have already filled up to filledIp so if ip ends up less than filledIp
+                         * we have positions in the hash table beyond the current position. This is
+                         * a problem if we reuse the hash table. So we have to remove these positions
+                         * from the hash table.
+                         */
+                        const BYTE* ptr;
+                        DEBUGLOG(5, "Clearing %u positions", (U32)(filledIp - ip));
+                        for (ptr = ip; ptr <= filledIp; ++ptr) {
+                            U32 const h = LZ4_hashPosition(ptr, tableType);
+                            LZ4_clearHash(h, cctx->hashTable, tableType);
+                        }
+                    }
+                } else {
+                    assert(outputDirective == limitedOutput);
+                    return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
+                }
+            }
+            if (matchCode >= ML_MASK) {
+                *token += ML_MASK;
+                matchCode -= ML_MASK;
+                LZ4_write32(op, 0xFFFFFFFF);
+                while (matchCode >= 4*255) {
+                    op+=4;
+                    LZ4_write32(op, 0xFFFFFFFF);
+                    matchCode -= 4*255;
+                }
+                op += matchCode / 255;
+                *op++ = (BYTE)(matchCode % 255);
+            } else
+                *token += (BYTE)(matchCode);
+        }
+        /* Ensure we have enough space for the last literals. */
+        assert(!(outputDirective == fillOutput && op + 1 + LASTLITERALS > olimit));
+
+        anchor = ip;
+
+        /* Test end of chunk */
+        if (ip >= mflimitPlusOne) break;
+
+        /* Fill table */
+        {   U32 const h = LZ4_hashPosition(ip-2, tableType);
+            if (tableType == byPtr) {
+                LZ4_putPositionOnHash(ip-2, h, cctx->hashTable, byPtr);
+            } else {
+                U32 const idx = (U32)((ip-2) - base);
+                LZ4_putIndexOnHash(idx, h, cctx->hashTable, tableType);
+        }   }
+
+        /* Test next position */
+        if (tableType == byPtr) {
+
+            match = LZ4_getPosition(ip, cctx->hashTable, tableType);
+            LZ4_putPosition(ip, cctx->hashTable, tableType);
+            if ( (match+LZ4_DISTANCE_MAX >= ip)
+              && (LZ4_read32(match) == LZ4_read32(ip)) )
+            { token=op++; *token=0; goto _next_match; }
+
+        } else {   /* byU32, byU16 */
+
+            U32 const h = LZ4_hashPosition(ip, tableType);
+            U32 const current = (U32)(ip-base);
+            U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
+            assert(matchIndex < current);
+            if (dictDirective == usingDictCtx) {
+                if (matchIndex < startIndex) {
+                    /* there was no match, try the dictionary */
+                    assert(tableType == byU32);
+                    matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
+                    match = dictBase + matchIndex;
+                    lowLimit = dictionary;   /* required for match length counter */
+                    matchIndex += dictDelta;
+                } else {
+                    match = base + matchIndex;
+                    lowLimit = (const BYTE*)source;  /* required for match length counter */
+                }
+            } else if (dictDirective==usingExtDict) {
+                if (matchIndex < startIndex) {
+                    assert(dictBase);
+                    match = dictBase + matchIndex;
+                    lowLimit = dictionary;   /* required for match length counter */
+                } else {
+                    match = base + matchIndex;
+                    lowLimit = (const BYTE*)source;   /* required for match length counter */
+                }
+            } else {   /* single memory segment */
+                match = base + matchIndex;
+            }
+            LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
+            assert(matchIndex < current);
+            if ( ((dictIssue==dictSmall) ? (matchIndex >= prefixIdxLimit) : 1)
+              && (((tableType==byU16) && (LZ4_DISTANCE_MAX == LZ4_DISTANCE_ABSOLUTE_MAX)) ? 1 : (matchIndex+LZ4_DISTANCE_MAX >= current))
+              && (LZ4_read32(match) == LZ4_read32(ip)) ) {
+                token=op++;
+                *token=0;
+                if (maybe_extMem) offset = current - matchIndex;
+                DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
+                            (int)(anchor-(const BYTE*)source), 0, (int)(ip-(const BYTE*)source));
+                goto _next_match;
+            }
+        }
+
+        /* Prepare next loop */
+        forwardH = LZ4_hashPosition(++ip, tableType);
+
+    }
+
+_last_literals:
+    /* Encode Last Literals */
+    {   size_t lastRun = (size_t)(iend - anchor);
+        if ( (outputDirective) &&  /* Check output buffer overflow */
+            (op + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > olimit)) {
+            if (outputDirective == fillOutput) {
+                /* adapt lastRun to fill 'dst' */
+                assert(olimit >= op);
+                lastRun  = (size_t)(olimit-op) - 1/*token*/;
+                lastRun -= (lastRun + 256 - RUN_MASK) / 256;  /*additional length tokens*/
+            } else {
+                assert(outputDirective == limitedOutput);
+                return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
+            }
+        }
+        DEBUGLOG(6, "Final literal run : %i literals", (int)lastRun);
+        if (lastRun >= RUN_MASK) {
+            size_t accumulator = lastRun - RUN_MASK;
+            *op++ = RUN_MASK << ML_BITS;
+            for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
+            *op++ = (BYTE) accumulator;
+        } else {
+            *op++ = (BYTE)(lastRun<<ML_BITS);
+        }
+        LZ4_memcpy(op, anchor, lastRun);
+        ip = anchor + lastRun;
+        op += lastRun;
+    }
+
+    if (outputDirective == fillOutput) {
+        *inputConsumed = (int) (((const char*)ip)-source);
+    }
+    result = (int)(((char*)op) - dest);
+    assert(result > 0);
+    DEBUGLOG(5, "LZ4_compress_generic: compressed %i bytes into %i bytes", inputSize, result);
+    return result;
+}
+
+/** LZ4_compress_generic() :
+ *  inlined, to ensure branches are decided at compilation time;
+ *  takes care of src == (NULL, 0)
+ *  and forward the rest to LZ4_compress_generic_validated */
+LZ4_FORCE_INLINE int LZ4_compress_generic(
+                 LZ4_stream_t_internal* const cctx,
+                 const char* const src,
+                 char* const dst,
+                 const int srcSize,
+                 int *inputConsumed, /* only written when outputDirective == fillOutput */
+                 const int dstCapacity,
+                 const limitedOutput_directive outputDirective,
+                 const tableType_t tableType,
+                 const dict_directive dictDirective,
+                 const dictIssue_directive dictIssue,
+                 const int acceleration)
+{
+    DEBUGLOG(5, "LZ4_compress_generic: srcSize=%i, dstCapacity=%i",
+                srcSize, dstCapacity);
+
+    if ((U32)srcSize > (U32)LZ4_MAX_INPUT_SIZE) { return 0; }  /* Unsupported srcSize, too large (or negative) */
+    if (srcSize == 0) {   /* src == NULL supported if srcSize == 0 */
+        if (outputDirective != notLimited && dstCapacity <= 0) return 0;  /* no output, can't write anything */
+        DEBUGLOG(5, "Generating an empty block");
+        assert(outputDirective == notLimited || dstCapacity >= 1);
+        assert(dst != NULL);
+        dst[0] = 0;
+        if (outputDirective == fillOutput) {
+            assert (inputConsumed != NULL);
+            *inputConsumed = 0;
+        }
+        return 1;
+    }
+    assert(src != NULL);
+
+    return LZ4_compress_generic_validated(cctx, src, dst, srcSize,
+                inputConsumed, /* only written into if outputDirective == fillOutput */
+                dstCapacity, outputDirective,
+                tableType, dictDirective, dictIssue, acceleration);
+}
+
+
+int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
+{
+    LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;
+    assert(ctx != NULL);
+    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
+    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
+    if (maxOutputSize >= LZ4_compressBound(inputSize)) {
+        if (inputSize < LZ4_64Klimit) {
+            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, byU16, noDict, noDictIssue, acceleration);
+        } else {
+            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
+            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
+        }
+    } else {
+        if (inputSize < LZ4_64Klimit) {
+            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration);
+        } else {
+            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
+            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, noDict, noDictIssue, acceleration);
+        }
+    }
+}
+
+/**
+ * LZ4_compress_fast_extState_fastReset() :
+ * A variant of LZ4_compress_fast_extState().
+ *
+ * Using this variant avoids an expensive initialization step. It is only safe
+ * to call if the state buffer is known to be correctly initialized already
+ * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of
+ * "correctly initialized").
+ */
+int LZ4_compress_fast_extState_fastReset(void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration)
+{
+    LZ4_stream_t_internal* const ctx = &((LZ4_stream_t*)state)->internal_donotuse;
+    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
+    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
+    assert(ctx != NULL);
+
+    if (dstCapacity >= LZ4_compressBound(srcSize)) {
+        if (srcSize < LZ4_64Klimit) {
+            const tableType_t tableType = byU16;
+            LZ4_prepareTable(ctx, srcSize, tableType);
+            if (ctx->currentOffset) {
+                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, dictSmall, acceleration);
+            } else {
+                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
+            }
+        } else {
+            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
+            LZ4_prepareTable(ctx, srcSize, tableType);
+            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
+        }
+    } else {
+        if (srcSize < LZ4_64Klimit) {
+            const tableType_t tableType = byU16;
+            LZ4_prepareTable(ctx, srcSize, tableType);
+            if (ctx->currentOffset) {
+                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, dictSmall, acceleration);
+            } else {
+                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
+            }
+        } else {
+            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
+            LZ4_prepareTable(ctx, srcSize, tableType);
+            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
+        }
+    }
+}
+
+
+int LZ4_compress_fast(const char* src, char* dest, int srcSize, int dstCapacity, int acceleration)
+{
+    int result;
+#if (LZ4_HEAPMODE)
+    LZ4_stream_t* const ctxPtr = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
+    if (ctxPtr == NULL) return 0;
+#else
+    LZ4_stream_t ctx;
+    LZ4_stream_t* const ctxPtr = &ctx;
+#endif
+    result = LZ4_compress_fast_extState(ctxPtr, src, dest, srcSize, dstCapacity, acceleration);
+
+#if (LZ4_HEAPMODE)
+    FREEMEM(ctxPtr);
+#endif
+    return result;
+}
+
+
+int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity)
+{
+    return LZ4_compress_fast(src, dst, srcSize, dstCapacity, 1);
+}
+
+
+/* Note!: This function leaves the stream in an unclean/broken state!
+ * It is not safe to subsequently use the same state with a _fastReset() or
+ * _continue() call without resetting it. */
+static int LZ4_compress_destSize_extState_internal(LZ4_stream_t* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize, int acceleration)
+{
+    void* const s = LZ4_initStream(state, sizeof (*state));
+    assert(s != NULL); (void)s;
+
+    if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) {  /* compression success is guaranteed */
+        return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, acceleration);
+    } else {
+        if (*srcSizePtr < LZ4_64Klimit) {
+            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, byU16, noDict, noDictIssue, acceleration);
+        } else {
+            tableType_t const addrMode = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
+            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, addrMode, noDict, noDictIssue, acceleration);
+    }   }
+}
+
+int LZ4_compress_destSize_extState(void* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize, int acceleration)
+{
+    int const r = LZ4_compress_destSize_extState_internal((LZ4_stream_t*)state, src, dst, srcSizePtr, targetDstSize, acceleration);
+    /* clean the state on exit */
+    LZ4_initStream(state, sizeof (LZ4_stream_t));
+    return r;
+}
+
+
+int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize)
+{
+#if (LZ4_HEAPMODE)
+    LZ4_stream_t* const ctx = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
+    if (ctx == NULL) return 0;
+#else
+    LZ4_stream_t ctxBody;
+    LZ4_stream_t* const ctx = &ctxBody;
+#endif
+
+    int result = LZ4_compress_destSize_extState_internal(ctx, src, dst, srcSizePtr, targetDstSize, 1);
+
+#if (LZ4_HEAPMODE)
+    FREEMEM(ctx);
+#endif
+    return result;
+}
+
+
+
+/*-******************************
+*  Streaming functions
+********************************/
+
+#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
+LZ4_stream_t* LZ4_createStream(void)
+{
+    LZ4_stream_t* const lz4s = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));
+    LZ4_STATIC_ASSERT(sizeof(LZ4_stream_t) >= sizeof(LZ4_stream_t_internal));
+    DEBUGLOG(4, "LZ4_createStream %p", lz4s);
+    if (lz4s == NULL) return NULL;
+    LZ4_initStream(lz4s, sizeof(*lz4s));
+    return lz4s;
+}
+#endif
+
+static size_t LZ4_stream_t_alignment(void)
+{
+#if LZ4_ALIGN_TEST
+    typedef struct { char c; LZ4_stream_t t; } t_a;
+    return sizeof(t_a) - sizeof(LZ4_stream_t);
+#else
+    return 1;  /* effectively disabled */
+#endif
+}
+
+LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
+{
+    DEBUGLOG(5, "LZ4_initStream");
+    if (buffer == NULL) { return NULL; }
+    if (size < sizeof(LZ4_stream_t)) { return NULL; }
+    if (!LZ4_isAligned(buffer, LZ4_stream_t_alignment())) return NULL;
+    MEM_INIT(buffer, 0, sizeof(LZ4_stream_t_internal));
+    return (LZ4_stream_t*)buffer;
+}
+
+/* resetStream is now deprecated,
+ * prefer initStream() which is more general */
+void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
+{
+    DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);
+    MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t_internal));
+}
+
+void LZ4_resetStream_fast(LZ4_stream_t* ctx) {
+    LZ4_prepareTable(&(ctx->internal_donotuse), 0, byU32);
+}
+
+#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
+int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
+{
+    if (!LZ4_stream) return 0;   /* support free on NULL */
+    DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);
+    FREEMEM(LZ4_stream);
+    return (0);
+}
+#endif
+
+
+typedef enum { _ld_fast, _ld_slow } LoadDict_mode_e;
+#define HASH_UNIT sizeof(reg_t)
+int LZ4_loadDict_internal(LZ4_stream_t* LZ4_dict,
+                    const char* dictionary, int dictSize,
+                    LoadDict_mode_e _ld)
+{
+    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
+    const tableType_t tableType = byU32;
+    const BYTE* p = (const BYTE*)dictionary;
+    const BYTE* const dictEnd = p + dictSize;
+    U32 idx32;
+
+    DEBUGLOG(4, "LZ4_loadDict (%i bytes from %p into %p)", dictSize, dictionary, LZ4_dict);
+
+    /* It's necessary to reset the context,
+     * and not just continue it with prepareTable()
+     * to avoid any risk of generating overflowing matchIndex
+     * when compressing using this dictionary */
+    LZ4_resetStream(LZ4_dict);
+
+    /* We always increment the offset by 64 KB, since, if the dict is longer,
+     * we truncate it to the last 64k, and if it's shorter, we still want to
+     * advance by a whole window length so we can provide the guarantee that
+     * there are only valid offsets in the window, which allows an optimization
+     * in LZ4_compress_fast_continue() where it uses noDictIssue even when the
+     * dictionary isn't a full 64k. */
+    dict->currentOffset += 64 KB;
+
+    if (dictSize < (int)HASH_UNIT) {
+        return 0;
+    }
+
+    if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
+    dict->dictionary = p;
+    dict->dictSize = (U32)(dictEnd - p);
+    dict->tableType = (U32)tableType;
+    idx32 = dict->currentOffset - dict->dictSize;
+
+    while (p <= dictEnd-HASH_UNIT) {
+        U32 const h = LZ4_hashPosition(p, tableType);
+        /* Note: overwriting => favors positions end of dictionary */
+        LZ4_putIndexOnHash(idx32, h, dict->hashTable, tableType);
+        p+=3; idx32+=3;
+    }
+
+    if (_ld == _ld_slow) {
+        /* Fill hash table with additional references, to improve compression capability */
+        p = dict->dictionary;
+        idx32 = dict->currentOffset - dict->dictSize;
+        while (p <= dictEnd-HASH_UNIT) {
+            U32 const h = LZ4_hashPosition(p, tableType);
+            U32 const limit = dict->currentOffset - 64 KB;
+            if (LZ4_getIndexOnHash(h, dict->hashTable, tableType) <= limit) {
+                /* Note: not overwriting => favors positions beginning of dictionary */
+                LZ4_putIndexOnHash(idx32, h, dict->hashTable, tableType);
+            }
+            p++; idx32++;
+        }
+    }
+
+    return (int)dict->dictSize;
+}
+
+int LZ4_loadDict(LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
+{
+    return LZ4_loadDict_internal(LZ4_dict, dictionary, dictSize, _ld_fast);
+}
+
+int LZ4_loadDictSlow(LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
+{
+    return LZ4_loadDict_internal(LZ4_dict, dictionary, dictSize, _ld_slow);
+}
+
+void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream)
+{
+    const LZ4_stream_t_internal* dictCtx = (dictionaryStream == NULL) ? NULL :
+        &(dictionaryStream->internal_donotuse);
+
+    DEBUGLOG(4, "LZ4_attach_dictionary (%p, %p, size %u)",
+             workingStream, dictionaryStream,
+             dictCtx != NULL ? dictCtx->dictSize : 0);
+
+    if (dictCtx != NULL) {
+        /* If the current offset is zero, we will never look in the
+         * external dictionary context, since there is no value a table
+         * entry can take that indicate a miss. In that case, we need
+         * to bump the offset to something non-zero.
+         */
+        if (workingStream->internal_donotuse.currentOffset == 0) {
+            workingStream->internal_donotuse.currentOffset = 64 KB;
+        }
+
+        /* Don't actually attach an empty dictionary.
+         */
+        if (dictCtx->dictSize == 0) {
+            dictCtx = NULL;
+        }
+    }
+    workingStream->internal_donotuse.dictCtx = dictCtx;
+}
+
+
+static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, int nextSize)
+{
+    assert(nextSize >= 0);
+    if (LZ4_dict->currentOffset + (unsigned)nextSize > 0x80000000) {   /* potential ptrdiff_t overflow (32-bits mode) */
+        /* rescale hash table */
+        U32 const delta = LZ4_dict->currentOffset - 64 KB;
+        const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
+        int i;
+        DEBUGLOG(4, "LZ4_renormDictT");
+        for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
+            if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
+            else LZ4_dict->hashTable[i] -= delta;
+        }
+        LZ4_dict->currentOffset = 64 KB;
+        if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
+        LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
+    }
+}
+
+
+int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream,
+                                const char* source, char* dest,
+                                int inputSize, int maxOutputSize,
+                                int acceleration)
+{
+    const tableType_t tableType = byU32;
+    LZ4_stream_t_internal* const streamPtr = &LZ4_stream->internal_donotuse;
+    const char* dictEnd = streamPtr->dictSize ? (const char*)streamPtr->dictionary + streamPtr->dictSize : NULL;
+
+    DEBUGLOG(5, "LZ4_compress_fast_continue (inputSize=%i, dictSize=%u)", inputSize, streamPtr->dictSize);
+
+    LZ4_renormDictT(streamPtr, inputSize);   /* fix index overflow */
+    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
+    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
+
+    /* invalidate tiny dictionaries */
+    if ( (streamPtr->dictSize < 4)     /* tiny dictionary : not enough for a hash */
+      && (dictEnd != source)           /* prefix mode */
+      && (inputSize > 0)               /* tolerance : don't lose history, in case next invocation would use prefix mode */
+      && (streamPtr->dictCtx == NULL)  /* usingDictCtx */
+      ) {
+        DEBUGLOG(5, "LZ4_compress_fast_continue: dictSize(%u) at addr:%p is too small", streamPtr->dictSize, streamPtr->dictionary);
+        /* remove dictionary existence from history, to employ faster prefix mode */
+        streamPtr->dictSize = 0;
+        streamPtr->dictionary = (const BYTE*)source;
+        dictEnd = source;
+    }
+
+    /* Check overlapping input/dictionary space */
+    {   const char* const sourceEnd = source + inputSize;
+        if ((sourceEnd > (const char*)streamPtr->dictionary) && (sourceEnd < dictEnd)) {
+            streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
+            if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
+            if (streamPtr->dictSize < 4) streamPtr->dictSize = 0;
+            streamPtr->dictionary = (const BYTE*)dictEnd - streamPtr->dictSize;
+        }
+    }
+
+    /* prefix mode : source data follows dictionary */
+    if (dictEnd == source) {
+        if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
+            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, dictSmall, acceleration);
+        else
+            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, noDictIssue, acceleration);
+    }
+
+    /* external dictionary mode */
+    {   int result;
+        if (streamPtr->dictCtx) {
+            /* We depend here on the fact that dictCtx'es (produced by
+             * LZ4_loadDict) guarantee that their tables contain no references
+             * to offsets between dictCtx->currentOffset - 64 KB and
+             * dictCtx->currentOffset - dictCtx->dictSize. This makes it safe
+             * to use noDictIssue even when the dict isn't a full 64 KB.
+             */
+            if (inputSize > 4 KB) {
+                /* For compressing large blobs, it is faster to pay the setup
+                 * cost to copy the dictionary's tables into the active context,
+                 * so that the compression loop is only looking into one table.
+                 */
+                LZ4_memcpy(streamPtr, streamPtr->dictCtx, sizeof(*streamPtr));
+                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
+            } else {
+                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingDictCtx, noDictIssue, acceleration);
+            }
+        } else {  /* small data <= 4 KB */
+            if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
+                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, dictSmall, acceleration);
+            } else {
+                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
+            }
+        }
+        streamPtr->dictionary = (const BYTE*)source;
+        streamPtr->dictSize = (U32)inputSize;
+        return result;
+    }
+}
+
+
+/* Hidden debug function, to force-test external dictionary mode */
+int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize)
+{
+    LZ4_stream_t_internal* const streamPtr = &LZ4_dict->internal_donotuse;
+    int result;
+
+    LZ4_renormDictT(streamPtr, srcSize);
+
+    if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
+        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, dictSmall, 1);
+    } else {
+        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
+    }
+
+    streamPtr->dictionary = (const BYTE*)source;
+    streamPtr->dictSize = (U32)srcSize;
+
+    return result;
+}
+
+
+/*! LZ4_saveDict() :
+ *  If previously compressed data block is not guaranteed to remain available at its memory location,
+ *  save it into a safer place (char* safeBuffer).
+ *  Note : no need to call LZ4_loadDict() afterwards, dictionary is immediately usable,
+ *         one can therefore call LZ4_compress_fast_continue() right after.
+ * @return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
+ */
+int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
+{
+    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
+
+    DEBUGLOG(5, "LZ4_saveDict : dictSize=%i, safeBuffer=%p", dictSize, safeBuffer);
+
+    if ((U32)dictSize > 64 KB) { dictSize = 64 KB; } /* useless to define a dictionary > 64 KB */
+    if ((U32)dictSize > dict->dictSize) { dictSize = (int)dict->dictSize; }
+
+    if (safeBuffer == NULL) assert(dictSize == 0);
+    if (dictSize > 0) {
+        const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize;
+        assert(dict->dictionary);
+        LZ4_memmove(safeBuffer, previousDictEnd - dictSize, (size_t)dictSize);
+    }
+
+    dict->dictionary = (const BYTE*)safeBuffer;
+    dict->dictSize = (U32)dictSize;
+
+    return dictSize;
+}
+
+
+
+/*-*******************************
+ *  Decompression functions
+ ********************************/
+
+typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive;
+
+#undef MIN
+#define MIN(a,b)    ( (a) < (b) ? (a) : (b) )
+
+
+/* variant for decompress_unsafe()
+ * does not know end of input
+ * presumes input is well formed
+ * note : will consume at least one byte */
+static size_t read_long_length_no_check(const BYTE** pp)
+{
+    size_t b, l = 0;
+    do { b = **pp; (*pp)++; l += b; } while (b==255);
+    DEBUGLOG(6, "read_long_length_no_check: +length=%zu using %zu input bytes", l, l/255 + 1)
+    return l;
+}
+
+/* core decoder variant for LZ4_decompress_fast*()
+ * for legacy support only : these entry points are deprecated.
+ * - Presumes input is correctly formed (no defense vs malformed inputs)
+ * - Does not know input size (presume input buffer is "large enough")
+ * - Decompress a full block (only)
+ * @return : nb of bytes read from input.
+ * Note : this variant is not optimized for speed, just for maintenance.
+ *        the goal is to remove support of decompress_fast*() variants by v2.0
+**/
+LZ4_FORCE_INLINE int
+LZ4_decompress_unsafe_generic(
+                 const BYTE* const istart,
+                 BYTE* const ostart,
+                 int decompressedSize,
+
+                 size_t prefixSize,
+                 const BYTE* const dictStart,  /* only if dict==usingExtDict */
+                 const size_t dictSize         /* note: =0 if dictStart==NULL */
+                 )
+{
+    const BYTE* ip = istart;
+    BYTE* op = (BYTE*)ostart;
+    BYTE* const oend = ostart + decompressedSize;
+    const BYTE* const prefixStart = ostart - prefixSize;
+
+    DEBUGLOG(5, "LZ4_decompress_unsafe_generic");
+    if (dictStart == NULL) assert(dictSize == 0);
+
+    while (1) {
+        /* start new sequence */
+        unsigned token = *ip++;
+
+        /* literals */
+        {   size_t ll = token >> ML_BITS;
+            if (ll==15) {
+                /* long literal length */
+                ll += read_long_length_no_check(&ip);
+            }
+            if ((size_t)(oend-op) < ll) return -1; /* output buffer overflow */
+            LZ4_memmove(op, ip, ll); /* support in-place decompression */
+            op += ll;
+            ip += ll;
+            if ((size_t)(oend-op) < MFLIMIT) {
+                if (op==oend) break;  /* end of block */
+                DEBUGLOG(5, "invalid: literals end at distance %zi from end of block", oend-op);
+                /* incorrect end of block :
+                 * last match must start at least MFLIMIT==12 bytes before end of output block */
+                return -1;
+        }   }
+
+        /* match */
+        {   size_t ml = token & 15;
+            size_t const offset = LZ4_readLE16(ip);
+            ip+=2;
+
+            if (ml==15) {
+                /* long literal length */
+                ml += read_long_length_no_check(&ip);
+            }
+            ml += MINMATCH;
+
+            if ((size_t)(oend-op) < ml) return -1; /* output buffer overflow */
+
+            {   const BYTE* match = op - offset;
+
+                /* out of range */
+                if (offset > (size_t)(op - prefixStart) + dictSize) {
+                    DEBUGLOG(6, "offset out of range");
+                    return -1;
+                }
+
+                /* check special case : extDict */
+                if (offset > (size_t)(op - prefixStart)) {
+                    /* extDict scenario */
+                    const BYTE* const dictEnd = dictStart + dictSize;
+                    const BYTE* extMatch = dictEnd - (offset - (size_t)(op-prefixStart));
+                    size_t const extml = (size_t)(dictEnd - extMatch);
+                    if (extml > ml) {
+                        /* match entirely within extDict */
+                        LZ4_memmove(op, extMatch, ml);
+                        op += ml;
+                        ml = 0;
+                    } else {
+                        /* match split between extDict & prefix */
+                        LZ4_memmove(op, extMatch, extml);
+                        op += extml;
+                        ml -= extml;
+                    }
+                    match = prefixStart;
+                }
+
+                /* match copy - slow variant, supporting overlap copy */
+                {   size_t u;
+                    for (u=0; u<ml; u++) {
+                        op[u] = match[u];
+            }   }   }
+            op += ml;
+            if ((size_t)(oend-op) < LASTLITERALS) {
+                DEBUGLOG(5, "invalid: match ends at distance %zi from end of block", oend-op);
+                /* incorrect end of block :
+                 * last match must stop at least LASTLITERALS==5 bytes before end of output block */
+                return -1;
+            }
+        } /* match */
+    } /* main loop */
+    return (int)(ip - istart);
+}
+
+
+/* Read the variable-length literal or match length.
+ *
+ * @ip : input pointer
+ * @ilimit : position after which if length is not decoded, the input is necessarily corrupted.
+ * @initial_check - check ip >= ipmax before start of loop.  Returns initial_error if so.
+ * @error (output) - error code.  Must be set to 0 before call.
+**/
+typedef size_t Rvl_t;
+static const Rvl_t rvl_error = (Rvl_t)(-1);
+LZ4_FORCE_INLINE Rvl_t
+read_variable_length(const BYTE** ip, const BYTE* ilimit,
+                     int initial_check)
+{
+    Rvl_t s, length = 0;
+    assert(ip != NULL);
+    assert(*ip !=  NULL);
+    assert(ilimit != NULL);
+    if (initial_check && unlikely((*ip) >= ilimit)) {    /* read limit reached */
+        return rvl_error;
+    }
+    s = **ip;
+    (*ip)++;
+    length += s;
+    if (unlikely((*ip) > ilimit)) {    /* read limit reached */
+        return rvl_error;
+    }
+    /* accumulator overflow detection (32-bit mode only) */
+    if ((sizeof(length) < 8) && unlikely(length > ((Rvl_t)(-1)/2)) ) {
+        return rvl_error;
+    }
+    if (likely(s != 255)) return length;
+    do {
+        s = **ip;
+        (*ip)++;
+        length += s;
+        if (unlikely((*ip) > ilimit)) {    /* read limit reached */
+            return rvl_error;
+        }
+        /* accumulator overflow detection (32-bit mode only) */
+        if ((sizeof(length) < 8) && unlikely(length > ((Rvl_t)(-1)/2)) ) {
+            return rvl_error;
+        }
+    } while (s == 255);
+
+    return length;
+}
+
+/*! LZ4_decompress_generic() :
+ *  This generic decompression function covers all use cases.
+ *  It shall be instantiated several times, using different sets of directives.
+ *  Note that it is important for performance that this function really get inlined,
+ *  in order to remove useless branches during compilation optimization.
+ */
+LZ4_FORCE_INLINE int
+LZ4_decompress_generic(
+                 const char* const src,
+                 char* const dst,
+                 int srcSize,
+                 int outputSize,         /* If endOnInput==endOnInputSize, this value is `dstCapacity` */
+
+                 earlyEnd_directive partialDecoding,  /* full, partial */
+                 dict_directive dict,                 /* noDict, withPrefix64k, usingExtDict */
+                 const BYTE* const lowPrefix,  /* always <= dst, == dst when no prefix */
+                 const BYTE* const dictStart,  /* only if dict==usingExtDict */
+                 const size_t dictSize         /* note : = 0 if noDict */
+                 )
+{
+    if ((src == NULL) || (outputSize < 0)) { return -1; }
+
+    {   const BYTE* ip = (const BYTE*) src;
+        const BYTE* const iend = ip + srcSize;
+
+        BYTE* op = (BYTE*) dst;
+        BYTE* const oend = op + outputSize;
+        BYTE* cpy;
+
+        const BYTE* const dictEnd = (dictStart == NULL) ? NULL : dictStart + dictSize;
+
+        const int checkOffset = (dictSize < (int)(64 KB));
+
+
+        /* Set up the "end" pointers for the shortcut. */
+        const BYTE* const shortiend = iend - 14 /*maxLL*/ - 2 /*offset*/;
+        const BYTE* const shortoend = oend - 14 /*maxLL*/ - 18 /*maxML*/;
+
+        const BYTE* match;
+        size_t offset;
+        unsigned token;
+        size_t length;
+
+
+        DEBUGLOG(5, "LZ4_decompress_generic (srcSize:%i, dstSize:%i)", srcSize, outputSize);
+
+        /* Special cases */
+        assert(lowPrefix <= op);
+        if (unlikely(outputSize==0)) {
+            /* Empty output buffer */
+            if (partialDecoding) return 0;
+            return ((srcSize==1) && (*ip==0)) ? 0 : -1;
+        }
+        if (unlikely(srcSize==0)) { return -1; }
+
+    /* LZ4_FAST_DEC_LOOP:
+     * designed for modern OoO performance cpus,
+     * where copying reliably 32-bytes is preferable to an unpredictable branch.
+     * note : fast loop may show a regression for some client arm chips. */
+#if LZ4_FAST_DEC_LOOP
+        if ((oend - op) < FASTLOOP_SAFE_DISTANCE) {
+            DEBUGLOG(6, "move to safe decode loop");
+            goto safe_decode;
+        }
+
+        /* Fast loop : decode sequences as long as output < oend-FASTLOOP_SAFE_DISTANCE */
+        DEBUGLOG(6, "using fast decode loop");
+        while (1) {
+            /* Main fastloop assertion: We can always wildcopy FASTLOOP_SAFE_DISTANCE */
+            assert(oend - op >= FASTLOOP_SAFE_DISTANCE);
+            assert(ip < iend);
+            token = *ip++;
+            length = token >> ML_BITS;  /* literal length */
+            DEBUGLOG(7, "blockPos%6u: litLength token = %u", (unsigned)(op-(BYTE*)dst), (unsigned)length);
+
+            /* decode literal length */
+            if (length == RUN_MASK) {
+                size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1);
+                if (addl == rvl_error) {
+                    DEBUGLOG(6, "error reading long literal length");
+                    goto _output_error;
+                }
+                length += addl;
+                if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */
+                if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */
+
+                /* copy literals */
+                LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH);
+                if ((op+length>oend-32) || (ip+length>iend-32)) { goto safe_literal_copy; }
+                LZ4_wildCopy32(op, ip, op+length);
+                ip += length; op += length;
+            } else if (ip <= iend-(16 + 1/*max lit + offset + nextToken*/)) {
+                /* We don't need to check oend, since we check it once for each loop below */
+                DEBUGLOG(7, "copy %u bytes in a 16-bytes stripe", (unsigned)length);
+                /* Literals can only be <= 14, but hope compilers optimize better when copy by a register size */
+                LZ4_memcpy(op, ip, 16);
+                ip += length; op += length;
+            } else {
+                goto safe_literal_copy;
+            }
+
+            /* get offset */
+            offset = LZ4_readLE16(ip); ip+=2;
+            DEBUGLOG(6, "blockPos%6u: offset = %u", (unsigned)(op-(BYTE*)dst), (unsigned)offset);
+            match = op - offset;
+            assert(match <= op);  /* overflow check */
+
+            /* get matchlength */
+            length = token & ML_MASK;
+            DEBUGLOG(7, "  match length token = %u (len==%u)", (unsigned)length, (unsigned)length+MINMATCH);
+
+            if (length == ML_MASK) {
+                size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0);
+                if (addl == rvl_error) {
+                    DEBUGLOG(5, "error reading long match length");
+                    goto _output_error;
+                }
+                length += addl;
+                length += MINMATCH;
+                DEBUGLOG(7, "  long match length == %u", (unsigned)length);
+                if (unlikely((uptrval)(op)+length<(uptrval)op)) { goto _output_error; } /* overflow detection */
+                if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) {
+                    goto safe_match_copy;
+                }
+            } else {
+                length += MINMATCH;
+                if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) {
+                    DEBUGLOG(7, "moving to safe_match_copy (ml==%u)", (unsigned)length);
+                    goto safe_match_copy;
+                }
+
+                /* Fastpath check: skip LZ4_wildCopy32 when true */
+                if ((dict == withPrefix64k) || (match >= lowPrefix)) {
+                    if (offset >= 8) {
+                        assert(match >= lowPrefix);
+                        assert(match <= op);
+                        assert(op + 18 <= oend);
+
+                        LZ4_memcpy(op, match, 8);
+                        LZ4_memcpy(op+8, match+8, 8);
+                        LZ4_memcpy(op+16, match+16, 2);
+                        op += length;
+                        continue;
+            }   }   }
+
+            if ( checkOffset && (unlikely(match + dictSize < lowPrefix)) ) {
+                DEBUGLOG(5, "Error : pos=%zi, offset=%zi => outside buffers", op-lowPrefix, op-match);
+                goto _output_error;
+            }
+            /* match starting within external dictionary */
+            if ((dict==usingExtDict) && (match < lowPrefix)) {
+                assert(dictEnd != NULL);
+                if (unlikely(op+length > oend-LASTLITERALS)) {
+                    if (partialDecoding) {
+                        DEBUGLOG(7, "partialDecoding: dictionary match, close to dstEnd");
+                        length = MIN(length, (size_t)(oend-op));
+                    } else {
+                        DEBUGLOG(6, "end-of-block condition violated")
+                        goto _output_error;
+                }   }
+
+                if (length <= (size_t)(lowPrefix-match)) {
+                    /* match fits entirely within external dictionary : just copy */
+                    LZ4_memmove(op, dictEnd - (lowPrefix-match), length);
+                    op += length;
+                } else {
+                    /* match stretches into both external dictionary and current block */
+                    size_t const copySize = (size_t)(lowPrefix - match);
+                    size_t const restSize = length - copySize;
+                    LZ4_memcpy(op, dictEnd - copySize, copySize);
+                    op += copySize;
+                    if (restSize > (size_t)(op - lowPrefix)) {  /* overlap copy */
+                        BYTE* const endOfMatch = op + restSize;
+                        const BYTE* copyFrom = lowPrefix;
+                        while (op < endOfMatch) { *op++ = *copyFrom++; }
+                    } else {
+                        LZ4_memcpy(op, lowPrefix, restSize);
+                        op += restSize;
+                }   }
+                continue;
+            }
+
+            /* copy match within block */
+            cpy = op + length;
+
+            assert((op <= oend) && (oend-op >= 32));
+            if (unlikely(offset<16)) {
+                LZ4_memcpy_using_offset(op, match, cpy, offset);
+            } else {
+                LZ4_wildCopy32(op, match, cpy);
+            }
+
+            op = cpy;   /* wildcopy correction */
+        }
+    safe_decode:
+#endif
+
+        /* Main Loop : decode remaining sequences where output < FASTLOOP_SAFE_DISTANCE */
+        DEBUGLOG(6, "using safe decode loop");
+        while (1) {
+            assert(ip < iend);
+            token = *ip++;
+            length = token >> ML_BITS;  /* literal length */
+            DEBUGLOG(7, "blockPos%6u: litLength token = %u", (unsigned)(op-(BYTE*)dst), (unsigned)length);
+
+            /* A two-stage shortcut for the most common case:
+             * 1) If the literal length is 0..14, and there is enough space,
+             * enter the shortcut and copy 16 bytes on behalf of the literals
+             * (in the fast mode, only 8 bytes can be safely copied this way).
+             * 2) Further if the match length is 4..18, copy 18 bytes in a similar
+             * manner; but we ensure that there's enough space in the output for
+             * those 18 bytes earlier, upon entering the shortcut (in other words,
+             * there is a combined check for both stages).
+             */
+            if ( (length != RUN_MASK)
+                /* strictly "less than" on input, to re-enter the loop with at least one byte */
+              && likely((ip < shortiend) & (op <= shortoend)) ) {
+                /* Copy the literals */
+                LZ4_memcpy(op, ip, 16);
+                op += length; ip += length;
+
+                /* The second stage: prepare for match copying, decode full info.
+                 * If it doesn't work out, the info won't be wasted. */
+                length = token & ML_MASK; /* match length */
+                DEBUGLOG(7, "blockPos%6u: matchLength token = %u (len=%u)", (unsigned)(op-(BYTE*)dst), (unsigned)length, (unsigned)length + 4);
+                offset = LZ4_readLE16(ip); ip += 2;
+                match = op - offset;
+                assert(match <= op); /* check overflow */
+
+                /* Do not deal with overlapping matches. */
+                if ( (length != ML_MASK)
+                  && (offset >= 8)
+                  && (dict==withPrefix64k || match >= lowPrefix) ) {
+                    /* Copy the match. */
+                    LZ4_memcpy(op + 0, match + 0, 8);
+                    LZ4_memcpy(op + 8, match + 8, 8);
+                    LZ4_memcpy(op +16, match +16, 2);
+                    op += length + MINMATCH;
+                    /* Both stages worked, load the next token. */
+                    continue;
+                }
+
+                /* The second stage didn't work out, but the info is ready.
+                 * Propel it right to the point of match copying. */
+                goto _copy_match;
+            }
+
+            /* decode literal length */
+            if (length == RUN_MASK) {
+                size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1);
+                if (addl == rvl_error) { goto _output_error; }
+                length += addl;
+                if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */
+                if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */
+            }
+
+#if LZ4_FAST_DEC_LOOP
+        safe_literal_copy:
+#endif
+            /* copy literals */
+            cpy = op+length;
+
+            LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH);
+            if ((cpy>oend-MFLIMIT) || (ip+length>iend-(2+1+LASTLITERALS))) {
+                /* We've either hit the input parsing restriction or the output parsing restriction.
+                 * In the normal scenario, decoding a full block, it must be the last sequence,
+                 * otherwise it's an error (invalid input or dimensions).
+                 * In partialDecoding scenario, it's necessary to ensure there is no buffer overflow.
+                 */
+                if (partialDecoding) {
+                    /* Since we are partial decoding we may be in this block because of the output parsing
+                     * restriction, which is not valid since the output buffer is allowed to be undersized.
+                     */
+                    DEBUGLOG(7, "partialDecoding: copying literals, close to input or output end")
+                    DEBUGLOG(7, "partialDecoding: literal length = %u", (unsigned)length);
+                    DEBUGLOG(7, "partialDecoding: remaining space in dstBuffer : %i", (int)(oend - op));
+                    DEBUGLOG(7, "partialDecoding: remaining space in srcBuffer : %i", (int)(iend - ip));
+                    /* Finishing in the middle of a literals segment,
+                     * due to lack of input.
+                     */
+                    if (ip+length > iend) {
+                        length = (size_t)(iend-ip);
+                        cpy = op + length;
+                    }
+                    /* Finishing in the middle of a literals segment,
+                     * due to lack of output space.
+                     */
+                    if (cpy > oend) {
+                        cpy = oend;
+                        assert(op<=oend);
+                        length = (size_t)(oend-op);
+                    }
+                } else {
+                     /* We must be on the last sequence (or invalid) because of the parsing limitations
+                      * so check that we exactly consume the input and don't overrun the output buffer.
+                      */
+                    if ((ip+length != iend) || (cpy > oend)) {
+                        DEBUGLOG(5, "should have been last run of literals")
+                        DEBUGLOG(5, "ip(%p) + length(%i) = %p != iend (%p)", ip, (int)length, ip+length, iend);
+                        DEBUGLOG(5, "or cpy(%p) > (oend-MFLIMIT)(%p)", cpy, oend-MFLIMIT);
+                        DEBUGLOG(5, "after writing %u bytes / %i bytes available", (unsigned)(op-(BYTE*)dst), outputSize);
+                        goto _output_error;
+                    }
+                }
+                LZ4_memmove(op, ip, length);  /* supports overlapping memory regions, for in-place decompression scenarios */
+                ip += length;
+                op += length;
+                /* Necessarily EOF when !partialDecoding.
+                 * When partialDecoding, it is EOF if we've either
+                 * filled the output buffer or
+                 * can't proceed with reading an offset for following match.
+                 */
+                if (!partialDecoding || (cpy == oend) || (ip >= (iend-2))) {
+                    break;
+                }
+            } else {
+                LZ4_wildCopy8(op, ip, cpy);   /* can overwrite up to 8 bytes beyond cpy */
+                ip += length; op = cpy;
+            }
+
+            /* get offset */
+            offset = LZ4_readLE16(ip); ip+=2;
+            match = op - offset;
+
+            /* get matchlength */
+            length = token & ML_MASK;
+            DEBUGLOG(7, "blockPos%6u: matchLength token = %u", (unsigned)(op-(BYTE*)dst), (unsigned)length);
+
+    _copy_match:
+            if (length == ML_MASK) {
+                size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0);
+                if (addl == rvl_error) { goto _output_error; }
+                length += addl;
+                if (unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error;   /* overflow detection */
+            }
+            length += MINMATCH;
+
+#if LZ4_FAST_DEC_LOOP
+        safe_match_copy:
+#endif
+            if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) goto _output_error;   /* Error : offset outside buffers */
+            /* match starting within external dictionary */
+            if ((dict==usingExtDict) && (match < lowPrefix)) {
+                assert(dictEnd != NULL);
+                if (unlikely(op+length > oend-LASTLITERALS)) {
+                    if (partialDecoding) length = MIN(length, (size_t)(oend-op));
+                    else goto _output_error;   /* doesn't respect parsing restriction */
+                }
+
+                if (length <= (size_t)(lowPrefix-match)) {
+                    /* match fits entirely within external dictionary : just copy */
+                    LZ4_memmove(op, dictEnd - (lowPrefix-match), length);
+                    op += length;
+                } else {
+                    /* match stretches into both external dictionary and current block */
+                    size_t const copySize = (size_t)(lowPrefix - match);
+                    size_t const restSize = length - copySize;
+                    LZ4_memcpy(op, dictEnd - copySize, copySize);
+                    op += copySize;
+                    if (restSize > (size_t)(op - lowPrefix)) {  /* overlap copy */
+                        BYTE* const endOfMatch = op + restSize;
+                        const BYTE* copyFrom = lowPrefix;
+                        while (op < endOfMatch) *op++ = *copyFrom++;
+                    } else {
+                        LZ4_memcpy(op, lowPrefix, restSize);
+                        op += restSize;
+                }   }
+                continue;
+            }
+            assert(match >= lowPrefix);
+
+            /* copy match within block */
+            cpy = op + length;
+
+            /* partialDecoding : may end anywhere within the block */
+            assert(op<=oend);
+            if (partialDecoding && (cpy > oend-MATCH_SAFEGUARD_DISTANCE)) {
+                size_t const mlen = MIN(length, (size_t)(oend-op));
+                const BYTE* const matchEnd = match + mlen;
+                BYTE* const copyEnd = op + mlen;
+                if (matchEnd > op) {   /* overlap copy */
+                    while (op < copyEnd) { *op++ = *match++; }
+                } else {
+                    LZ4_memcpy(op, match, mlen);
+                }
+                op = copyEnd;
+                if (op == oend) { break; }
+                continue;
+            }
+
+            if (unlikely(offset<8)) {
+                LZ4_write32(op, 0);   /* silence msan warning when offset==0 */
+                op[0] = match[0];
+                op[1] = match[1];
+                op[2] = match[2];
+                op[3] = match[3];
+                match += inc32table[offset];
+                LZ4_memcpy(op+4, match, 4);
+                match -= dec64table[offset];
+            } else {
+                LZ4_memcpy(op, match, 8);
+                match += 8;
+            }
+            op += 8;
+
+            if (unlikely(cpy > oend-MATCH_SAFEGUARD_DISTANCE)) {
+                BYTE* const oCopyLimit = oend - (WILDCOPYLENGTH-1);
+                if (cpy > oend-LASTLITERALS) { goto _output_error; } /* Error : last LASTLITERALS bytes must be literals (uncompressed) */
+                if (op < oCopyLimit) {
+                    LZ4_wildCopy8(op, match, oCopyLimit);
+                    match += oCopyLimit - op;
+                    op = oCopyLimit;
+                }
+                while (op < cpy) { *op++ = *match++; }
+            } else {
+                LZ4_memcpy(op, match, 8);
+                if (length > 16) { LZ4_wildCopy8(op+8, match+8, cpy); }
+            }
+            op = cpy;   /* wildcopy correction */
+        }
+
+        /* end of decoding */
+        DEBUGLOG(5, "decoded %i bytes", (int) (((char*)op)-dst));
+        return (int) (((char*)op)-dst);     /* Nb of output bytes decoded */
+
+        /* Overflow error detected */
+    _output_error:
+        return (int) (-(((const char*)ip)-src))-1;
+    }
+}
+
+
+/*===== Instantiate the API decoding functions. =====*/
+
+LZ4_FORCE_O2
+int LZ4_decompress_safe(const char* source, char* dest, int compressedSize, int maxDecompressedSize)
+{
+    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize,
+                                  decode_full_block, noDict,
+                                  (BYTE*)dest, NULL, 0);
+}
+
+LZ4_FORCE_O2
+int LZ4_decompress_safe_partial(const char* src, char* dst, int compressedSize, int targetOutputSize, int dstCapacity)
+{
+    dstCapacity = MIN(targetOutputSize, dstCapacity);
+    return LZ4_decompress_generic(src, dst, compressedSize, dstCapacity,
+                                  partial_decode,
+                                  noDict, (BYTE*)dst, NULL, 0);
+}
+
+LZ4_FORCE_O2
+int LZ4_decompress_fast(const char* source, char* dest, int originalSize)
+{
+    DEBUGLOG(5, "LZ4_decompress_fast");
+    return LZ4_decompress_unsafe_generic(
+                (const BYTE*)source, (BYTE*)dest, originalSize,
+                0, NULL, 0);
+}
+
+/*===== Instantiate a few more decoding cases, used more than once. =====*/
+
+LZ4_FORCE_O2 /* Exported, an obsolete API function. */
+int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize)
+{
+    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
+                                  decode_full_block, withPrefix64k,
+                                  (BYTE*)dest - 64 KB, NULL, 0);
+}
+
+LZ4_FORCE_O2
+static int LZ4_decompress_safe_partial_withPrefix64k(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity)
+{
+    dstCapacity = MIN(targetOutputSize, dstCapacity);
+    return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity,
+                                  partial_decode, withPrefix64k,
+                                  (BYTE*)dest - 64 KB, NULL, 0);
+}
+
+/* Another obsolete API function, paired with the previous one. */
+int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize)
+{
+    return LZ4_decompress_unsafe_generic(
+                (const BYTE*)source, (BYTE*)dest, originalSize,
+                64 KB, NULL, 0);
+}
+
+LZ4_FORCE_O2
+static int LZ4_decompress_safe_withSmallPrefix(const char* source, char* dest, int compressedSize, int maxOutputSize,
+                                               size_t prefixSize)
+{
+    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
+                                  decode_full_block, noDict,
+                                  (BYTE*)dest-prefixSize, NULL, 0);
+}
+
+LZ4_FORCE_O2
+static int LZ4_decompress_safe_partial_withSmallPrefix(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity,
+                                               size_t prefixSize)
+{
+    dstCapacity = MIN(targetOutputSize, dstCapacity);
+    return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity,
+                                  partial_decode, noDict,
+                                  (BYTE*)dest-prefixSize, NULL, 0);
+}
+
+LZ4_FORCE_O2
+int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,
+                                     int compressedSize, int maxOutputSize,
+                                     const void* dictStart, size_t dictSize)
+{
+    DEBUGLOG(5, "LZ4_decompress_safe_forceExtDict");
+    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
+                                  decode_full_block, usingExtDict,
+                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
+}
+
+LZ4_FORCE_O2
+int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest,
+                                     int compressedSize, int targetOutputSize, int dstCapacity,
+                                     const void* dictStart, size_t dictSize)
+{
+    dstCapacity = MIN(targetOutputSize, dstCapacity);
+    return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity,
+                                  partial_decode, usingExtDict,
+                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
+}
+
+LZ4_FORCE_O2
+static int LZ4_decompress_fast_extDict(const char* source, char* dest, int originalSize,
+                                       const void* dictStart, size_t dictSize)
+{
+    return LZ4_decompress_unsafe_generic(
+                (const BYTE*)source, (BYTE*)dest, originalSize,
+                0, (const BYTE*)dictStart, dictSize);
+}
+
+/* The "double dictionary" mode, for use with e.g. ring buffers: the first part
+ * of the dictionary is passed as prefix, and the second via dictStart + dictSize.
+ * These routines are used only once, in LZ4_decompress_*_continue().
+ */
+LZ4_FORCE_INLINE
+int LZ4_decompress_safe_doubleDict(const char* source, char* dest, int compressedSize, int maxOutputSize,
+                                   size_t prefixSize, const void* dictStart, size_t dictSize)
+{
+    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
+                                  decode_full_block, usingExtDict,
+                                  (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize);
+}
+
+/*===== streaming decompression functions =====*/
+
+#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
+LZ4_streamDecode_t* LZ4_createStreamDecode(void)
+{
+    LZ4_STATIC_ASSERT(sizeof(LZ4_streamDecode_t) >= sizeof(LZ4_streamDecode_t_internal));
+    return (LZ4_streamDecode_t*) ALLOC_AND_ZERO(sizeof(LZ4_streamDecode_t));
+}
+
+int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
+{
+    if (LZ4_stream == NULL) { return 0; }  /* support free on NULL */
+    FREEMEM(LZ4_stream);
+    return 0;
+}
+#endif
+
+/*! LZ4_setStreamDecode() :
+ *  Use this function to instruct where to find the dictionary.
+ *  This function is not necessary if previous data is still available where it was decoded.
+ *  Loading a size of 0 is allowed (same effect as no dictionary).
+ * @return : 1 if OK, 0 if error
+ */
+int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
+{
+    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
+    lz4sd->prefixSize = (size_t)dictSize;
+    if (dictSize) {
+        assert(dictionary != NULL);
+        lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
+    } else {
+        lz4sd->prefixEnd = (const BYTE*) dictionary;
+    }
+    lz4sd->externalDict = NULL;
+    lz4sd->extDictSize  = 0;
+    return 1;
+}
+
+/*! LZ4_decoderRingBufferSize() :
+ *  when setting a ring buffer for streaming decompression (optional scenario),
+ *  provides the minimum size of this ring buffer
+ *  to be compatible with any source respecting maxBlockSize condition.
+ *  Note : in a ring buffer scenario,
+ *  blocks are presumed decompressed next to each other.
+ *  When not enough space remains for next block (remainingSize < maxBlockSize),
+ *  decoding resumes from beginning of ring buffer.
+ * @return : minimum ring buffer size,
+ *           or 0 if there is an error (invalid maxBlockSize).
+ */
+int LZ4_decoderRingBufferSize(int maxBlockSize)
+{
+    if (maxBlockSize < 0) return 0;
+    if (maxBlockSize > LZ4_MAX_INPUT_SIZE) return 0;
+    if (maxBlockSize < 16) maxBlockSize = 16;
+    return LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize);
+}
+
+/*
+*_continue() :
+    These decoding functions allow decompression of multiple blocks in "streaming" mode.
+    Previously decoded blocks must still be available at the memory position where they were decoded.
+    If it's not possible, save the relevant part of decoded data into a safe buffer,
+    and indicate where it stands using LZ4_setStreamDecode()
+*/
+LZ4_FORCE_O2
+int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxOutputSize)
+{
+    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
+    int result;
+
+    if (lz4sd->prefixSize == 0) {
+        /* The first call, no dictionary yet. */
+        assert(lz4sd->extDictSize == 0);
+        result = LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
+        if (result <= 0) return result;
+        lz4sd->prefixSize = (size_t)result;
+        lz4sd->prefixEnd = (BYTE*)dest + result;
+    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
+        /* They're rolling the current segment. */
+        if (lz4sd->prefixSize >= 64 KB - 1)
+            result = LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
+        else if (lz4sd->extDictSize == 0)
+            result = LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize,
+                                                         lz4sd->prefixSize);
+        else
+            result = LZ4_decompress_safe_doubleDict(source, dest, compressedSize, maxOutputSize,
+                                                    lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
+        if (result <= 0) return result;
+        lz4sd->prefixSize += (size_t)result;
+        lz4sd->prefixEnd  += result;
+    } else {
+        /* The buffer wraps around, or they're switching to another buffer. */
+        lz4sd->extDictSize = lz4sd->prefixSize;
+        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
+        result = LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize,
+                                                  lz4sd->externalDict, lz4sd->extDictSize);
+        if (result <= 0) return result;
+        lz4sd->prefixSize = (size_t)result;
+        lz4sd->prefixEnd  = (BYTE*)dest + result;
+    }
+
+    return result;
+}
+
+LZ4_FORCE_O2 int
+LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode,
+                        const char* source, char* dest, int originalSize)
+{
+    LZ4_streamDecode_t_internal* const lz4sd =
+        (assert(LZ4_streamDecode!=NULL), &LZ4_streamDecode->internal_donotuse);
+    int result;
+
+    DEBUGLOG(5, "LZ4_decompress_fast_continue (toDecodeSize=%i)", originalSize);
+    assert(originalSize >= 0);
+
+    if (lz4sd->prefixSize == 0) {
+        DEBUGLOG(5, "first invocation : no prefix nor extDict");
+        assert(lz4sd->extDictSize == 0);
+        result = LZ4_decompress_fast(source, dest, originalSize);
+        if (result <= 0) return result;
+        lz4sd->prefixSize = (size_t)originalSize;
+        lz4sd->prefixEnd = (BYTE*)dest + originalSize;
+    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
+        DEBUGLOG(5, "continue using existing prefix");
+        result = LZ4_decompress_unsafe_generic(
+                        (const BYTE*)source, (BYTE*)dest, originalSize,
+                        lz4sd->prefixSize,
+                        lz4sd->externalDict, lz4sd->extDictSize);
+        if (result <= 0) return result;
+        lz4sd->prefixSize += (size_t)originalSize;
+        lz4sd->prefixEnd  += originalSize;
+    } else {
+        DEBUGLOG(5, "prefix becomes extDict");
+        lz4sd->extDictSize = lz4sd->prefixSize;
+        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
+        result = LZ4_decompress_fast_extDict(source, dest, originalSize,
+                                             lz4sd->externalDict, lz4sd->extDictSize);
+        if (result <= 0) return result;
+        lz4sd->prefixSize = (size_t)originalSize;
+        lz4sd->prefixEnd  = (BYTE*)dest + originalSize;
+    }
+
+    return result;
+}
+
+
+/*
+Advanced decoding functions :
+*_usingDict() :
+    These decoding functions work the same as "_continue" ones,
+    the dictionary must be explicitly provided within parameters
+*/
+
+int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
+{
+    if (dictSize==0)
+        return LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
+    if (dictStart+dictSize == dest) {
+        if (dictSize >= 64 KB - 1) {
+            return LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
+        }
+        assert(dictSize >= 0);
+        return LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize, (size_t)dictSize);
+    }
+    assert(dictSize >= 0);
+    return LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, dictStart, (size_t)dictSize);
+}
+
+int LZ4_decompress_safe_partial_usingDict(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity, const char* dictStart, int dictSize)
+{
+    if (dictSize==0)
+        return LZ4_decompress_safe_partial(source, dest, compressedSize, targetOutputSize, dstCapacity);
+    if (dictStart+dictSize == dest) {
+        if (dictSize >= 64 KB - 1) {
+            return LZ4_decompress_safe_partial_withPrefix64k(source, dest, compressedSize, targetOutputSize, dstCapacity);
+        }
+        assert(dictSize >= 0);
+        return LZ4_decompress_safe_partial_withSmallPrefix(source, dest, compressedSize, targetOutputSize, dstCapacity, (size_t)dictSize);
+    }
+    assert(dictSize >= 0);
+    return LZ4_decompress_safe_partial_forceExtDict(source, dest, compressedSize, targetOutputSize, dstCapacity, dictStart, (size_t)dictSize);
+}
+
+int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSize, const char* dictStart, int dictSize)
+{
+    if (dictSize==0 || dictStart+dictSize == dest)
+        return LZ4_decompress_unsafe_generic(
+                        (const BYTE*)source, (BYTE*)dest, originalSize,
+                        (size_t)dictSize, NULL, 0);
+    assert(dictSize >= 0);
+    return LZ4_decompress_fast_extDict(source, dest, originalSize, dictStart, (size_t)dictSize);
+}
+
+
+/*=*************************************************
+*  Obsolete Functions
+***************************************************/
+/* obsolete compression functions */
+int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize)
+{
+    return LZ4_compress_default(source, dest, inputSize, maxOutputSize);
+}
+int LZ4_compress(const char* src, char* dest, int srcSize)
+{
+    return LZ4_compress_default(src, dest, srcSize, LZ4_compressBound(srcSize));
+}
+int LZ4_compress_limitedOutput_withState (void* state, const char* src, char* dst, int srcSize, int dstSize)
+{
+    return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1);
+}
+int LZ4_compress_withState (void* state, const char* src, char* dst, int srcSize)
+{
+    return LZ4_compress_fast_extState(state, src, dst, srcSize, LZ4_compressBound(srcSize), 1);
+}
+int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_stream, const char* src, char* dst, int srcSize, int dstCapacity)
+{
+    return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, dstCapacity, 1);
+}
+int LZ4_compress_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize)
+{
+    return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize, LZ4_compressBound(inputSize), 1);
+}
+
+/*
+These decompression functions are deprecated and should no longer be used.
+They are only provided here for compatibility with older user programs.
+- LZ4_uncompress is totally equivalent to LZ4_decompress_fast
+- LZ4_uncompress_unknownOutputSize is totally equivalent to LZ4_decompress_safe
+*/
+int LZ4_uncompress (const char* source, char* dest, int outputSize)
+{
+    return LZ4_decompress_fast(source, dest, outputSize);
+}
+int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize)
+{
+    return LZ4_decompress_safe(source, dest, isize, maxOutputSize);
+}
+
+/* Obsolete Streaming functions */
+
+int LZ4_sizeofStreamState(void) { return sizeof(LZ4_stream_t); }
+
+int LZ4_resetStreamState(void* state, char* inputBuffer)
+{
+    (void)inputBuffer;
+    LZ4_resetStream((LZ4_stream_t*)state);
+    return 0;
+}
+
+#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
+void* LZ4_create (char* inputBuffer)
+{
+    (void)inputBuffer;
+    return LZ4_createStream();
+}
+#endif
+
+char* LZ4_slideInputBuffer (void* state)
+{
+    /* avoid const char * -> char * conversion warning */
+    return (char *)(uptrval)((LZ4_stream_t*)state)->internal_donotuse.dictionary;
+}
+
+#endif   /* LZ4_COMMONDEFS_ONLY */
diff --git a/native/lz4/vendor/lib/lz4.h b/native/lz4/vendor/lib/lz4.h
new file mode 100644
index 0000000..80e3e5c
--- /dev/null
+++ b/native/lz4/vendor/lib/lz4.h
@@ -0,0 +1,884 @@
+/*
+ *  LZ4 - Fast LZ compression algorithm
+ *  Header File
+ *  Copyright (C) 2011-2023, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+    - LZ4 homepage : http://www.lz4.org
+    - LZ4 source repository : https://github.com/lz4/lz4
+*/
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#ifndef LZ4_H_2983827168210
+#define LZ4_H_2983827168210
+
+/* --- Dependency --- */
+#include <stddef.h>   /* size_t */
+
+
+/**
+  Introduction
+
+  LZ4 is lossless compression algorithm, providing compression speed >500 MB/s per core,
+  scalable with multi-cores CPU. It features an extremely fast decoder, with speed in
+  multiple GB/s per core, typically reaching RAM speed limits on multi-core systems.
+
+  The LZ4 compression library provides in-memory compression and decompression functions.
+  It gives full buffer control to user.
+  Compression can be done in:
+    - a single step (described as Simple Functions)
+    - a single step, reusing a context (described in Advanced Functions)
+    - unbounded multiple steps (described as Streaming compression)
+
+  lz4.h generates and decodes LZ4-compressed blocks (doc/lz4_Block_format.md).
+  Decompressing such a compressed block requires additional metadata.
+  Exact metadata depends on exact decompression function.
+  For the typical case of LZ4_decompress_safe(),
+  metadata includes block's compressed size, and maximum bound of decompressed size.
+  Each application is free to encode and pass such metadata in whichever way it wants.
+
+  lz4.h only handle blocks, it can not generate Frames.
+
+  Blocks are different from Frames (doc/lz4_Frame_format.md).
+  Frames bundle both blocks and metadata in a specified manner.
+  Embedding metadata is required for compressed data to be self-contained and portable.
+  Frame format is delivered through a companion API, declared in lz4frame.h.
+  The `lz4` CLI can only manage frames.
+*/
+
+/*^***************************************************************
+*  Export parameters
+*****************************************************************/
+/*
+*  LZ4_DLL_EXPORT :
+*  Enable exporting of functions when building a Windows DLL
+*  LZ4LIB_VISIBILITY :
+*  Control library symbols visibility.
+*/
+#ifndef LZ4LIB_VISIBILITY
+#  if defined(__GNUC__) && (__GNUC__ >= 4)
+#    define LZ4LIB_VISIBILITY __attribute__ ((visibility ("default")))
+#  else
+#    define LZ4LIB_VISIBILITY
+#  endif
+#endif
+#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
+#  define LZ4LIB_API __declspec(dllexport) LZ4LIB_VISIBILITY
+#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
+#  define LZ4LIB_API __declspec(dllimport) LZ4LIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
+#else
+#  define LZ4LIB_API LZ4LIB_VISIBILITY
+#endif
+
+/*! LZ4_FREESTANDING :
+ *  When this macro is set to 1, it enables "freestanding mode" that is
+ *  suitable for typical freestanding environment which doesn't support
+ *  standard C library.
+ *
+ *  - LZ4_FREESTANDING is a compile-time switch.
+ *  - It requires the following macros to be defined:
+ *    LZ4_memcpy, LZ4_memmove, LZ4_memset.
+ *  - It only enables LZ4/HC functions which don't use heap.
+ *    All LZ4F_* functions are not supported.
+ *  - See tests/freestanding.c to check its basic setup.
+ */
+#if defined(LZ4_FREESTANDING) && (LZ4_FREESTANDING == 1)
+#  define LZ4_HEAPMODE 0
+#  define LZ4HC_HEAPMODE 0
+#  define LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION 1
+#  if !defined(LZ4_memcpy)
+#    error "LZ4_FREESTANDING requires macro 'LZ4_memcpy'."
+#  endif
+#  if !defined(LZ4_memset)
+#    error "LZ4_FREESTANDING requires macro 'LZ4_memset'."
+#  endif
+#  if !defined(LZ4_memmove)
+#    error "LZ4_FREESTANDING requires macro 'LZ4_memmove'."
+#  endif
+#elif ! defined(LZ4_FREESTANDING)
+#  define LZ4_FREESTANDING 0
+#endif
+
+
+/*------   Version   ------*/
+#define LZ4_VERSION_MAJOR    1    /* for breaking interface changes  */
+#define LZ4_VERSION_MINOR   10    /* for new (non-breaking) interface capabilities */
+#define LZ4_VERSION_RELEASE  0    /* for tweaks, bug-fixes, or development */
+
+#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
+
+#define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE
+#define LZ4_QUOTE(str) #str
+#define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str)
+#define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION)  /* requires v1.7.3+ */
+
+LZ4LIB_API int LZ4_versionNumber (void);  /**< library version number; useful to check dll version; requires v1.3.0+ */
+LZ4LIB_API const char* LZ4_versionString (void);   /**< library version string; useful to check dll version; requires v1.7.5+ */
+
+
+/*-************************************
+*  Tuning memory usage
+**************************************/
+/*!
+ * LZ4_MEMORY_USAGE :
+ * Can be selected at compile time, by setting LZ4_MEMORY_USAGE.
+ * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB)
+ * Increasing memory usage improves compression ratio, generally at the cost of speed.
+ * Reduced memory usage may improve speed at the cost of ratio, thanks to better cache locality.
+ * Default value is 14, for 16KB, which nicely fits into most L1 caches.
+ */
+#ifndef LZ4_MEMORY_USAGE
+# define LZ4_MEMORY_USAGE LZ4_MEMORY_USAGE_DEFAULT
+#endif
+
+/* These are absolute limits, they should not be changed by users */
+#define LZ4_MEMORY_USAGE_MIN 10
+#define LZ4_MEMORY_USAGE_DEFAULT 14
+#define LZ4_MEMORY_USAGE_MAX 20
+
+#if (LZ4_MEMORY_USAGE < LZ4_MEMORY_USAGE_MIN)
+#  error "LZ4_MEMORY_USAGE is too small !"
+#endif
+
+#if (LZ4_MEMORY_USAGE > LZ4_MEMORY_USAGE_MAX)
+#  error "LZ4_MEMORY_USAGE is too large !"
+#endif
+
+/*-************************************
+*  Simple Functions
+**************************************/
+/*! LZ4_compress_default() :
+ *  Compresses 'srcSize' bytes from buffer 'src'
+ *  into already allocated 'dst' buffer of size 'dstCapacity'.
+ *  Compression is guaranteed to succeed if 'dstCapacity' >= LZ4_compressBound(srcSize).
+ *  It also runs faster, so it's a recommended setting.
+ *  If the function cannot compress 'src' into a more limited 'dst' budget,
+ *  compression stops *immediately*, and the function result is zero.
+ *  In which case, 'dst' content is undefined (invalid).
+ *      srcSize : max supported value is LZ4_MAX_INPUT_SIZE.
+ *      dstCapacity : size of buffer 'dst' (which must be already allocated)
+ *     @return  : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity)
+ *                or 0 if compression fails
+ * Note : This function is protected against buffer overflow scenarios (never writes outside 'dst' buffer, nor read outside 'source' buffer).
+ */
+LZ4LIB_API int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity);
+
+/*! LZ4_decompress_safe() :
+ * @compressedSize : is the exact complete size of the compressed block.
+ * @dstCapacity : is the size of destination buffer (which must be already allocated),
+ *                presumed an upper bound of decompressed size.
+ * @return : the number of bytes decompressed into destination buffer (necessarily <= dstCapacity)
+ *           If destination buffer is not large enough, decoding will stop and output an error code (negative value).
+ *           If the source stream is detected malformed, the function will stop decoding and return a negative result.
+ * Note 1 : This function is protected against malicious data packets :
+ *          it will never writes outside 'dst' buffer, nor read outside 'source' buffer,
+ *          even if the compressed block is maliciously modified to order the decoder to do these actions.
+ *          In such case, the decoder stops immediately, and considers the compressed block malformed.
+ * Note 2 : compressedSize and dstCapacity must be provided to the function, the compressed block does not contain them.
+ *          The implementation is free to send / store / derive this information in whichever way is most beneficial.
+ *          If there is a need for a different format which bundles together both compressed data and its metadata, consider looking at lz4frame.h instead.
+ */
+LZ4LIB_API int LZ4_decompress_safe (const char* src, char* dst, int compressedSize, int dstCapacity);
+
+
+/*-************************************
+*  Advanced Functions
+**************************************/
+#define LZ4_MAX_INPUT_SIZE        0x7E000000   /* 2 113 929 216 bytes */
+#define LZ4_COMPRESSBOUND(isize)  ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
+
+/*! LZ4_compressBound() :
+    Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
+    This function is primarily useful for memory allocation purposes (destination buffer size).
+    Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
+    Note that LZ4_compress_default() compresses faster when dstCapacity is >= LZ4_compressBound(srcSize)
+        inputSize  : max supported value is LZ4_MAX_INPUT_SIZE
+        return : maximum output size in a "worst case" scenario
+              or 0, if input size is incorrect (too large or negative)
+*/
+LZ4LIB_API int LZ4_compressBound(int inputSize);
+
+/*! LZ4_compress_fast() :
+    Same as LZ4_compress_default(), but allows selection of "acceleration" factor.
+    The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
+    It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
+    An acceleration value of "1" is the same as regular LZ4_compress_default()
+    Values <= 0 will be replaced by LZ4_ACCELERATION_DEFAULT (currently == 1, see lz4.c).
+    Values > LZ4_ACCELERATION_MAX will be replaced by LZ4_ACCELERATION_MAX (currently == 65537, see lz4.c).
+*/
+LZ4LIB_API int LZ4_compress_fast (const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
+
+
+/*! LZ4_compress_fast_extState() :
+ *  Same as LZ4_compress_fast(), using an externally allocated memory space for its state.
+ *  Use LZ4_sizeofState() to know how much memory must be allocated,
+ *  and allocate it on 8-bytes boundaries (using `malloc()` typically).
+ *  Then, provide this buffer as `void* state` to compression function.
+ */
+LZ4LIB_API int LZ4_sizeofState(void);
+LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
+
+/*! LZ4_compress_destSize() :
+ *  Reverse the logic : compresses as much data as possible from 'src' buffer
+ *  into already allocated buffer 'dst', of size >= 'dstCapacity'.
+ *  This function either compresses the entire 'src' content into 'dst' if it's large enough,
+ *  or fill 'dst' buffer completely with as much data as possible from 'src'.
+ *  note: acceleration parameter is fixed to "default".
+ *
+ * *srcSizePtr : in+out parameter. Initially contains size of input.
+ *               Will be modified to indicate how many bytes where read from 'src' to fill 'dst'.
+ *               New value is necessarily <= input value.
+ * @return : Nb bytes written into 'dst' (necessarily <= dstCapacity)
+ *           or 0 if compression fails.
+ *
+ * Note : from v1.8.2 to v1.9.1, this function had a bug (fixed in v1.9.2+):
+ *        the produced compressed content could, in specific circumstances,
+ *        require to be decompressed into a destination buffer larger
+ *        by at least 1 byte than the content to decompress.
+ *        If an application uses `LZ4_compress_destSize()`,
+ *        it's highly recommended to update liblz4 to v1.9.2 or better.
+ *        If this can't be done or ensured,
+ *        the receiving decompression function should provide
+ *        a dstCapacity which is > decompressedSize, by at least 1 byte.
+ *        See https://github.com/lz4/lz4/issues/859 for details
+ */
+LZ4LIB_API int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize);
+
+/*! LZ4_decompress_safe_partial() :
+ *  Decompress an LZ4 compressed block, of size 'srcSize' at position 'src',
+ *  into destination buffer 'dst' of size 'dstCapacity'.
+ *  Up to 'targetOutputSize' bytes will be decoded.
+ *  The function stops decoding on reaching this objective.
+ *  This can be useful to boost performance
+ *  whenever only the beginning of a block is required.
+ *
+ * @return : the number of bytes decoded in `dst` (necessarily <= targetOutputSize)
+ *           If source stream is detected malformed, function returns a negative result.
+ *
+ *  Note 1 : @return can be < targetOutputSize, if compressed block contains less data.
+ *
+ *  Note 2 : targetOutputSize must be <= dstCapacity
+ *
+ *  Note 3 : this function effectively stops decoding on reaching targetOutputSize,
+ *           so dstCapacity is kind of redundant.
+ *           This is because in older versions of this function,
+ *           decoding operation would still write complete sequences.
+ *           Therefore, there was no guarantee that it would stop writing at exactly targetOutputSize,
+ *           it could write more bytes, though only up to dstCapacity.
+ *           Some "margin" used to be required for this operation to work properly.
+ *           Thankfully, this is no longer necessary.
+ *           The function nonetheless keeps the same signature, in an effort to preserve API compatibility.
+ *
+ *  Note 4 : If srcSize is the exact size of the block,
+ *           then targetOutputSize can be any value,
+ *           including larger than the block's decompressed size.
+ *           The function will, at most, generate block's decompressed size.
+ *
+ *  Note 5 : If srcSize is _larger_ than block's compressed size,
+ *           then targetOutputSize **MUST** be <= block's decompressed size.
+ *           Otherwise, *silent corruption will occur*.
+ */
+LZ4LIB_API int LZ4_decompress_safe_partial (const char* src, char* dst, int srcSize, int targetOutputSize, int dstCapacity);
+
+
+/*-*********************************************
+*  Streaming Compression Functions
+***********************************************/
+typedef union LZ4_stream_u LZ4_stream_t;  /* incomplete type (defined later) */
+
+/*!
+ Note about RC_INVOKED
+
+ - RC_INVOKED is predefined symbol of rc.exe (the resource compiler which is part of MSVC/Visual Studio).
+   https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros
+
+ - Since rc.exe is a legacy compiler, it truncates long symbol (> 30 chars)
+   and reports warning "RC4011: identifier truncated".
+
+ - To eliminate the warning, we surround long preprocessor symbol with
+   "#if !defined(RC_INVOKED) ... #endif" block that means
+   "skip this block when rc.exe is trying to read it".
+*/
+#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */
+#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
+LZ4LIB_API LZ4_stream_t* LZ4_createStream(void);
+LZ4LIB_API int           LZ4_freeStream (LZ4_stream_t* streamPtr);
+#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */
+#endif
+
+/*! LZ4_resetStream_fast() : v1.9.0+
+ *  Use this to prepare an LZ4_stream_t for a new chain of dependent blocks
+ *  (e.g., LZ4_compress_fast_continue()).
+ *
+ *  An LZ4_stream_t must be initialized once before usage.
+ *  This is automatically done when created by LZ4_createStream().
+ *  However, should the LZ4_stream_t be simply declared on stack (for example),
+ *  it's necessary to initialize it first, using LZ4_initStream().
+ *
+ *  After init, start any new stream with LZ4_resetStream_fast().
+ *  A same LZ4_stream_t can be re-used multiple times consecutively
+ *  and compress multiple streams,
+ *  provided that it starts each new stream with LZ4_resetStream_fast().
+ *
+ *  LZ4_resetStream_fast() is much faster than LZ4_initStream(),
+ *  but is not compatible with memory regions containing garbage data.
+ *
+ *  Note: it's only useful to call LZ4_resetStream_fast()
+ *        in the context of streaming compression.
+ *        The *extState* functions perform their own resets.
+ *        Invoking LZ4_resetStream_fast() before is redundant, and even counterproductive.
+ */
+LZ4LIB_API void LZ4_resetStream_fast (LZ4_stream_t* streamPtr);
+
+/*! LZ4_loadDict() :
+ *  Use this function to reference a static dictionary into LZ4_stream_t.
+ *  The dictionary must remain available during compression.
+ *  LZ4_loadDict() triggers a reset, so any previous data will be forgotten.
+ *  The same dictionary will have to be loaded on decompression side for successful decoding.
+ *  Dictionary are useful for better compression of small data (KB range).
+ *  While LZ4 itself accepts any input as dictionary, dictionary efficiency is also a topic.
+ *  When in doubt, employ the Zstandard's Dictionary Builder.
+ *  Loading a size of 0 is allowed, and is the same as reset.
+ * @return : loaded dictionary size, in bytes (note: only the last 64 KB are loaded)
+ */
+LZ4LIB_API int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
+
+/*! LZ4_loadDictSlow() : v1.10.0+
+ *  Same as LZ4_loadDict(),
+ *  but uses a bit more cpu to reference the dictionary content more thoroughly.
+ *  This is expected to slightly improve compression ratio.
+ *  The extra-cpu cost is likely worth it if the dictionary is re-used across multiple sessions.
+ * @return : loaded dictionary size, in bytes (note: only the last 64 KB are loaded)
+ */
+LZ4LIB_API int LZ4_loadDictSlow(LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
+
+/*! LZ4_attach_dictionary() : stable since v1.10.0
+ *
+ *  This allows efficient re-use of a static dictionary multiple times.
+ *
+ *  Rather than re-loading the dictionary buffer into a working context before
+ *  each compression, or copying a pre-loaded dictionary's LZ4_stream_t into a
+ *  working LZ4_stream_t, this function introduces a no-copy setup mechanism,
+ *  in which the working stream references @dictionaryStream in-place.
+ *
+ *  Several assumptions are made about the state of @dictionaryStream.
+ *  Currently, only states which have been prepared by LZ4_loadDict() or
+ *  LZ4_loadDictSlow() should be expected to work.
+ *
+ *  Alternatively, the provided @dictionaryStream may be NULL,
+ *  in which case any existing dictionary stream is unset.
+ *
+ *  If a dictionary is provided, it replaces any pre-existing stream history.
+ *  The dictionary contents are the only history that can be referenced and
+ *  logically immediately precede the data compressed in the first subsequent
+ *  compression call.
+ *
+ *  The dictionary will only remain attached to the working stream through the
+ *  first compression call, at the end of which it is cleared.
+ * @dictionaryStream stream (and source buffer) must remain in-place / accessible / unchanged
+ *  through the completion of the compression session.
+ *
+ *  Note: there is no equivalent LZ4_attach_*() method on the decompression side
+ *  because there is no initialization cost, hence no need to share the cost across multiple sessions.
+ *  To decompress LZ4 blocks using dictionary, attached or not,
+ *  just employ the regular LZ4_setStreamDecode() for streaming,
+ *  or the stateless LZ4_decompress_safe_usingDict() for one-shot decompression.
+ */
+LZ4LIB_API void
+LZ4_attach_dictionary(LZ4_stream_t* workingStream,
+                const LZ4_stream_t* dictionaryStream);
+
+/*! LZ4_compress_fast_continue() :
+ *  Compress 'src' content using data from previously compressed blocks, for better compression ratio.
+ * 'dst' buffer must be already allocated.
+ *  If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
+ *
+ * @return : size of compressed block
+ *           or 0 if there is an error (typically, cannot fit into 'dst').
+ *
+ *  Note 1 : Each invocation to LZ4_compress_fast_continue() generates a new block.
+ *           Each block has precise boundaries.
+ *           Each block must be decompressed separately, calling LZ4_decompress_*() with relevant metadata.
+ *           It's not possible to append blocks together and expect a single invocation of LZ4_decompress_*() to decompress them together.
+ *
+ *  Note 2 : The previous 64KB of source data is __assumed__ to remain present, unmodified, at same address in memory !
+ *
+ *  Note 3 : When input is structured as a double-buffer, each buffer can have any size, including < 64 KB.
+ *           Make sure that buffers are separated, by at least one byte.
+ *           This construction ensures that each block only depends on previous block.
+ *
+ *  Note 4 : If input buffer is a ring-buffer, it can have any size, including < 64 KB.
+ *
+ *  Note 5 : After an error, the stream status is undefined (invalid), it can only be reset or freed.
+ */
+LZ4LIB_API int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
+
+/*! LZ4_saveDict() :
+ *  If last 64KB data cannot be guaranteed to remain available at its current memory location,
+ *  save it into a safer place (char* safeBuffer).
+ *  This is schematically equivalent to a memcpy() followed by LZ4_loadDict(),
+ *  but is much faster, because LZ4_saveDict() doesn't need to rebuild tables.
+ * @return : saved dictionary size in bytes (necessarily <= maxDictSize), or 0 if error.
+ */
+LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int maxDictSize);
+
+
+/*-**********************************************
+*  Streaming Decompression Functions
+*  Bufferless synchronous API
+************************************************/
+typedef union LZ4_streamDecode_u LZ4_streamDecode_t;   /* tracking context */
+
+/*! LZ4_createStreamDecode() and LZ4_freeStreamDecode() :
+ *  creation / destruction of streaming decompression tracking context.
+ *  A tracking context can be re-used multiple times.
+ */
+#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */
+#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
+LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void);
+LZ4LIB_API int                 LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
+#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */
+#endif
+
+/*! LZ4_setStreamDecode() :
+ *  An LZ4_streamDecode_t context can be allocated once and re-used multiple times.
+ *  Use this function to start decompression of a new stream of blocks.
+ *  A dictionary can optionally be set. Use NULL or size 0 for a reset order.
+ *  Dictionary is presumed stable : it must remain accessible and unmodified during next decompression.
+ * @return : 1 if OK, 0 if error
+ */
+LZ4LIB_API int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
+
+/*! LZ4_decoderRingBufferSize() : v1.8.2+
+ *  Note : in a ring buffer scenario (optional),
+ *  blocks are presumed decompressed next to each other
+ *  up to the moment there is not enough remaining space for next block (remainingSize < maxBlockSize),
+ *  at which stage it resumes from beginning of ring buffer.
+ *  When setting such a ring buffer for streaming decompression,
+ *  provides the minimum size of this ring buffer
+ *  to be compatible with any source respecting maxBlockSize condition.
+ * @return : minimum ring buffer size,
+ *           or 0 if there is an error (invalid maxBlockSize).
+ */
+LZ4LIB_API int LZ4_decoderRingBufferSize(int maxBlockSize);
+#define LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize) (65536 + 14 + (maxBlockSize))  /* for static allocation; maxBlockSize presumed valid */
+
+/*! LZ4_decompress_safe_continue() :
+ *  This decoding function allows decompression of consecutive blocks in "streaming" mode.
+ *  The difference with the usual independent blocks is that
+ *  new blocks are allowed to find references into former blocks.
+ *  A block is an unsplittable entity, and must be presented entirely to the decompression function.
+ *  LZ4_decompress_safe_continue() only accepts one block at a time.
+ *  It's modeled after `LZ4_decompress_safe()` and behaves similarly.
+ *
+ * @LZ4_streamDecode : decompression state, tracking the position in memory of past data
+ * @compressedSize : exact complete size of one compressed block.
+ * @dstCapacity : size of destination buffer (which must be already allocated),
+ *                must be an upper bound of decompressed size.
+ * @return : number of bytes decompressed into destination buffer (necessarily <= dstCapacity)
+ *           If destination buffer is not large enough, decoding will stop and output an error code (negative value).
+ *           If the source stream is detected malformed, the function will stop decoding and return a negative result.
+ *
+ *  The last 64KB of previously decoded data *must* remain available and unmodified
+ *  at the memory position where they were previously decoded.
+ *  If less than 64KB of data has been decoded, all the data must be present.
+ *
+ *  Special : if decompression side sets a ring buffer, it must respect one of the following conditions :
+ *  - Decompression buffer size is _at least_ LZ4_decoderRingBufferSize(maxBlockSize).
+ *    maxBlockSize is the maximum size of any single block. It can have any value > 16 bytes.
+ *    In which case, encoding and decoding buffers do not need to be synchronized.
+ *    Actually, data can be produced by any source compliant with LZ4 format specification, and respecting maxBlockSize.
+ *  - Synchronized mode :
+ *    Decompression buffer size is _exactly_ the same as compression buffer size,
+ *    and follows exactly same update rule (block boundaries at same positions),
+ *    and decoding function is provided with exact decompressed size of each block (exception for last block of the stream),
+ *    _then_ decoding & encoding ring buffer can have any size, including small ones ( < 64 KB).
+ *  - Decompression buffer is larger than encoding buffer, by a minimum of maxBlockSize more bytes.
+ *    In which case, encoding and decoding buffers do not need to be synchronized,
+ *    and encoding ring buffer can have any size, including small ones ( < 64 KB).
+ *
+ *  Whenever these conditions are not possible,
+ *  save the last 64KB of decoded data into a safe buffer where it can't be modified during decompression,
+ *  then indicate where this data is saved using LZ4_setStreamDecode(), before decompressing next block.
+*/
+LZ4LIB_API int
+LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode,
+                        const char* src, char* dst,
+                        int srcSize, int dstCapacity);
+
+
+/*! LZ4_decompress_safe_usingDict() :
+ *  Works the same as
+ *  a combination of LZ4_setStreamDecode() followed by LZ4_decompress_safe_continue()
+ *  However, it's stateless: it doesn't need any LZ4_streamDecode_t state.
+ *  Dictionary is presumed stable : it must remain accessible and unmodified during decompression.
+ *  Performance tip : Decompression speed can be substantially increased
+ *                    when dst == dictStart + dictSize.
+ */
+LZ4LIB_API int
+LZ4_decompress_safe_usingDict(const char* src, char* dst,
+                              int srcSize, int dstCapacity,
+                              const char* dictStart, int dictSize);
+
+/*! LZ4_decompress_safe_partial_usingDict() :
+ *  Behaves the same as LZ4_decompress_safe_partial()
+ *  with the added ability to specify a memory segment for past data.
+ *  Performance tip : Decompression speed can be substantially increased
+ *                    when dst == dictStart + dictSize.
+ */
+LZ4LIB_API int
+LZ4_decompress_safe_partial_usingDict(const char* src, char* dst,
+                                      int compressedSize,
+                                      int targetOutputSize, int maxOutputSize,
+                                      const char* dictStart, int dictSize);
+
+#endif /* LZ4_H_2983827168210 */
+
+
+/*^*************************************
+ * !!!!!!   STATIC LINKING ONLY   !!!!!!
+ ***************************************/
+
+/*-****************************************************************************
+ * Experimental section
+ *
+ * Symbols declared in this section must be considered unstable. Their
+ * signatures or semantics may change, or they may be removed altogether in the
+ * future. They are therefore only safe to depend on when the caller is
+ * statically linked against the library.
+ *
+ * To protect against unsafe usage, not only are the declarations guarded,
+ * the definitions are hidden by default
+ * when building LZ4 as a shared/dynamic library.
+ *
+ * In order to access these declarations,
+ * define LZ4_STATIC_LINKING_ONLY in your application
+ * before including LZ4's headers.
+ *
+ * In order to make their implementations accessible dynamically, you must
+ * define LZ4_PUBLISH_STATIC_FUNCTIONS when building the LZ4 library.
+ ******************************************************************************/
+
+#ifdef LZ4_STATIC_LINKING_ONLY
+
+#ifndef LZ4_STATIC_3504398509
+#define LZ4_STATIC_3504398509
+
+#ifdef LZ4_PUBLISH_STATIC_FUNCTIONS
+# define LZ4LIB_STATIC_API LZ4LIB_API
+#else
+# define LZ4LIB_STATIC_API
+#endif
+
+
+/*! LZ4_compress_fast_extState_fastReset() :
+ *  A variant of LZ4_compress_fast_extState().
+ *
+ *  Using this variant avoids an expensive initialization step.
+ *  It is only safe to call if the state buffer is known to be correctly initialized already
+ *  (see above comment on LZ4_resetStream_fast() for a definition of "correctly initialized").
+ *  From a high level, the difference is that
+ *  this function initializes the provided state with a call to something like LZ4_resetStream_fast()
+ *  while LZ4_compress_fast_extState() starts with a call to LZ4_resetStream().
+ */
+LZ4LIB_STATIC_API int LZ4_compress_fast_extState_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
+
+/*! LZ4_compress_destSize_extState() : introduced in v1.10.0
+ *  Same as LZ4_compress_destSize(), but using an externally allocated state.
+ *  Also: exposes @acceleration
+ */
+int LZ4_compress_destSize_extState(void* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize, int acceleration);
+
+/*! In-place compression and decompression
+ *
+ * It's possible to have input and output sharing the same buffer,
+ * for highly constrained memory environments.
+ * In both cases, it requires input to lay at the end of the buffer,
+ * and decompression to start at beginning of the buffer.
+ * Buffer size must feature some margin, hence be larger than final size.
+ *
+ * |<------------------------buffer--------------------------------->|
+ *                             |<-----------compressed data--------->|
+ * |<-----------decompressed size------------------>|
+ *                                                  |<----margin---->|
+ *
+ * This technique is more useful for decompression,
+ * since decompressed size is typically larger,
+ * and margin is short.
+ *
+ * In-place decompression will work inside any buffer
+ * which size is >= LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize).
+ * This presumes that decompressedSize > compressedSize.
+ * Otherwise, it means compression actually expanded data,
+ * and it would be more efficient to store such data with a flag indicating it's not compressed.
+ * This can happen when data is not compressible (already compressed, or encrypted).
+ *
+ * For in-place compression, margin is larger, as it must be able to cope with both
+ * history preservation, requiring input data to remain unmodified up to LZ4_DISTANCE_MAX,
+ * and data expansion, which can happen when input is not compressible.
+ * As a consequence, buffer size requirements are much higher,
+ * and memory savings offered by in-place compression are more limited.
+ *
+ * There are ways to limit this cost for compression :
+ * - Reduce history size, by modifying LZ4_DISTANCE_MAX.
+ *   Note that it is a compile-time constant, so all compressions will apply this limit.
+ *   Lower values will reduce compression ratio, except when input_size < LZ4_DISTANCE_MAX,
+ *   so it's a reasonable trick when inputs are known to be small.
+ * - Require the compressor to deliver a "maximum compressed size".
+ *   This is the `dstCapacity` parameter in `LZ4_compress*()`.
+ *   When this size is < LZ4_COMPRESSBOUND(inputSize), then compression can fail,
+ *   in which case, the return code will be 0 (zero).
+ *   The caller must be ready for these cases to happen,
+ *   and typically design a backup scheme to send data uncompressed.
+ * The combination of both techniques can significantly reduce
+ * the amount of margin required for in-place compression.
+ *
+ * In-place compression can work in any buffer
+ * which size is >= (maxCompressedSize)
+ * with maxCompressedSize == LZ4_COMPRESSBOUND(srcSize) for guaranteed compression success.
+ * LZ4_COMPRESS_INPLACE_BUFFER_SIZE() depends on both maxCompressedSize and LZ4_DISTANCE_MAX,
+ * so it's possible to reduce memory requirements by playing with them.
+ */
+
+#define LZ4_DECOMPRESS_INPLACE_MARGIN(compressedSize)          (((compressedSize) >> 8) + 32)
+#define LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize)   ((decompressedSize) + LZ4_DECOMPRESS_INPLACE_MARGIN(decompressedSize))  /**< note: presumes that compressedSize < decompressedSize. note2: margin is overestimated a bit, since it could use compressedSize instead */
+
+#ifndef LZ4_DISTANCE_MAX   /* history window size; can be user-defined at compile time */
+#  define LZ4_DISTANCE_MAX 65535   /* set to maximum value by default */
+#endif
+
+#define LZ4_COMPRESS_INPLACE_MARGIN                           (LZ4_DISTANCE_MAX + 32)   /* LZ4_DISTANCE_MAX can be safely replaced by srcSize when it's smaller */
+#define LZ4_COMPRESS_INPLACE_BUFFER_SIZE(maxCompressedSize)   ((maxCompressedSize) + LZ4_COMPRESS_INPLACE_MARGIN)  /**< maxCompressedSize is generally LZ4_COMPRESSBOUND(inputSize), but can be set to any lower value, with the risk that compression can fail (return code 0(zero)) */
+
+#endif   /* LZ4_STATIC_3504398509 */
+#endif   /* LZ4_STATIC_LINKING_ONLY */
+
+
+
+#ifndef LZ4_H_98237428734687
+#define LZ4_H_98237428734687
+
+/*-************************************************************
+ *  Private Definitions
+ **************************************************************
+ * Do not use these definitions directly.
+ * They are only exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`.
+ * Accessing members will expose user code to API and/or ABI break in future versions of the library.
+ **************************************************************/
+#define LZ4_HASHLOG   (LZ4_MEMORY_USAGE-2)
+#define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
+#define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG)       /* required as macro for static allocation */
+
+#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+# include <stdint.h>
+  typedef  int8_t  LZ4_i8;
+  typedef uint8_t  LZ4_byte;
+  typedef uint16_t LZ4_u16;
+  typedef uint32_t LZ4_u32;
+#else
+  typedef   signed char  LZ4_i8;
+  typedef unsigned char  LZ4_byte;
+  typedef unsigned short LZ4_u16;
+  typedef unsigned int   LZ4_u32;
+#endif
+
+/*! LZ4_stream_t :
+ *  Never ever use below internal definitions directly !
+ *  These definitions are not API/ABI safe, and may change in future versions.
+ *  If you need static allocation, declare or allocate an LZ4_stream_t object.
+**/
+
+typedef struct LZ4_stream_t_internal LZ4_stream_t_internal;
+struct LZ4_stream_t_internal {
+    LZ4_u32 hashTable[LZ4_HASH_SIZE_U32];
+    const LZ4_byte* dictionary;
+    const LZ4_stream_t_internal* dictCtx;
+    LZ4_u32 currentOffset;
+    LZ4_u32 tableType;
+    LZ4_u32 dictSize;
+    /* Implicit padding to ensure structure is aligned */
+};
+
+#define LZ4_STREAM_MINSIZE  ((1UL << (LZ4_MEMORY_USAGE)) + 32)  /* static size, for inter-version compatibility */
+union LZ4_stream_u {
+    char minStateSize[LZ4_STREAM_MINSIZE];
+    LZ4_stream_t_internal internal_donotuse;
+}; /* previously typedef'd to LZ4_stream_t */
+
+
+/*! LZ4_initStream() : v1.9.0+
+ *  An LZ4_stream_t structure must be initialized at least once.
+ *  This is automatically done when invoking LZ4_createStream(),
+ *  but it's not when the structure is simply declared on stack (for example).
+ *
+ *  Use LZ4_initStream() to properly initialize a newly declared LZ4_stream_t.
+ *  It can also initialize any arbitrary buffer of sufficient size,
+ *  and will @return a pointer of proper type upon initialization.
+ *
+ *  Note : initialization fails if size and alignment conditions are not respected.
+ *         In which case, the function will @return NULL.
+ *  Note2: An LZ4_stream_t structure guarantees correct alignment and size.
+ *  Note3: Before v1.9.0, use LZ4_resetStream() instead
+**/
+LZ4LIB_API LZ4_stream_t* LZ4_initStream (void* stateBuffer, size_t size);
+
+
+/*! LZ4_streamDecode_t :
+ *  Never ever use below internal definitions directly !
+ *  These definitions are not API/ABI safe, and may change in future versions.
+ *  If you need static allocation, declare or allocate an LZ4_streamDecode_t object.
+**/
+typedef struct {
+    const LZ4_byte* externalDict;
+    const LZ4_byte* prefixEnd;
+    size_t extDictSize;
+    size_t prefixSize;
+} LZ4_streamDecode_t_internal;
+
+#define LZ4_STREAMDECODE_MINSIZE 32
+union LZ4_streamDecode_u {
+    char minStateSize[LZ4_STREAMDECODE_MINSIZE];
+    LZ4_streamDecode_t_internal internal_donotuse;
+} ;   /* previously typedef'd to LZ4_streamDecode_t */
+
+
+
+/*-************************************
+*  Obsolete Functions
+**************************************/
+
+/*! Deprecation warnings
+ *
+ *  Deprecated functions make the compiler generate a warning when invoked.
+ *  This is meant to invite users to update their source code.
+ *  Should deprecation warnings be a problem, it is generally possible to disable them,
+ *  typically with -Wno-deprecated-declarations for gcc
+ *  or _CRT_SECURE_NO_WARNINGS in Visual.
+ *
+ *  Another method is to define LZ4_DISABLE_DEPRECATE_WARNINGS
+ *  before including the header file.
+ */
+#ifdef LZ4_DISABLE_DEPRECATE_WARNINGS
+#  define LZ4_DEPRECATED(message)   /* disable deprecation warnings */
+#else
+#  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
+#    define LZ4_DEPRECATED(message) [[deprecated(message)]]
+#  elif defined(_MSC_VER)
+#    define LZ4_DEPRECATED(message) __declspec(deprecated(message))
+#  elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 45))
+#    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
+#  elif defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 31)
+#    define LZ4_DEPRECATED(message) __attribute__((deprecated))
+#  else
+#    pragma message("WARNING: LZ4_DEPRECATED needs custom implementation for this compiler")
+#    define LZ4_DEPRECATED(message)   /* disabled */
+#  endif
+#endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */
+
+/*! Obsolete compression functions (since v1.7.3) */
+LZ4_DEPRECATED("use LZ4_compress_default() instead")       LZ4LIB_API int LZ4_compress               (const char* src, char* dest, int srcSize);
+LZ4_DEPRECATED("use LZ4_compress_default() instead")       LZ4LIB_API int LZ4_compress_limitedOutput (const char* src, char* dest, int srcSize, int maxOutputSize);
+LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_withState               (void* state, const char* source, char* dest, int inputSize);
+LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
+LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_continue                (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
+LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_limitedOutput_continue  (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
+
+/*! Obsolete decompression functions (since v1.8.0) */
+LZ4_DEPRECATED("use LZ4_decompress_fast() instead") LZ4LIB_API int LZ4_uncompress (const char* source, char* dest, int outputSize);
+LZ4_DEPRECATED("use LZ4_decompress_safe() instead") LZ4LIB_API int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);
+
+/* Obsolete streaming functions (since v1.7.0)
+ * degraded functionality; do not use!
+ *
+ * In order to perform streaming compression, these functions depended on data
+ * that is no longer tracked in the state. They have been preserved as well as
+ * possible: using them will still produce a correct output. However, they don't
+ * actually retain any history between compression calls. The compression ratio
+ * achieved will therefore be no better than compressing each chunk
+ * independently.
+ */
+LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API void* LZ4_create (char* inputBuffer);
+LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API int   LZ4_sizeofStreamState(void);
+LZ4_DEPRECATED("Use LZ4_resetStream() instead")  LZ4LIB_API int   LZ4_resetStreamState(void* state, char* inputBuffer);
+LZ4_DEPRECATED("Use LZ4_saveDict() instead")     LZ4LIB_API char* LZ4_slideInputBuffer (void* state);
+
+/*! Obsolete streaming decoding functions (since v1.7.0) */
+LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") LZ4LIB_API int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
+LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") LZ4LIB_API int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
+
+/*! Obsolete LZ4_decompress_fast variants (since v1.9.0) :
+ *  These functions used to be faster than LZ4_decompress_safe(),
+ *  but this is no longer the case. They are now slower.
+ *  This is because LZ4_decompress_fast() doesn't know the input size,
+ *  and therefore must progress more cautiously into the input buffer to not read beyond the end of block.
+ *  On top of that `LZ4_decompress_fast()` is not protected vs malformed or malicious inputs, making it a security liability.
+ *  As a consequence, LZ4_decompress_fast() is strongly discouraged, and deprecated.
+ *
+ *  The last remaining LZ4_decompress_fast() specificity is that
+ *  it can decompress a block without knowing its compressed size.
+ *  Such functionality can be achieved in a more secure manner
+ *  by employing LZ4_decompress_safe_partial().
+ *
+ *  Parameters:
+ *  originalSize : is the uncompressed size to regenerate.
+ *                 `dst` must be already allocated, its size must be >= 'originalSize' bytes.
+ * @return : number of bytes read from source buffer (== compressed size).
+ *           The function expects to finish at block's end exactly.
+ *           If the source stream is detected malformed, the function stops decoding and returns a negative result.
+ *  note : LZ4_decompress_fast*() requires originalSize. Thanks to this information, it never writes past the output buffer.
+ *         However, since it doesn't know its 'src' size, it may read an unknown amount of input, past input buffer bounds.
+ *         Also, since match offsets are not validated, match reads from 'src' may underflow too.
+ *         These issues never happen if input (compressed) data is correct.
+ *         But they may happen if input data is invalid (error or intentional tampering).
+ *         As a consequence, use these functions in trusted environments with trusted data **only**.
+ */
+LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_partial() instead")
+LZ4LIB_API int LZ4_decompress_fast (const char* src, char* dst, int originalSize);
+LZ4_DEPRECATED("This function is deprecated and unsafe. Consider migrating towards LZ4_decompress_safe_continue() instead. "
+               "Note that the contract will change (requires block's compressed size, instead of decompressed size)")
+LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int originalSize);
+LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_partial_usingDict() instead")
+LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* src, char* dst, int originalSize, const char* dictStart, int dictSize);
+
+/*! LZ4_resetStream() :
+ *  An LZ4_stream_t structure must be initialized at least once.
+ *  This is done with LZ4_initStream(), or LZ4_resetStream().
+ *  Consider switching to LZ4_initStream(),
+ *  invoking LZ4_resetStream() will trigger deprecation warnings in the future.
+ */
+LZ4LIB_API void LZ4_resetStream (LZ4_stream_t* streamPtr);
+
+
+#endif /* LZ4_H_98237428734687 */
+
+
+#if defined (__cplusplus)
+}
+#endif
diff --git a/native/lz4/vendor/lib/lz4hc.c b/native/lz4/vendor/lib/lz4hc.c
new file mode 100644
index 0000000..4d8c36a
--- /dev/null
+++ b/native/lz4/vendor/lib/lz4hc.c
@@ -0,0 +1,2192 @@
+/*
+    LZ4 HC - High Compression Mode of LZ4
+    Copyright (C) 2011-2020, Yann Collet.
+
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    You can contact the author at :
+       - LZ4 source repository : https://github.com/lz4/lz4
+       - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+/* note : lz4hc is not an independent module, it requires lz4.h/lz4.c for proper compilation */
+
+
+/* *************************************
+*  Tuning Parameter
+***************************************/
+
+/*! HEAPMODE :
+ *  Select how stateless HC compression functions like `LZ4_compress_HC()`
+ *  allocate memory for their workspace:
+ *  in stack (0:fastest), or in heap (1:default, requires malloc()).
+ *  Since workspace is rather large, heap mode is recommended.
+**/
+#ifndef LZ4HC_HEAPMODE
+#  define LZ4HC_HEAPMODE 1
+#endif
+
+
+/*===    Dependency    ===*/
+#define LZ4_HC_STATIC_LINKING_ONLY
+#include "lz4hc.h"
+#include <limits.h>
+
+
+/*===   Shared lz4.c code   ===*/
+#ifndef LZ4_SRC_INCLUDED
+# if defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wunused-function"
+# endif
+# if defined (__clang__)
+#  pragma clang diagnostic ignored "-Wunused-function"
+# endif
+# define LZ4_COMMONDEFS_ONLY
+# include "lz4.c"   /* LZ4_count, constants, mem */
+#endif
+
+
+/*===   Enums   ===*/
+typedef enum { noDictCtx, usingDictCtxHc } dictCtx_directive;
+
+
+/*===   Constants   ===*/
+#define OPTIMAL_ML (int)((ML_MASK-1)+MINMATCH)
+#define LZ4_OPT_NUM   (1<<12)
+
+
+/*===   Macros   ===*/
+#define MIN(a,b)   ( (a) < (b) ? (a) : (b) )
+#define MAX(a,b)   ( (a) > (b) ? (a) : (b) )
+
+
+/*===   Levels definition   ===*/
+typedef enum { lz4mid, lz4hc, lz4opt } lz4hc_strat_e;
+typedef struct {
+    lz4hc_strat_e strat;
+    int nbSearches;
+    U32 targetLength;
+} cParams_t;
+static const cParams_t k_clTable[LZ4HC_CLEVEL_MAX+1] = {
+    { lz4mid,    2, 16 },  /* 0, unused */
+    { lz4mid,    2, 16 },  /* 1, unused */
+    { lz4mid,    2, 16 },  /* 2 */
+    { lz4hc,     4, 16 },  /* 3 */
+    { lz4hc,     8, 16 },  /* 4 */
+    { lz4hc,    16, 16 },  /* 5 */
+    { lz4hc,    32, 16 },  /* 6 */
+    { lz4hc,    64, 16 },  /* 7 */
+    { lz4hc,   128, 16 },  /* 8 */
+    { lz4hc,   256, 16 },  /* 9 */
+    { lz4opt,   96, 64 },  /*10==LZ4HC_CLEVEL_OPT_MIN*/
+    { lz4opt,  512,128 },  /*11 */
+    { lz4opt,16384,LZ4_OPT_NUM },  /* 12==LZ4HC_CLEVEL_MAX */
+};
+
+static cParams_t LZ4HC_getCLevelParams(int cLevel)
+{
+    /* note : clevel convention is a bit different from lz4frame,
+     * possibly something worth revisiting for consistency */
+    if (cLevel < 1)
+        cLevel = LZ4HC_CLEVEL_DEFAULT;
+    cLevel = MIN(LZ4HC_CLEVEL_MAX, cLevel);
+    return k_clTable[cLevel];
+}
+
+
+/*===   Hashing   ===*/
+#define LZ4HC_HASHSIZE 4
+#define HASH_FUNCTION(i)      (((i) * 2654435761U) >> ((MINMATCH*8)-LZ4HC_HASH_LOG))
+static U32 LZ4HC_hashPtr(const void* ptr) { return HASH_FUNCTION(LZ4_read32(ptr)); }
+
+#if defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==2)
+/* lie to the compiler about data alignment; use with caution */
+static U64 LZ4_read64(const void* memPtr) { return *(const U64*) memPtr; }
+
+#elif defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==1)
+/* __pack instructions are safer, but compiler specific */
+LZ4_PACK(typedef struct { U64 u64; }) LZ4_unalign64;
+static U64 LZ4_read64(const void* ptr) { return ((const LZ4_unalign64*)ptr)->u64; }
+
+#else  /* safe and portable access using memcpy() */
+static U64 LZ4_read64(const void* memPtr)
+{
+    U64 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
+}
+
+#endif /* LZ4_FORCE_MEMORY_ACCESS */
+
+#define LZ4MID_HASHSIZE 8
+#define LZ4MID_HASHLOG (LZ4HC_HASH_LOG-1)
+#define LZ4MID_HASHTABLESIZE (1 << LZ4MID_HASHLOG)
+
+static U32 LZ4MID_hash4(U32 v) { return (v * 2654435761U) >> (32-LZ4MID_HASHLOG); }
+static U32 LZ4MID_hash4Ptr(const void* ptr) { return LZ4MID_hash4(LZ4_read32(ptr)); }
+/* note: hash7 hashes the lower 56-bits.
+ * It presumes input was read using little endian.*/
+static U32 LZ4MID_hash7(U64 v) { return (U32)(((v  << (64-56)) * 58295818150454627ULL) >> (64-LZ4MID_HASHLOG)) ; }
+static U64 LZ4_readLE64(const void* memPtr);
+static U32 LZ4MID_hash8Ptr(const void* ptr) { return LZ4MID_hash7(LZ4_readLE64(ptr)); }
+
+static U64 LZ4_readLE64(const void* memPtr)
+{
+    if (LZ4_isLittleEndian()) {
+        return LZ4_read64(memPtr);
+    } else {
+        const BYTE* p = (const BYTE*)memPtr;
+        /* note: relies on the compiler to simplify this expression */
+        return (U64)p[0] | ((U64)p[1]<<8) | ((U64)p[2]<<16) | ((U64)p[3]<<24)
+            | ((U64)p[4]<<32) | ((U64)p[5]<<40) | ((U64)p[6]<<48) | ((U64)p[7]<<56);
+    }
+}
+
+
+/*===   Count match length   ===*/
+LZ4_FORCE_INLINE
+unsigned LZ4HC_NbCommonBytes32(U32 val)
+{
+    assert(val != 0);
+    if (LZ4_isLittleEndian()) {
+#     if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(LZ4_FORCE_SW_BITCOUNT)
+        unsigned long r;
+        _BitScanReverse(&r, val);
+        return (unsigned)((31 - r) >> 3);
+#     elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
+                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
+                                        !defined(LZ4_FORCE_SW_BITCOUNT)
+        return (unsigned)__builtin_clz(val) >> 3;
+#     else
+        val >>= 8;
+        val = ((((val + 0x00FFFF00) | 0x00FFFFFF) + val) |
+              (val + 0x00FF0000)) >> 24;
+        return (unsigned)val ^ 3;
+#     endif
+    } else {
+#     if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(LZ4_FORCE_SW_BITCOUNT)
+        unsigned long r;
+        _BitScanForward(&r, val);
+        return (unsigned)(r >> 3);
+#     elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
+                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
+                                        !defined(LZ4_FORCE_SW_BITCOUNT)
+        return (unsigned)__builtin_ctz(val) >> 3;
+#     else
+        const U32 m = 0x01010101;
+        return (unsigned)((((val - 1) ^ val) & (m - 1)) * m) >> 24;
+#     endif
+    }
+}
+
+/** LZ4HC_countBack() :
+ * @return : negative value, nb of common bytes before ip/match */
+LZ4_FORCE_INLINE
+int LZ4HC_countBack(const BYTE* const ip, const BYTE* const match,
+                    const BYTE* const iMin, const BYTE* const mMin)
+{
+    int back = 0;
+    int const min = (int)MAX(iMin - ip, mMin - match);
+    assert(min <= 0);
+    assert(ip >= iMin); assert((size_t)(ip-iMin) < (1U<<31));
+    assert(match >= mMin); assert((size_t)(match - mMin) < (1U<<31));
+
+    while ((back - min) > 3) {
+        U32 const v = LZ4_read32(ip + back - 4) ^ LZ4_read32(match + back - 4);
+        if (v) {
+            return (back - (int)LZ4HC_NbCommonBytes32(v));
+        } else back -= 4; /* 4-byte step */
+    }
+    /* check remainder if any */
+    while ( (back > min)
+         && (ip[back-1] == match[back-1]) )
+            back--;
+    return back;
+}
+
+/*===   Chain table updates   ===*/
+#define DELTANEXTU16(table, pos) table[(U16)(pos)]   /* faster */
+/* Make fields passed to, and updated by LZ4HC_encodeSequence explicit */
+#define UPDATABLE(ip, op, anchor) &ip, &op, &anchor
+
+
+/**************************************
+*  Init
+**************************************/
+static void LZ4HC_clearTables (LZ4HC_CCtx_internal* hc4)
+{
+    MEM_INIT(hc4->hashTable, 0, sizeof(hc4->hashTable));
+    MEM_INIT(hc4->chainTable, 0xFF, sizeof(hc4->chainTable));
+}
+
+static void LZ4HC_init_internal (LZ4HC_CCtx_internal* hc4, const BYTE* start)
+{
+    size_t const bufferSize = (size_t)(hc4->end - hc4->prefixStart);
+    size_t newStartingOffset = bufferSize + hc4->dictLimit;
+    DEBUGLOG(5, "LZ4HC_init_internal");
+    assert(newStartingOffset >= bufferSize);  /* check overflow */
+    if (newStartingOffset > 1 GB) {
+        LZ4HC_clearTables(hc4);
+        newStartingOffset = 0;
+    }
+    newStartingOffset += 64 KB;
+    hc4->nextToUpdate = (U32)newStartingOffset;
+    hc4->prefixStart = start;
+    hc4->end = start;
+    hc4->dictStart = start;
+    hc4->dictLimit = (U32)newStartingOffset;
+    hc4->lowLimit = (U32)newStartingOffset;
+}
+
+
+/**************************************
+*  Encode
+**************************************/
+/* LZ4HC_encodeSequence() :
+ * @return : 0 if ok,
+ *           1 if buffer issue detected */
+LZ4_FORCE_INLINE int LZ4HC_encodeSequence (
+    const BYTE** _ip,
+    BYTE** _op,
+    const BYTE** _anchor,
+    int matchLength,
+    int offset,
+    limitedOutput_directive limit,
+    BYTE* oend)
+{
+#define ip      (*_ip)
+#define op      (*_op)
+#define anchor  (*_anchor)
+
+    size_t length;
+    BYTE* const token = op++;
+
+#if defined(LZ4_DEBUG) && (LZ4_DEBUG >= 6)
+    static const BYTE* start = NULL;
+    static U32 totalCost = 0;
+    U32 const pos = (start==NULL) ? 0 : (U32)(anchor - start);
+    U32 const ll = (U32)(ip - anchor);
+    U32 const llAdd = (ll>=15) ? ((ll-15) / 255) + 1 : 0;
+    U32 const mlAdd = (matchLength>=19) ? ((matchLength-19) / 255) + 1 : 0;
+    U32 const cost = 1 + llAdd + ll + 2 + mlAdd;
+    if (start==NULL) start = anchor;  /* only works for single segment */
+    /* g_debuglog_enable = (pos >= 2228) & (pos <= 2262); */
+    DEBUGLOG(6, "pos:%7u -- literals:%4u, match:%4i, offset:%5i, cost:%4u + %5u",
+                pos,
+                (U32)(ip - anchor), matchLength, offset,
+                cost, totalCost);
+    totalCost += cost;
+#endif
+
+    /* Encode Literal length */
+    length = (size_t)(ip - anchor);
+    LZ4_STATIC_ASSERT(notLimited == 0);
+    /* Check output limit */
+    if (limit && ((op + (length / 255) + length + (2 + 1 + LASTLITERALS)) > oend)) {
+        DEBUGLOG(6, "Not enough room to write %i literals (%i bytes remaining)",
+                (int)length, (int)(oend - op));
+        return 1;
+    }
+    if (length >= RUN_MASK) {
+        size_t len = length - RUN_MASK;
+        *token = (RUN_MASK << ML_BITS);
+        for(; len >= 255 ; len -= 255) *op++ = 255;
+        *op++ = (BYTE)len;
+    } else {
+        *token = (BYTE)(length << ML_BITS);
+    }
+
+    /* Copy Literals */
+    LZ4_wildCopy8(op, anchor, op + length);
+    op += length;
+
+    /* Encode Offset */
+    assert(offset <= LZ4_DISTANCE_MAX );
+    assert(offset > 0);
+    LZ4_writeLE16(op, (U16)(offset)); op += 2;
+
+    /* Encode MatchLength */
+    assert(matchLength >= MINMATCH);
+    length = (size_t)matchLength - MINMATCH;
+    if (limit && (op + (length / 255) + (1 + LASTLITERALS) > oend)) {
+        DEBUGLOG(6, "Not enough room to write match length");
+        return 1;   /* Check output limit */
+    }
+    if (length >= ML_MASK) {
+        *token += ML_MASK;
+        length -= ML_MASK;
+        for(; length >= 510 ; length -= 510) { *op++ = 255; *op++ = 255; }
+        if (length >= 255) { length -= 255; *op++ = 255; }
+        *op++ = (BYTE)length;
+    } else {
+        *token += (BYTE)(length);
+    }
+
+    /* Prepare next loop */
+    ip += matchLength;
+    anchor = ip;
+
+    return 0;
+
+#undef ip
+#undef op
+#undef anchor
+}
+
+
+typedef struct {
+    int off;
+    int len;
+    int back;  /* negative value */
+} LZ4HC_match_t;
+
+LZ4HC_match_t LZ4HC_searchExtDict(const BYTE* ip, U32 ipIndex,
+        const BYTE* const iLowLimit, const BYTE* const iHighLimit,
+        const LZ4HC_CCtx_internal* dictCtx, U32 gDictEndIndex,
+        int currentBestML, int nbAttempts)
+{
+    size_t const lDictEndIndex = (size_t)(dictCtx->end - dictCtx->prefixStart) + dictCtx->dictLimit;
+    U32 lDictMatchIndex = dictCtx->hashTable[LZ4HC_hashPtr(ip)];
+    U32 matchIndex = lDictMatchIndex + gDictEndIndex - (U32)lDictEndIndex;
+    int offset = 0, sBack = 0;
+    assert(lDictEndIndex <= 1 GB);
+    if (lDictMatchIndex>0)
+        DEBUGLOG(7, "lDictEndIndex = %zu, lDictMatchIndex = %u", lDictEndIndex, lDictMatchIndex);
+    while (ipIndex - matchIndex <= LZ4_DISTANCE_MAX && nbAttempts--) {
+        const BYTE* const matchPtr = dictCtx->prefixStart - dictCtx->dictLimit + lDictMatchIndex;
+
+        if (LZ4_read32(matchPtr) == LZ4_read32(ip)) {
+            int mlt;
+            int back = 0;
+            const BYTE* vLimit = ip + (lDictEndIndex - lDictMatchIndex);
+            if (vLimit > iHighLimit) vLimit = iHighLimit;
+            mlt = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH;
+            back = (ip > iLowLimit) ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictCtx->prefixStart) : 0;
+            mlt -= back;
+            if (mlt > currentBestML) {
+                currentBestML = mlt;
+                offset = (int)(ipIndex - matchIndex);
+                sBack = back;
+                DEBUGLOG(7, "found match of length %i within extDictCtx", currentBestML);
+        }   }
+
+        {   U32 const nextOffset = DELTANEXTU16(dictCtx->chainTable, lDictMatchIndex);
+            lDictMatchIndex -= nextOffset;
+            matchIndex -= nextOffset;
+    }   }
+
+    {   LZ4HC_match_t md;
+        md.len = currentBestML;
+        md.off = offset;
+        md.back = sBack;
+        return md;
+    }
+}
+
+typedef LZ4HC_match_t (*LZ4MID_searchIntoDict_f)(const BYTE* ip, U32 ipIndex,
+        const BYTE* const iHighLimit,
+        const LZ4HC_CCtx_internal* dictCtx, U32 gDictEndIndex);
+
+static LZ4HC_match_t LZ4MID_searchHCDict(const BYTE* ip, U32 ipIndex,
+        const BYTE* const iHighLimit,
+        const LZ4HC_CCtx_internal* dictCtx, U32 gDictEndIndex)
+{
+    return LZ4HC_searchExtDict(ip,ipIndex,
+                            ip, iHighLimit,
+                            dictCtx, gDictEndIndex,
+                            MINMATCH-1, 2);
+}
+
+static LZ4HC_match_t LZ4MID_searchExtDict(const BYTE* ip, U32 ipIndex,
+        const BYTE* const iHighLimit,
+        const LZ4HC_CCtx_internal* dictCtx, U32 gDictEndIndex)
+{
+    size_t const lDictEndIndex = (size_t)(dictCtx->end - dictCtx->prefixStart) + dictCtx->dictLimit;
+    const U32* const hash4Table = dictCtx->hashTable;
+    const U32* const hash8Table = hash4Table + LZ4MID_HASHTABLESIZE;
+    DEBUGLOG(7, "LZ4MID_searchExtDict (ipIdx=%u)", ipIndex);
+
+    /* search long match first */
+    {   U32 l8DictMatchIndex = hash8Table[LZ4MID_hash8Ptr(ip)];
+        U32 m8Index = l8DictMatchIndex + gDictEndIndex - (U32)lDictEndIndex;
+        assert(lDictEndIndex <= 1 GB);
+        if (ipIndex - m8Index <= LZ4_DISTANCE_MAX) {
+            const BYTE* const matchPtr = dictCtx->prefixStart - dictCtx->dictLimit + l8DictMatchIndex;
+            const size_t safeLen = MIN(lDictEndIndex - l8DictMatchIndex, (size_t)(iHighLimit - ip));
+            int mlt = (int)LZ4_count(ip, matchPtr, ip + safeLen);
+            if (mlt >= MINMATCH) {
+                LZ4HC_match_t md;
+                DEBUGLOG(7, "Found long ExtDict match of len=%u", mlt);
+                md.len = mlt;
+                md.off = (int)(ipIndex - m8Index);
+                md.back = 0;
+                return md;
+            }
+        }
+    }
+
+    /* search for short match second */
+    {   U32 l4DictMatchIndex = hash4Table[LZ4MID_hash4Ptr(ip)];
+        U32 m4Index = l4DictMatchIndex + gDictEndIndex - (U32)lDictEndIndex;
+        if (ipIndex - m4Index <= LZ4_DISTANCE_MAX) {
+            const BYTE* const matchPtr = dictCtx->prefixStart - dictCtx->dictLimit + l4DictMatchIndex;
+            const size_t safeLen = MIN(lDictEndIndex - l4DictMatchIndex, (size_t)(iHighLimit - ip));
+            int mlt = (int)LZ4_count(ip, matchPtr, ip + safeLen);
+            if (mlt >= MINMATCH) {
+                LZ4HC_match_t md;
+                DEBUGLOG(7, "Found short ExtDict match of len=%u", mlt);
+                md.len = mlt;
+                md.off = (int)(ipIndex - m4Index);
+                md.back = 0;
+                return md;
+            }
+        }
+    }
+
+    /* nothing found */
+    {   LZ4HC_match_t const md = {0, 0, 0 };
+        return md;
+    }
+}
+
+/**************************************
+*  Mid Compression (level 2)
+**************************************/
+
+LZ4_FORCE_INLINE void
+LZ4MID_addPosition(U32* hTable, U32 hValue, U32 index)
+{
+    hTable[hValue] = index;
+}
+
+#define ADDPOS8(_p, _idx) LZ4MID_addPosition(hash8Table, LZ4MID_hash8Ptr(_p), _idx)
+#define ADDPOS4(_p, _idx) LZ4MID_addPosition(hash4Table, LZ4MID_hash4Ptr(_p), _idx)
+
+/* Fill hash tables with references into dictionary.
+ * The resulting table is only exploitable by LZ4MID (level 2) */
+static void
+LZ4MID_fillHTable (LZ4HC_CCtx_internal* cctx, const void* dict, size_t size)
+{
+    U32* const hash4Table = cctx->hashTable;
+    U32* const hash8Table = hash4Table + LZ4MID_HASHTABLESIZE;
+    const BYTE* const prefixPtr = (const BYTE*)dict;
+    U32 const prefixIdx = cctx->dictLimit;
+    U32 const target = prefixIdx + (U32)size - LZ4MID_HASHSIZE;
+    U32 idx = cctx->nextToUpdate;
+    assert(dict == cctx->prefixStart);
+    DEBUGLOG(4, "LZ4MID_fillHTable (size:%zu)", size);
+    if (size <= LZ4MID_HASHSIZE)
+        return;
+
+    for (; idx < target; idx += 3) {
+        ADDPOS4(prefixPtr+idx-prefixIdx, idx);
+        ADDPOS8(prefixPtr+idx+1-prefixIdx, idx+1);
+    }
+
+    idx = (size > 32 KB + LZ4MID_HASHSIZE) ? target - 32 KB : cctx->nextToUpdate;
+    for (; idx < target; idx += 1) {
+        ADDPOS8(prefixPtr+idx-prefixIdx, idx);
+    }
+
+    cctx->nextToUpdate = target;
+}
+
+static LZ4MID_searchIntoDict_f select_searchDict_function(const LZ4HC_CCtx_internal* dictCtx)
+{
+    if (dictCtx == NULL) return NULL;
+    if (LZ4HC_getCLevelParams(dictCtx->compressionLevel).strat == lz4mid)
+        return LZ4MID_searchExtDict;
+    return LZ4MID_searchHCDict;
+}
+
+static int LZ4MID_compress (
+    LZ4HC_CCtx_internal* const ctx,
+    const char* const src,
+    char* const dst,
+    int* srcSizePtr,
+    int const maxOutputSize,
+    const limitedOutput_directive limit,
+    const dictCtx_directive dict
+    )
+{
+    U32* const hash4Table = ctx->hashTable;
+    U32* const hash8Table = hash4Table + LZ4MID_HASHTABLESIZE;
+    const BYTE* ip = (const BYTE*)src;
+    const BYTE* anchor = ip;
+    const BYTE* const iend = ip + *srcSizePtr;
+    const BYTE* const mflimit = iend - MFLIMIT;
+    const BYTE* const matchlimit = (iend - LASTLITERALS);
+    const BYTE* const ilimit = (iend - LZ4MID_HASHSIZE);
+    BYTE* op = (BYTE*)dst;
+    BYTE* oend = op + maxOutputSize;
+
+    const BYTE* const prefixPtr = ctx->prefixStart;
+    const U32 prefixIdx = ctx->dictLimit;
+    const U32 ilimitIdx = (U32)(ilimit - prefixPtr) + prefixIdx;
+    const BYTE* const dictStart = ctx->dictStart;
+    const U32 dictIdx = ctx->lowLimit;
+    const U32 gDictEndIndex = ctx->lowLimit;
+    const LZ4MID_searchIntoDict_f searchIntoDict = (dict == usingDictCtxHc) ? select_searchDict_function(ctx->dictCtx) : NULL;
+    unsigned matchLength;
+    unsigned matchDistance;
+
+    /* input sanitization */
+    DEBUGLOG(5, "LZ4MID_compress (%i bytes)", *srcSizePtr);
+    if (dict == usingDictCtxHc) DEBUGLOG(5, "usingDictCtxHc");
+    assert(*srcSizePtr >= 0);
+    if (*srcSizePtr) assert(src != NULL);
+    if (maxOutputSize) assert(dst != NULL);
+    if (*srcSizePtr < 0) return 0;  /* invalid */
+    if (maxOutputSize < 0) return 0; /* invalid */
+    if (*srcSizePtr > LZ4_MAX_INPUT_SIZE) {
+        /* forbidden: no input is allowed to be that large */
+        return 0;
+    }
+    if (limit == fillOutput) oend -= LASTLITERALS;  /* Hack for support LZ4 format restriction */
+    if (*srcSizePtr < LZ4_minLength)
+        goto _lz4mid_last_literals;  /* Input too small, no compression (all literals) */
+
+    /* main loop */
+    while (ip <= mflimit) {
+        const U32 ipIndex = (U32)(ip - prefixPtr) + prefixIdx;
+        /* search long match */
+        {   U32 const h8 = LZ4MID_hash8Ptr(ip);
+            U32 const pos8 = hash8Table[h8];
+            assert(h8 < LZ4MID_HASHTABLESIZE);
+            assert(pos8 < ipIndex);
+            LZ4MID_addPosition(hash8Table, h8, ipIndex);
+            if (ipIndex - pos8 <= LZ4_DISTANCE_MAX) {
+                /* match candidate found */
+                if (pos8 >= prefixIdx) {
+                    const BYTE* const matchPtr = prefixPtr + pos8 - prefixIdx;
+                    assert(matchPtr < ip);
+                    matchLength = LZ4_count(ip, matchPtr, matchlimit);
+                    if (matchLength >= MINMATCH) {
+                        DEBUGLOG(7, "found long match at pos %u (len=%u)", pos8, matchLength);
+                        matchDistance = ipIndex - pos8;
+                        goto _lz4mid_encode_sequence;
+                    }
+                } else {
+                    if (pos8 >= dictIdx) {
+                        /* extDict match candidate */
+                        const BYTE* const matchPtr = dictStart + (pos8 - dictIdx);
+                        const size_t safeLen = MIN(prefixIdx - pos8, (size_t)(matchlimit - ip));
+                        matchLength = LZ4_count(ip, matchPtr, ip + safeLen);
+                        if (matchLength >= MINMATCH) {
+                            DEBUGLOG(7, "found long match at ExtDict pos %u (len=%u)", pos8, matchLength);
+                            matchDistance = ipIndex - pos8;
+                            goto _lz4mid_encode_sequence;
+                        }
+                    }
+                }
+        }   }
+        /* search short match */
+        {   U32 const h4 = LZ4MID_hash4Ptr(ip);
+            U32 const pos4 = hash4Table[h4];
+            assert(h4 < LZ4MID_HASHTABLESIZE);
+            assert(pos4 < ipIndex);
+            LZ4MID_addPosition(hash4Table, h4, ipIndex);
+            if (ipIndex - pos4 <= LZ4_DISTANCE_MAX) {
+                /* match candidate found */
+                if (pos4 >= prefixIdx) {
+                /* only search within prefix */
+                    const BYTE* const matchPtr = prefixPtr + (pos4 - prefixIdx);
+                    assert(matchPtr < ip);
+                    assert(matchPtr >= prefixPtr);
+                    matchLength = LZ4_count(ip, matchPtr, matchlimit);
+                    if (matchLength >= MINMATCH) {
+                        /* short match found, let's just check ip+1 for longer */
+                        U32 const h8 = LZ4MID_hash8Ptr(ip+1);
+                        U32 const pos8 = hash8Table[h8];
+                        U32 const m2Distance = ipIndex + 1 - pos8;
+                        matchDistance = ipIndex - pos4;
+                        if ( m2Distance <= LZ4_DISTANCE_MAX
+                        && pos8 >= prefixIdx /* only search within prefix */
+                        && likely(ip < mflimit)
+                        ) {
+                            const BYTE* const m2Ptr = prefixPtr + (pos8 - prefixIdx);
+                            unsigned ml2 = LZ4_count(ip+1, m2Ptr, matchlimit);
+                            if (ml2 > matchLength) {
+                                LZ4MID_addPosition(hash8Table, h8, ipIndex+1);
+                                ip++;
+                                matchLength = ml2;
+                                matchDistance = m2Distance;
+                        }   }
+                        goto _lz4mid_encode_sequence;
+                    }
+                } else {
+                    if (pos4 >= dictIdx) {
+                        /* extDict match candidate */
+                        const BYTE* const matchPtr = dictStart + (pos4 - dictIdx);
+                        const size_t safeLen = MIN(prefixIdx - pos4, (size_t)(matchlimit - ip));
+                        matchLength = LZ4_count(ip, matchPtr, ip + safeLen);
+                        if (matchLength >= MINMATCH) {
+                            DEBUGLOG(7, "found match at ExtDict pos %u (len=%u)", pos4, matchLength);
+                            matchDistance = ipIndex - pos4;
+                            goto _lz4mid_encode_sequence;
+                        }
+                    }
+                }
+        }   }
+        /* no match found in prefix */
+        if ( (dict == usingDictCtxHc)
+          && (ipIndex - gDictEndIndex < LZ4_DISTANCE_MAX - 8) ) {
+            /* search a match into external dictionary */
+            LZ4HC_match_t dMatch = searchIntoDict(ip, ipIndex,
+                    matchlimit,
+                    ctx->dictCtx, gDictEndIndex);
+            if (dMatch.len >= MINMATCH) {
+                DEBUGLOG(7, "found Dictionary match (offset=%i)", dMatch.off);
+                assert(dMatch.back == 0);
+                matchLength = (unsigned)dMatch.len;
+                matchDistance = (unsigned)dMatch.off;
+                goto _lz4mid_encode_sequence;
+            }
+        }
+        /* no match found */
+        ip += 1 + ((ip-anchor) >> 9);  /* skip faster over incompressible data */
+        continue;
+
+_lz4mid_encode_sequence:
+        /* catch back */
+        while (((ip > anchor) & ((U32)(ip-prefixPtr) > matchDistance)) && (unlikely(ip[-1] == ip[-(int)matchDistance-1]))) {
+            ip--;  matchLength++;
+        };
+
+        /* fill table with beginning of match */
+        ADDPOS8(ip+1, ipIndex+1);
+        ADDPOS8(ip+2, ipIndex+2);
+        ADDPOS4(ip+1, ipIndex+1);
+
+        /* encode */
+        {   BYTE* const saved_op = op;
+            /* LZ4HC_encodeSequence always updates @op; on success, it updates @ip and @anchor */
+            if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
+                    (int)matchLength, (int)matchDistance,
+                    limit, oend) ) {
+                op = saved_op;  /* restore @op value before failed LZ4HC_encodeSequence */
+                goto _lz4mid_dest_overflow;
+            }
+        }
+
+        /* fill table with end of match */
+        {   U32 endMatchIdx = (U32)(ip-prefixPtr) + prefixIdx;
+            U32 pos_m2 = endMatchIdx - 2;
+            if (pos_m2 < ilimitIdx) {
+                if (likely(ip - prefixPtr > 5)) {
+                    ADDPOS8(ip-5, endMatchIdx - 5);
+                }
+                ADDPOS8(ip-3, endMatchIdx - 3);
+                ADDPOS8(ip-2, endMatchIdx - 2);
+                ADDPOS4(ip-2, endMatchIdx - 2);
+                ADDPOS4(ip-1, endMatchIdx - 1);
+            }
+        }
+    }
+
+_lz4mid_last_literals:
+    /* Encode Last Literals */
+    {   size_t lastRunSize = (size_t)(iend - anchor);  /* literals */
+        size_t llAdd = (lastRunSize + 255 - RUN_MASK) / 255;
+        size_t const totalSize = 1 + llAdd + lastRunSize;
+        if (limit == fillOutput) oend += LASTLITERALS;  /* restore correct value */
+        if (limit && (op + totalSize > oend)) {
+            if (limit == limitedOutput) return 0;  /* not enough space in @dst */
+            /* adapt lastRunSize to fill 'dest' */
+            lastRunSize  = (size_t)(oend - op) - 1 /*token*/;
+            llAdd = (lastRunSize + 256 - RUN_MASK) / 256;
+            lastRunSize -= llAdd;
+        }
+        DEBUGLOG(6, "Final literal run : %i literals", (int)lastRunSize);
+        ip = anchor + lastRunSize;  /* can be != iend if limit==fillOutput */
+
+        if (lastRunSize >= RUN_MASK) {
+            size_t accumulator = lastRunSize - RUN_MASK;
+            *op++ = (RUN_MASK << ML_BITS);
+            for(; accumulator >= 255 ; accumulator -= 255)
+                *op++ = 255;
+            *op++ = (BYTE) accumulator;
+        } else {
+            *op++ = (BYTE)(lastRunSize << ML_BITS);
+        }
+        assert(lastRunSize <= (size_t)(oend - op));
+        LZ4_memcpy(op, anchor, lastRunSize);
+        op += lastRunSize;
+    }
+
+    /* End */
+    DEBUGLOG(5, "compressed %i bytes into %i bytes", *srcSizePtr, (int)((char*)op - dst));
+    assert(ip >= (const BYTE*)src);
+    assert(ip <= iend);
+    *srcSizePtr = (int)(ip - (const BYTE*)src);
+    assert((char*)op >= dst);
+    assert(op <= oend);
+    assert((char*)op - dst < INT_MAX);
+    return (int)((char*)op - dst);
+
+_lz4mid_dest_overflow:
+    if (limit == fillOutput) {
+        /* Assumption : @ip, @anchor, @optr and @matchLength must be set correctly */
+        size_t const ll = (size_t)(ip - anchor);
+        size_t const ll_addbytes = (ll + 240) / 255;
+        size_t const ll_totalCost = 1 + ll_addbytes + ll;
+        BYTE* const maxLitPos = oend - 3; /* 2 for offset, 1 for token */
+        DEBUGLOG(6, "Last sequence is overflowing : %u literals, %u remaining space",
+                (unsigned)ll, (unsigned)(oend-op));
+        if (op + ll_totalCost <= maxLitPos) {
+            /* ll validated; now adjust match length */
+            size_t const bytesLeftForMl = (size_t)(maxLitPos - (op+ll_totalCost));
+            size_t const maxMlSize = MINMATCH + (ML_MASK-1) + (bytesLeftForMl * 255);
+            assert(maxMlSize < INT_MAX);
+            if ((size_t)matchLength > maxMlSize) matchLength= (unsigned)maxMlSize;
+            if ((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1 + matchLength >= MFLIMIT) {
+            DEBUGLOG(6, "Let's encode a last sequence (ll=%u, ml=%u)", (unsigned)ll, matchLength);
+                LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
+                        (int)matchLength, (int)matchDistance,
+                        notLimited, oend);
+        }   }
+        DEBUGLOG(6, "Let's finish with a run of literals (%u bytes left)", (unsigned)(oend-op));
+        goto _lz4mid_last_literals;
+    }
+    /* compression failed */
+    return 0;
+}
+
+
+/**************************************
+*  HC Compression - Search
+**************************************/
+
+/* Update chains up to ip (excluded) */
+LZ4_FORCE_INLINE void LZ4HC_Insert (LZ4HC_CCtx_internal* hc4, const BYTE* ip)
+{
+    U16* const chainTable = hc4->chainTable;
+    U32* const hashTable  = hc4->hashTable;
+    const BYTE* const prefixPtr = hc4->prefixStart;
+    U32 const prefixIdx = hc4->dictLimit;
+    U32 const target = (U32)(ip - prefixPtr) + prefixIdx;
+    U32 idx = hc4->nextToUpdate;
+    assert(ip >= prefixPtr);
+    assert(target >= prefixIdx);
+
+    while (idx < target) {
+        U32 const h = LZ4HC_hashPtr(prefixPtr+idx-prefixIdx);
+        size_t delta = idx - hashTable[h];
+        if (delta>LZ4_DISTANCE_MAX) delta = LZ4_DISTANCE_MAX;
+        DELTANEXTU16(chainTable, idx) = (U16)delta;
+        hashTable[h] = idx;
+        idx++;
+    }
+
+    hc4->nextToUpdate = target;
+}
+
+#if defined(_MSC_VER)
+#  define LZ4HC_rotl32(x,r) _rotl(x,r)
+#else
+#  define LZ4HC_rotl32(x,r) ((x << r) | (x >> (32 - r)))
+#endif
+
+
+static U32 LZ4HC_rotatePattern(size_t const rotate, U32 const pattern)
+{
+    size_t const bitsToRotate = (rotate & (sizeof(pattern) - 1)) << 3;
+    if (bitsToRotate == 0) return pattern;
+    return LZ4HC_rotl32(pattern, (int)bitsToRotate);
+}
+
+/* LZ4HC_countPattern() :
+ * pattern32 must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!) */
+static unsigned
+LZ4HC_countPattern(const BYTE* ip, const BYTE* const iEnd, U32 const pattern32)
+{
+    const BYTE* const iStart = ip;
+    reg_t const pattern = (sizeof(pattern)==8) ?
+        (reg_t)pattern32 + (((reg_t)pattern32) << (sizeof(pattern)*4)) : pattern32;
+
+    while (likely(ip < iEnd-(sizeof(pattern)-1))) {
+        reg_t const diff = LZ4_read_ARCH(ip) ^ pattern;
+        if (!diff) { ip+=sizeof(pattern); continue; }
+        ip += LZ4_NbCommonBytes(diff);
+        return (unsigned)(ip - iStart);
+    }
+
+    if (LZ4_isLittleEndian()) {
+        reg_t patternByte = pattern;
+        while ((ip<iEnd) && (*ip == (BYTE)patternByte)) {
+            ip++; patternByte >>= 8;
+        }
+    } else {  /* big endian */
+        U32 bitOffset = (sizeof(pattern)*8) - 8;
+        while (ip < iEnd) {
+            BYTE const byte = (BYTE)(pattern >> bitOffset);
+            if (*ip != byte) break;
+            ip ++; bitOffset -= 8;
+    }   }
+
+    return (unsigned)(ip - iStart);
+}
+
+/* LZ4HC_reverseCountPattern() :
+ * pattern must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!)
+ * read using natural platform endianness */
+static unsigned
+LZ4HC_reverseCountPattern(const BYTE* ip, const BYTE* const iLow, U32 pattern)
+{
+    const BYTE* const iStart = ip;
+
+    while (likely(ip >= iLow+4)) {
+        if (LZ4_read32(ip-4) != pattern) break;
+        ip -= 4;
+    }
+    {   const BYTE* bytePtr = (const BYTE*)(&pattern) + 3; /* works for any endianness */
+        while (likely(ip>iLow)) {
+            if (ip[-1] != *bytePtr) break;
+            ip--; bytePtr--;
+    }   }
+    return (unsigned)(iStart - ip);
+}
+
+/* LZ4HC_protectDictEnd() :
+ * Checks if the match is in the last 3 bytes of the dictionary, so reading the
+ * 4 byte MINMATCH would overflow.
+ * @returns true if the match index is okay.
+ */
+static int LZ4HC_protectDictEnd(U32 const dictLimit, U32 const matchIndex)
+{
+    return ((U32)((dictLimit - 1) - matchIndex) >= 3);
+}
+
+typedef enum { rep_untested, rep_not, rep_confirmed } repeat_state_e;
+typedef enum { favorCompressionRatio=0, favorDecompressionSpeed } HCfavor_e;
+
+
+LZ4_FORCE_INLINE LZ4HC_match_t
+LZ4HC_InsertAndGetWiderMatch (
+        LZ4HC_CCtx_internal* const hc4,
+        const BYTE* const ip,
+        const BYTE* const iLowLimit, const BYTE* const iHighLimit,
+        int longest,
+        const int maxNbAttempts,
+        const int patternAnalysis, const int chainSwap,
+        const dictCtx_directive dict,
+        const HCfavor_e favorDecSpeed)
+{
+    U16* const chainTable = hc4->chainTable;
+    U32* const hashTable = hc4->hashTable;
+    const LZ4HC_CCtx_internal* const dictCtx = hc4->dictCtx;
+    const BYTE* const prefixPtr = hc4->prefixStart;
+    const U32 prefixIdx = hc4->dictLimit;
+    const U32 ipIndex = (U32)(ip - prefixPtr) + prefixIdx;
+    const int withinStartDistance = (hc4->lowLimit + (LZ4_DISTANCE_MAX + 1) > ipIndex);
+    const U32 lowestMatchIndex = (withinStartDistance) ? hc4->lowLimit : ipIndex - LZ4_DISTANCE_MAX;
+    const BYTE* const dictStart = hc4->dictStart;
+    const U32 dictIdx = hc4->lowLimit;
+    const BYTE* const dictEnd = dictStart + prefixIdx - dictIdx;
+    int const lookBackLength = (int)(ip-iLowLimit);
+    int nbAttempts = maxNbAttempts;
+    U32 matchChainPos = 0;
+    U32 const pattern = LZ4_read32(ip);
+    U32 matchIndex;
+    repeat_state_e repeat = rep_untested;
+    size_t srcPatternLength = 0;
+    int offset = 0, sBack = 0;
+
+    DEBUGLOG(7, "LZ4HC_InsertAndGetWiderMatch");
+    /* First Match */
+    LZ4HC_Insert(hc4, ip);  /* insert all prior positions up to ip (excluded) */
+    matchIndex = hashTable[LZ4HC_hashPtr(ip)];
+    DEBUGLOG(7, "First candidate match for pos %u found at index %u / %u (lowestMatchIndex)",
+                ipIndex, matchIndex, lowestMatchIndex);
+
+    while ((matchIndex>=lowestMatchIndex) && (nbAttempts>0)) {
+        int matchLength=0;
+        nbAttempts--;
+        assert(matchIndex < ipIndex);
+        if (favorDecSpeed && (ipIndex - matchIndex < 8)) {
+            /* do nothing:
+             * favorDecSpeed intentionally skips matches with offset < 8 */
+        } else if (matchIndex >= prefixIdx) {   /* within current Prefix */
+            const BYTE* const matchPtr = prefixPtr + (matchIndex - prefixIdx);
+            assert(matchPtr < ip);
+            assert(longest >= 1);
+            if (LZ4_read16(iLowLimit + longest - 1) == LZ4_read16(matchPtr - lookBackLength + longest - 1)) {
+                if (LZ4_read32(matchPtr) == pattern) {
+                    int const back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, prefixPtr) : 0;
+                    matchLength = MINMATCH + (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, iHighLimit);
+                    matchLength -= back;
+                    if (matchLength > longest) {
+                        longest = matchLength;
+                        offset = (int)(ipIndex - matchIndex);
+                        sBack = back;
+                        DEBUGLOG(7, "Found match of len=%i within prefix, offset=%i, back=%i", longest, offset, -back);
+            }   }   }
+        } else {   /* lowestMatchIndex <= matchIndex < dictLimit : within Ext Dict */
+            const BYTE* const matchPtr = dictStart + (matchIndex - dictIdx);
+            assert(matchIndex >= dictIdx);
+            if ( likely(matchIndex <= prefixIdx - 4)
+              && (LZ4_read32(matchPtr) == pattern) ) {
+                int back = 0;
+                const BYTE* vLimit = ip + (prefixIdx - matchIndex);
+                if (vLimit > iHighLimit) vLimit = iHighLimit;
+                matchLength = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH;
+                if ((ip+matchLength == vLimit) && (vLimit < iHighLimit))
+                    matchLength += LZ4_count(ip+matchLength, prefixPtr, iHighLimit);
+                back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictStart) : 0;
+                matchLength -= back;
+                if (matchLength > longest) {
+                    longest = matchLength;
+                    offset = (int)(ipIndex - matchIndex);
+                    sBack = back;
+                    DEBUGLOG(7, "Found match of len=%i within dict, offset=%i, back=%i", longest, offset, -back);
+        }   }   }
+
+        if (chainSwap && matchLength==longest) {   /* better match => select a better chain */
+            assert(lookBackLength==0);   /* search forward only */
+            if (matchIndex + (U32)longest <= ipIndex) {
+                int const kTrigger = 4;
+                U32 distanceToNextMatch = 1;
+                int const end = longest - MINMATCH + 1;
+                int step = 1;
+                int accel = 1 << kTrigger;
+                int pos;
+                for (pos = 0; pos < end; pos += step) {
+                    U32 const candidateDist = DELTANEXTU16(chainTable, matchIndex + (U32)pos);
+                    step = (accel++ >> kTrigger);
+                    if (candidateDist > distanceToNextMatch) {
+                        distanceToNextMatch = candidateDist;
+                        matchChainPos = (U32)pos;
+                        accel = 1 << kTrigger;
+                }   }
+                if (distanceToNextMatch > 1) {
+                    if (distanceToNextMatch > matchIndex) break;   /* avoid overflow */
+                    matchIndex -= distanceToNextMatch;
+                    continue;
+        }   }   }
+
+        {   U32 const distNextMatch = DELTANEXTU16(chainTable, matchIndex);
+            if (patternAnalysis && distNextMatch==1 && matchChainPos==0) {
+                U32 const matchCandidateIdx = matchIndex-1;
+                /* may be a repeated pattern */
+                if (repeat == rep_untested) {
+                    if ( ((pattern & 0xFFFF) == (pattern >> 16))
+                      &  ((pattern & 0xFF)   == (pattern >> 24)) ) {
+                        DEBUGLOG(7, "Repeat pattern detected, char %02X", pattern >> 24);
+                        repeat = rep_confirmed;
+                        srcPatternLength = LZ4HC_countPattern(ip+sizeof(pattern), iHighLimit, pattern) + sizeof(pattern);
+                    } else {
+                        repeat = rep_not;
+                }   }
+                if ( (repeat == rep_confirmed) && (matchCandidateIdx >= lowestMatchIndex)
+                  && LZ4HC_protectDictEnd(prefixIdx, matchCandidateIdx) ) {
+                    const int extDict = matchCandidateIdx < prefixIdx;
+                    const BYTE* const matchPtr = extDict ? dictStart + (matchCandidateIdx - dictIdx) : prefixPtr + (matchCandidateIdx - prefixIdx);
+                    if (LZ4_read32(matchPtr) == pattern) {  /* good candidate */
+                        const BYTE* const iLimit = extDict ? dictEnd : iHighLimit;
+                        size_t forwardPatternLength = LZ4HC_countPattern(matchPtr+sizeof(pattern), iLimit, pattern) + sizeof(pattern);
+                        if (extDict && matchPtr + forwardPatternLength == iLimit) {
+                            U32 const rotatedPattern = LZ4HC_rotatePattern(forwardPatternLength, pattern);
+                            forwardPatternLength += LZ4HC_countPattern(prefixPtr, iHighLimit, rotatedPattern);
+                        }
+                        {   const BYTE* const lowestMatchPtr = extDict ? dictStart : prefixPtr;
+                            size_t backLength = LZ4HC_reverseCountPattern(matchPtr, lowestMatchPtr, pattern);
+                            size_t currentSegmentLength;
+                            if (!extDict
+                              && matchPtr - backLength == prefixPtr
+                              && dictIdx < prefixIdx) {
+                                U32 const rotatedPattern = LZ4HC_rotatePattern((U32)(-(int)backLength), pattern);
+                                backLength += LZ4HC_reverseCountPattern(dictEnd, dictStart, rotatedPattern);
+                            }
+                            /* Limit backLength not go further than lowestMatchIndex */
+                            backLength = matchCandidateIdx - MAX(matchCandidateIdx - (U32)backLength, lowestMatchIndex);
+                            assert(matchCandidateIdx - backLength >= lowestMatchIndex);
+                            currentSegmentLength = backLength + forwardPatternLength;
+                            /* Adjust to end of pattern if the source pattern fits, otherwise the beginning of the pattern */
+                            if ( (currentSegmentLength >= srcPatternLength)   /* current pattern segment large enough to contain full srcPatternLength */
+                              && (forwardPatternLength <= srcPatternLength) ) { /* haven't reached this position yet */
+                                U32 const newMatchIndex = matchCandidateIdx + (U32)forwardPatternLength - (U32)srcPatternLength;  /* best position, full pattern, might be followed by more match */
+                                if (LZ4HC_protectDictEnd(prefixIdx, newMatchIndex))
+                                    matchIndex = newMatchIndex;
+                                else {
+                                    /* Can only happen if started in the prefix */
+                                    assert(newMatchIndex >= prefixIdx - 3 && newMatchIndex < prefixIdx && !extDict);
+                                    matchIndex = prefixIdx;
+                                }
+                            } else {
+                                U32 const newMatchIndex = matchCandidateIdx - (U32)backLength;   /* farthest position in current segment, will find a match of length currentSegmentLength + maybe some back */
+                                if (!LZ4HC_protectDictEnd(prefixIdx, newMatchIndex)) {
+                                    assert(newMatchIndex >= prefixIdx - 3 && newMatchIndex < prefixIdx && !extDict);
+                                    matchIndex = prefixIdx;
+                                } else {
+                                    matchIndex = newMatchIndex;
+                                    if (lookBackLength==0) {  /* no back possible */
+                                        size_t const maxML = MIN(currentSegmentLength, srcPatternLength);
+                                        if ((size_t)longest < maxML) {
+                                            assert(prefixPtr - prefixIdx + matchIndex != ip);
+                                            if ((size_t)(ip - prefixPtr) + prefixIdx - matchIndex > LZ4_DISTANCE_MAX) break;
+                                            assert(maxML < 2 GB);
+                                            longest = (int)maxML;
+                                            offset = (int)(ipIndex - matchIndex);
+                                            assert(sBack == 0);
+                                            DEBUGLOG(7, "Found repeat pattern match of len=%i, offset=%i", longest, offset);
+                                        }
+                                        {   U32 const distToNextPattern = DELTANEXTU16(chainTable, matchIndex);
+                                            if (distToNextPattern > matchIndex) break;  /* avoid overflow */
+                                            matchIndex -= distToNextPattern;
+                        }   }   }   }   }
+                        continue;
+                }   }
+        }   }   /* PA optimization */
+
+        /* follow current chain */
+        matchIndex -= DELTANEXTU16(chainTable, matchIndex + matchChainPos);
+
+    }  /* while ((matchIndex>=lowestMatchIndex) && (nbAttempts)) */
+
+    if ( dict == usingDictCtxHc
+      && nbAttempts > 0
+      && withinStartDistance) {
+        size_t const dictEndOffset = (size_t)(dictCtx->end - dictCtx->prefixStart) + dictCtx->dictLimit;
+        U32 dictMatchIndex = dictCtx->hashTable[LZ4HC_hashPtr(ip)];
+        assert(dictEndOffset <= 1 GB);
+        matchIndex = dictMatchIndex + lowestMatchIndex - (U32)dictEndOffset;
+        if (dictMatchIndex>0) DEBUGLOG(7, "dictEndOffset = %zu, dictMatchIndex = %u => relative matchIndex = %i", dictEndOffset, dictMatchIndex, (int)dictMatchIndex - (int)dictEndOffset);
+        while (ipIndex - matchIndex <= LZ4_DISTANCE_MAX && nbAttempts--) {
+            const BYTE* const matchPtr = dictCtx->prefixStart - dictCtx->dictLimit + dictMatchIndex;
+
+            if (LZ4_read32(matchPtr) == pattern) {
+                int mlt;
+                int back = 0;
+                const BYTE* vLimit = ip + (dictEndOffset - dictMatchIndex);
+                if (vLimit > iHighLimit) vLimit = iHighLimit;
+                mlt = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH;
+                back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictCtx->prefixStart) : 0;
+                mlt -= back;
+                if (mlt > longest) {
+                    longest = mlt;
+                    offset = (int)(ipIndex - matchIndex);
+                    sBack = back;
+                    DEBUGLOG(7, "found match of length %i within extDictCtx", longest);
+            }   }
+
+            {   U32 const nextOffset = DELTANEXTU16(dictCtx->chainTable, dictMatchIndex);
+                dictMatchIndex -= nextOffset;
+                matchIndex -= nextOffset;
+    }   }   }
+
+    {   LZ4HC_match_t md;
+        assert(longest >= 0);
+        md.len = longest;
+        md.off = offset;
+        md.back = sBack;
+        return md;
+    }
+}
+
+LZ4_FORCE_INLINE LZ4HC_match_t
+LZ4HC_InsertAndFindBestMatch(LZ4HC_CCtx_internal* const hc4,   /* Index table will be updated */
+                       const BYTE* const ip, const BYTE* const iLimit,
+                       const int maxNbAttempts,
+                       const int patternAnalysis,
+                       const dictCtx_directive dict)
+{
+    DEBUGLOG(7, "LZ4HC_InsertAndFindBestMatch");
+    /* note : LZ4HC_InsertAndGetWiderMatch() is able to modify the starting position of a match (*startpos),
+     * but this won't be the case here, as we define iLowLimit==ip,
+     * so LZ4HC_InsertAndGetWiderMatch() won't be allowed to search past ip */
+    return LZ4HC_InsertAndGetWiderMatch(hc4, ip, ip, iLimit, MINMATCH-1, maxNbAttempts, patternAnalysis, 0 /*chainSwap*/, dict, favorCompressionRatio);
+}
+
+
+LZ4_FORCE_INLINE int LZ4HC_compress_hashChain (
+    LZ4HC_CCtx_internal* const ctx,
+    const char* const source,
+    char* const dest,
+    int* srcSizePtr,
+    int const maxOutputSize,
+    int maxNbAttempts,
+    const limitedOutput_directive limit,
+    const dictCtx_directive dict
+    )
+{
+    const int inputSize = *srcSizePtr;
+    const int patternAnalysis = (maxNbAttempts > 128);   /* levels 9+ */
+
+    const BYTE* ip = (const BYTE*) source;
+    const BYTE* anchor = ip;
+    const BYTE* const iend = ip + inputSize;
+    const BYTE* const mflimit = iend - MFLIMIT;
+    const BYTE* const matchlimit = (iend - LASTLITERALS);
+
+    BYTE* optr = (BYTE*) dest;
+    BYTE* op = (BYTE*) dest;
+    BYTE* oend = op + maxOutputSize;
+
+    const BYTE* start0;
+    const BYTE* start2 = NULL;
+    const BYTE* start3 = NULL;
+    LZ4HC_match_t m0, m1, m2, m3;
+    const LZ4HC_match_t nomatch = {0, 0, 0};
+
+    /* init */
+    DEBUGLOG(5, "LZ4HC_compress_hashChain (dict?=>%i)", dict);
+    *srcSizePtr = 0;
+    if (limit == fillOutput) oend -= LASTLITERALS;                  /* Hack for support LZ4 format restriction */
+    if (inputSize < LZ4_minLength) goto _last_literals;             /* Input too small, no compression (all literals) */
+
+    /* Main Loop */
+    while (ip <= mflimit) {
+        m1 = LZ4HC_InsertAndFindBestMatch(ctx, ip, matchlimit, maxNbAttempts, patternAnalysis, dict);
+        if (m1.len<MINMATCH) { ip++; continue; }
+
+        /* saved, in case we would skip too much */
+        start0 = ip; m0 = m1;
+
+_Search2:
+        DEBUGLOG(7, "_Search2 (currently found match of size %i)", m1.len);
+        if (ip+m1.len <= mflimit) {
+            start2 = ip + m1.len - 2;
+            m2 = LZ4HC_InsertAndGetWiderMatch(ctx,
+                            start2, ip + 0, matchlimit, m1.len,
+                            maxNbAttempts, patternAnalysis, 0, dict, favorCompressionRatio);
+            start2 += m2.back;
+        } else {
+            m2 = nomatch;  /* do not search further */
+        }
+
+        if (m2.len <= m1.len) { /* No better match => encode ML1 immediately */
+            optr = op;
+            if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
+                    m1.len, m1.off,
+                    limit, oend) )
+                goto _dest_overflow;
+            continue;
+        }
+
+        if (start0 < ip) {   /* first match was skipped at least once */
+            if (start2 < ip + m0.len) {  /* squeezing ML1 between ML0(original ML1) and ML2 */
+                ip = start0; m1 = m0;  /* restore initial Match1 */
+        }   }
+
+        /* Here, start0==ip */
+        if ((start2 - ip) < 3) {  /* First Match too small : removed */
+            ip = start2;
+            m1 = m2;
+            goto _Search2;
+        }
+
+_Search3:
+        if ((start2 - ip) < OPTIMAL_ML) {
+            int correction;
+            int new_ml = m1.len;
+            if (new_ml > OPTIMAL_ML) new_ml = OPTIMAL_ML;
+            if (ip+new_ml > start2 + m2.len - MINMATCH)
+                new_ml = (int)(start2 - ip) + m2.len - MINMATCH;
+            correction = new_ml - (int)(start2 - ip);
+            if (correction > 0) {
+                start2 += correction;
+                m2.len -= correction;
+            }
+        }
+
+        if (start2 + m2.len <= mflimit) {
+            start3 = start2 + m2.len - 3;
+            m3 = LZ4HC_InsertAndGetWiderMatch(ctx,
+                            start3, start2, matchlimit, m2.len,
+                            maxNbAttempts, patternAnalysis, 0, dict, favorCompressionRatio);
+            start3 += m3.back;
+        } else {
+            m3 = nomatch;  /* do not search further */
+        }
+
+        if (m3.len <= m2.len) {  /* No better match => encode ML1 and ML2 */
+            /* ip & ref are known; Now for ml */
+            if (start2 < ip+m1.len) m1.len = (int)(start2 - ip);
+            /* Now, encode 2 sequences */
+            optr = op;
+            if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
+                    m1.len, m1.off,
+                    limit, oend) )
+                goto _dest_overflow;
+            ip = start2;
+            optr = op;
+            if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
+                    m2.len, m2.off,
+                    limit, oend) ) {
+                m1 = m2;
+                goto _dest_overflow;
+            }
+            continue;
+        }
+
+        if (start3 < ip+m1.len+3) {  /* Not enough space for match 2 : remove it */
+            if (start3 >= (ip+m1.len)) {  /* can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 */
+                if (start2 < ip+m1.len) {
+                    int correction = (int)(ip+m1.len - start2);
+                    start2 += correction;
+                    m2.len -= correction;
+                    if (m2.len < MINMATCH) {
+                        start2 = start3;
+                        m2 = m3;
+                    }
+                }
+
+                optr = op;
+                if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
+                        m1.len, m1.off,
+                        limit, oend) )
+                    goto _dest_overflow;
+                ip  = start3;
+                m1 = m3;
+
+                start0 = start2;
+                m0 = m2;
+                goto _Search2;
+            }
+
+            start2 = start3;
+            m2 = m3;
+            goto _Search3;
+        }
+
+        /*
+        * OK, now we have 3 ascending matches;
+        * let's write the first one ML1.
+        * ip & ref are known; Now decide ml.
+        */
+        if (start2 < ip+m1.len) {
+            if ((start2 - ip) < OPTIMAL_ML) {
+                int correction;
+                if (m1.len > OPTIMAL_ML) m1.len = OPTIMAL_ML;
+                if (ip + m1.len > start2 + m2.len - MINMATCH)
+                    m1.len = (int)(start2 - ip) + m2.len - MINMATCH;
+                correction = m1.len - (int)(start2 - ip);
+                if (correction > 0) {
+                    start2 += correction;
+                    m2.len -= correction;
+                }
+            } else {
+                m1.len = (int)(start2 - ip);
+            }
+        }
+        optr = op;
+        if ( LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
+                m1.len, m1.off,
+                limit, oend) )
+            goto _dest_overflow;
+
+        /* ML2 becomes ML1 */
+        ip = start2; m1 = m2;
+
+        /* ML3 becomes ML2 */
+        start2 = start3; m2 = m3;
+
+        /* let's find a new ML3 */
+        goto _Search3;
+    }
+
+_last_literals:
+    /* Encode Last Literals */
+    {   size_t lastRunSize = (size_t)(iend - anchor);  /* literals */
+        size_t llAdd = (lastRunSize + 255 - RUN_MASK) / 255;
+        size_t const totalSize = 1 + llAdd + lastRunSize;
+        if (limit == fillOutput) oend += LASTLITERALS;  /* restore correct value */
+        if (limit && (op + totalSize > oend)) {
+            if (limit == limitedOutput) return 0;
+            /* adapt lastRunSize to fill 'dest' */
+            lastRunSize  = (size_t)(oend - op) - 1 /*token*/;
+            llAdd = (lastRunSize + 256 - RUN_MASK) / 256;
+            lastRunSize -= llAdd;
+        }
+        DEBUGLOG(6, "Final literal run : %i literals", (int)lastRunSize);
+        ip = anchor + lastRunSize;  /* can be != iend if limit==fillOutput */
+
+        if (lastRunSize >= RUN_MASK) {
+            size_t accumulator = lastRunSize - RUN_MASK;
+            *op++ = (RUN_MASK << ML_BITS);
+            for(; accumulator >= 255 ; accumulator -= 255) *op++ = 255;
+            *op++ = (BYTE) accumulator;
+        } else {
+            *op++ = (BYTE)(lastRunSize << ML_BITS);
+        }
+        LZ4_memcpy(op, anchor, lastRunSize);
+        op += lastRunSize;
+    }
+
+    /* End */
+    *srcSizePtr = (int) (((const char*)ip) - source);
+    return (int) (((char*)op)-dest);
+
+_dest_overflow:
+    if (limit == fillOutput) {
+        /* Assumption : @ip, @anchor, @optr and @m1 must be set correctly */
+        size_t const ll = (size_t)(ip - anchor);
+        size_t const ll_addbytes = (ll + 240) / 255;
+        size_t const ll_totalCost = 1 + ll_addbytes + ll;
+        BYTE* const maxLitPos = oend - 3; /* 2 for offset, 1 for token */
+        DEBUGLOG(6, "Last sequence overflowing");
+        op = optr;  /* restore correct out pointer */
+        if (op + ll_totalCost <= maxLitPos) {
+            /* ll validated; now adjust match length */
+            size_t const bytesLeftForMl = (size_t)(maxLitPos - (op+ll_totalCost));
+            size_t const maxMlSize = MINMATCH + (ML_MASK-1) + (bytesLeftForMl * 255);
+            assert(maxMlSize < INT_MAX); assert(m1.len >= 0);
+            if ((size_t)m1.len > maxMlSize) m1.len = (int)maxMlSize;
+            if ((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1 + m1.len >= MFLIMIT) {
+                LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), m1.len, m1.off, notLimited, oend);
+        }   }
+        goto _last_literals;
+    }
+    /* compression failed */
+    return 0;
+}
+
+
+static int LZ4HC_compress_optimal( LZ4HC_CCtx_internal* ctx,
+    const char* const source, char* dst,
+    int* srcSizePtr, int dstCapacity,
+    int const nbSearches, size_t sufficient_len,
+    const limitedOutput_directive limit, int const fullUpdate,
+    const dictCtx_directive dict,
+    const HCfavor_e favorDecSpeed);
+
+LZ4_FORCE_INLINE int
+LZ4HC_compress_generic_internal (
+            LZ4HC_CCtx_internal* const ctx,
+            const char* const src,
+            char* const dst,
+            int* const srcSizePtr,
+            int const dstCapacity,
+            int cLevel,
+            const limitedOutput_directive limit,
+            const dictCtx_directive dict
+            )
+{
+    DEBUGLOG(5, "LZ4HC_compress_generic_internal(src=%p, srcSize=%d)",
+                src, *srcSizePtr);
+
+    if (limit == fillOutput && dstCapacity < 1) return 0;   /* Impossible to store anything */
+    if ((U32)*srcSizePtr > (U32)LZ4_MAX_INPUT_SIZE) return 0;  /* Unsupported input size (too large or negative) */
+
+    ctx->end += *srcSizePtr;
+    {   cParams_t const cParam = LZ4HC_getCLevelParams(cLevel);
+        HCfavor_e const favor = ctx->favorDecSpeed ? favorDecompressionSpeed : favorCompressionRatio;
+        int result;
+
+        if (cParam.strat == lz4mid) {
+            result = LZ4MID_compress(ctx,
+                                src, dst, srcSizePtr, dstCapacity,
+                                limit, dict);
+        } else if (cParam.strat == lz4hc) {
+            result = LZ4HC_compress_hashChain(ctx,
+                                src, dst, srcSizePtr, dstCapacity,
+                                cParam.nbSearches, limit, dict);
+        } else {
+            assert(cParam.strat == lz4opt);
+            result = LZ4HC_compress_optimal(ctx,
+                                src, dst, srcSizePtr, dstCapacity,
+                                cParam.nbSearches, cParam.targetLength, limit,
+                                cLevel >= LZ4HC_CLEVEL_MAX,   /* ultra mode */
+                                dict, favor);
+        }
+        if (result <= 0) ctx->dirty = 1;
+        return result;
+    }
+}
+
+static void LZ4HC_setExternalDict(LZ4HC_CCtx_internal* ctxPtr, const BYTE* newBlock);
+
+static int
+LZ4HC_compress_generic_noDictCtx (
+        LZ4HC_CCtx_internal* const ctx,
+        const char* const src,
+        char* const dst,
+        int* const srcSizePtr,
+        int const dstCapacity,
+        int cLevel,
+        limitedOutput_directive limit
+        )
+{
+    assert(ctx->dictCtx == NULL);
+    return LZ4HC_compress_generic_internal(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit, noDictCtx);
+}
+
+static int isStateCompatible(const LZ4HC_CCtx_internal* ctx1, const LZ4HC_CCtx_internal* ctx2)
+{
+    int const isMid1 = LZ4HC_getCLevelParams(ctx1->compressionLevel).strat == lz4mid;
+    int const isMid2 = LZ4HC_getCLevelParams(ctx2->compressionLevel).strat == lz4mid;
+    return !(isMid1 ^ isMid2);
+}
+
+static int
+LZ4HC_compress_generic_dictCtx (
+        LZ4HC_CCtx_internal* const ctx,
+        const char* const src,
+        char* const dst,
+        int* const srcSizePtr,
+        int const dstCapacity,
+        int cLevel,
+        limitedOutput_directive limit
+        )
+{
+    const size_t position = (size_t)(ctx->end - ctx->prefixStart) + (ctx->dictLimit - ctx->lowLimit);
+    assert(ctx->dictCtx != NULL);
+    if (position >= 64 KB) {
+        ctx->dictCtx = NULL;
+        return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);
+    } else if (position == 0 && *srcSizePtr > 4 KB && isStateCompatible(ctx, ctx->dictCtx)) {
+        LZ4_memcpy(ctx, ctx->dictCtx, sizeof(LZ4HC_CCtx_internal));
+        LZ4HC_setExternalDict(ctx, (const BYTE *)src);
+        ctx->compressionLevel = (short)cLevel;
+        return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);
+    } else {
+        return LZ4HC_compress_generic_internal(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit, usingDictCtxHc);
+    }
+}
+
+static int
+LZ4HC_compress_generic (
+        LZ4HC_CCtx_internal* const ctx,
+        const char* const src,
+        char* const dst,
+        int* const srcSizePtr,
+        int const dstCapacity,
+        int cLevel,
+        limitedOutput_directive limit
+        )
+{
+    if (ctx->dictCtx == NULL) {
+        return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);
+    } else {
+        return LZ4HC_compress_generic_dictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);
+    }
+}
+
+
+int LZ4_sizeofStateHC(void) { return (int)sizeof(LZ4_streamHC_t); }
+
+static size_t LZ4_streamHC_t_alignment(void)
+{
+#if LZ4_ALIGN_TEST
+    typedef struct { char c; LZ4_streamHC_t t; } t_a;
+    return sizeof(t_a) - sizeof(LZ4_streamHC_t);
+#else
+    return 1;  /* effectively disabled */
+#endif
+}
+
+/* state is presumed correctly initialized,
+ * in which case its size and alignment have already been validate */
+int LZ4_compress_HC_extStateHC_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
+{
+    LZ4HC_CCtx_internal* const ctx = &((LZ4_streamHC_t*)state)->internal_donotuse;
+    if (!LZ4_isAligned(state, LZ4_streamHC_t_alignment())) return 0;
+    LZ4_resetStreamHC_fast((LZ4_streamHC_t*)state, compressionLevel);
+    LZ4HC_init_internal (ctx, (const BYTE*)src);
+    if (dstCapacity < LZ4_compressBound(srcSize))
+        return LZ4HC_compress_generic (ctx, src, dst, &srcSize, dstCapacity, compressionLevel, limitedOutput);
+    else
+        return LZ4HC_compress_generic (ctx, src, dst, &srcSize, dstCapacity, compressionLevel, notLimited);
+}
+
+int LZ4_compress_HC_extStateHC (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
+{
+    LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx));
+    if (ctx==NULL) return 0;   /* init failure */
+    return LZ4_compress_HC_extStateHC_fastReset(state, src, dst, srcSize, dstCapacity, compressionLevel);
+}
+
+int LZ4_compress_HC(const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
+{
+    int cSize;
+#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
+    LZ4_streamHC_t* const statePtr = (LZ4_streamHC_t*)ALLOC(sizeof(LZ4_streamHC_t));
+    if (statePtr==NULL) return 0;
+#else
+    LZ4_streamHC_t state;
+    LZ4_streamHC_t* const statePtr = &state;
+#endif
+    DEBUGLOG(5, "LZ4_compress_HC")
+    cSize = LZ4_compress_HC_extStateHC(statePtr, src, dst, srcSize, dstCapacity, compressionLevel);
+#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
+    FREEMEM(statePtr);
+#endif
+    return cSize;
+}
+
+/* state is presumed sized correctly (>= sizeof(LZ4_streamHC_t)) */
+int LZ4_compress_HC_destSize(void* state, const char* source, char* dest, int* sourceSizePtr, int targetDestSize, int cLevel)
+{
+    LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx));
+    if (ctx==NULL) return 0;   /* init failure */
+    LZ4HC_init_internal(&ctx->internal_donotuse, (const BYTE*) source);
+    LZ4_setCompressionLevel(ctx, cLevel);
+    return LZ4HC_compress_generic(&ctx->internal_donotuse, source, dest, sourceSizePtr, targetDestSize, cLevel, fillOutput);
+}
+
+
+
+/**************************************
+*  Streaming Functions
+**************************************/
+/* allocation */
+#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
+LZ4_streamHC_t* LZ4_createStreamHC(void)
+{
+    LZ4_streamHC_t* const state =
+        (LZ4_streamHC_t*)ALLOC_AND_ZERO(sizeof(LZ4_streamHC_t));
+    if (state == NULL) return NULL;
+    LZ4_setCompressionLevel(state, LZ4HC_CLEVEL_DEFAULT);
+    return state;
+}
+
+int LZ4_freeStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr)
+{
+    DEBUGLOG(4, "LZ4_freeStreamHC(%p)", LZ4_streamHCPtr);
+    if (!LZ4_streamHCPtr) return 0;  /* support free on NULL */
+    FREEMEM(LZ4_streamHCPtr);
+    return 0;
+}
+#endif
+
+
+LZ4_streamHC_t* LZ4_initStreamHC (void* buffer, size_t size)
+{
+    LZ4_streamHC_t* const LZ4_streamHCPtr = (LZ4_streamHC_t*)buffer;
+    DEBUGLOG(4, "LZ4_initStreamHC(%p, %u)", buffer, (unsigned)size);
+    /* check conditions */
+    if (buffer == NULL) return NULL;
+    if (size < sizeof(LZ4_streamHC_t)) return NULL;
+    if (!LZ4_isAligned(buffer, LZ4_streamHC_t_alignment())) return NULL;
+    /* init */
+    { LZ4HC_CCtx_internal* const hcstate = &(LZ4_streamHCPtr->internal_donotuse);
+      MEM_INIT(hcstate, 0, sizeof(*hcstate)); }
+    LZ4_setCompressionLevel(LZ4_streamHCPtr, LZ4HC_CLEVEL_DEFAULT);
+    return LZ4_streamHCPtr;
+}
+
+/* just a stub */
+void LZ4_resetStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
+{
+    LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
+    LZ4_setCompressionLevel(LZ4_streamHCPtr, compressionLevel);
+}
+
+void LZ4_resetStreamHC_fast (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
+{
+    LZ4HC_CCtx_internal* const s = &LZ4_streamHCPtr->internal_donotuse;
+    DEBUGLOG(5, "LZ4_resetStreamHC_fast(%p, %d)", LZ4_streamHCPtr, compressionLevel);
+    if (s->dirty) {
+        LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
+    } else {
+        assert(s->end >= s->prefixStart);
+        s->dictLimit += (U32)(s->end - s->prefixStart);
+        s->prefixStart = NULL;
+        s->end = NULL;
+        s->dictCtx = NULL;
+    }
+    LZ4_setCompressionLevel(LZ4_streamHCPtr, compressionLevel);
+}
+
+void LZ4_setCompressionLevel(LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
+{
+    DEBUGLOG(5, "LZ4_setCompressionLevel(%p, %d)", LZ4_streamHCPtr, compressionLevel);
+    if (compressionLevel < 1) compressionLevel = LZ4HC_CLEVEL_DEFAULT;
+    if (compressionLevel > LZ4HC_CLEVEL_MAX) compressionLevel = LZ4HC_CLEVEL_MAX;
+    LZ4_streamHCPtr->internal_donotuse.compressionLevel = (short)compressionLevel;
+}
+
+void LZ4_favorDecompressionSpeed(LZ4_streamHC_t* LZ4_streamHCPtr, int favor)
+{
+    LZ4_streamHCPtr->internal_donotuse.favorDecSpeed = (favor!=0);
+}
+
+/* LZ4_loadDictHC() :
+ * LZ4_streamHCPtr is presumed properly initialized */
+int LZ4_loadDictHC (LZ4_streamHC_t* LZ4_streamHCPtr,
+              const char* dictionary, int dictSize)
+{
+    LZ4HC_CCtx_internal* const ctxPtr = &LZ4_streamHCPtr->internal_donotuse;
+    cParams_t cp;
+    DEBUGLOG(4, "LZ4_loadDictHC(ctx:%p, dict:%p, dictSize:%d, clevel=%d)", LZ4_streamHCPtr, dictionary, dictSize, ctxPtr->compressionLevel);
+    assert(dictSize >= 0);
+    assert(LZ4_streamHCPtr != NULL);
+    if (dictSize > 64 KB) {
+        dictionary += (size_t)dictSize - 64 KB;
+        dictSize = 64 KB;
+    }
+    /* need a full initialization, there are bad side-effects when using resetFast() */
+    {   int const cLevel = ctxPtr->compressionLevel;
+        LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
+        LZ4_setCompressionLevel(LZ4_streamHCPtr, cLevel);
+        cp = LZ4HC_getCLevelParams(cLevel);
+    }
+    LZ4HC_init_internal (ctxPtr, (const BYTE*)dictionary);
+    ctxPtr->end = (const BYTE*)dictionary + dictSize;
+    if (cp.strat == lz4mid) {
+        LZ4MID_fillHTable (ctxPtr, dictionary, (size_t)dictSize);
+    } else {
+        if (dictSize >= LZ4HC_HASHSIZE) LZ4HC_Insert (ctxPtr, ctxPtr->end-3);
+    }
+    return dictSize;
+}
+
+void LZ4_attach_HC_dictionary(LZ4_streamHC_t *working_stream, const LZ4_streamHC_t *dictionary_stream) {
+    working_stream->internal_donotuse.dictCtx = dictionary_stream != NULL ? &(dictionary_stream->internal_donotuse) : NULL;
+}
+
+/* compression */
+
+static void LZ4HC_setExternalDict(LZ4HC_CCtx_internal* ctxPtr, const BYTE* newBlock)
+{
+    DEBUGLOG(4, "LZ4HC_setExternalDict(%p, %p)", ctxPtr, newBlock);
+    if ( (ctxPtr->end >= ctxPtr->prefixStart + 4)
+      && (LZ4HC_getCLevelParams(ctxPtr->compressionLevel).strat != lz4mid) ) {
+        LZ4HC_Insert (ctxPtr, ctxPtr->end-3);  /* Referencing remaining dictionary content */
+    }
+
+    /* Only one memory segment for extDict, so any previous extDict is lost at this stage */
+    ctxPtr->lowLimit  = ctxPtr->dictLimit;
+    ctxPtr->dictStart  = ctxPtr->prefixStart;
+    ctxPtr->dictLimit += (U32)(ctxPtr->end - ctxPtr->prefixStart);
+    ctxPtr->prefixStart = newBlock;
+    ctxPtr->end  = newBlock;
+    ctxPtr->nextToUpdate = ctxPtr->dictLimit;   /* match referencing will resume from there */
+
+    /* cannot reference an extDict and a dictCtx at the same time */
+    ctxPtr->dictCtx = NULL;
+}
+
+static int
+LZ4_compressHC_continue_generic (LZ4_streamHC_t* LZ4_streamHCPtr,
+                                 const char* src, char* dst,
+                                 int* srcSizePtr, int dstCapacity,
+                                 limitedOutput_directive limit)
+{
+    LZ4HC_CCtx_internal* const ctxPtr = &LZ4_streamHCPtr->internal_donotuse;
+    DEBUGLOG(5, "LZ4_compressHC_continue_generic(ctx=%p, src=%p, srcSize=%d, limit=%d)",
+                LZ4_streamHCPtr, src, *srcSizePtr, limit);
+    assert(ctxPtr != NULL);
+    /* auto-init if forgotten */
+    if (ctxPtr->prefixStart == NULL)
+        LZ4HC_init_internal (ctxPtr, (const BYTE*) src);
+
+    /* Check overflow */
+    if ((size_t)(ctxPtr->end - ctxPtr->prefixStart) + ctxPtr->dictLimit > 2 GB) {
+        size_t dictSize = (size_t)(ctxPtr->end - ctxPtr->prefixStart);
+        if (dictSize > 64 KB) dictSize = 64 KB;
+        LZ4_loadDictHC(LZ4_streamHCPtr, (const char*)(ctxPtr->end) - dictSize, (int)dictSize);
+    }
+
+    /* Check if blocks follow each other */
+    if ((const BYTE*)src != ctxPtr->end)
+        LZ4HC_setExternalDict(ctxPtr, (const BYTE*)src);
+
+    /* Check overlapping input/dictionary space */
+    {   const BYTE* sourceEnd = (const BYTE*) src + *srcSizePtr;
+        const BYTE* const dictBegin = ctxPtr->dictStart;
+        const BYTE* const dictEnd   = ctxPtr->dictStart + (ctxPtr->dictLimit - ctxPtr->lowLimit);
+        if ((sourceEnd > dictBegin) && ((const BYTE*)src < dictEnd)) {
+            if (sourceEnd > dictEnd) sourceEnd = dictEnd;
+            ctxPtr->lowLimit += (U32)(sourceEnd - ctxPtr->dictStart);
+            ctxPtr->dictStart += (U32)(sourceEnd - ctxPtr->dictStart);
+            /* invalidate dictionary is it's too small */
+            if (ctxPtr->dictLimit - ctxPtr->lowLimit < LZ4HC_HASHSIZE) {
+                ctxPtr->lowLimit = ctxPtr->dictLimit;
+                ctxPtr->dictStart = ctxPtr->prefixStart;
+    }   }   }
+
+    return LZ4HC_compress_generic (ctxPtr, src, dst, srcSizePtr, dstCapacity, ctxPtr->compressionLevel, limit);
+}
+
+int LZ4_compress_HC_continue (LZ4_streamHC_t* LZ4_streamHCPtr, const char* src, char* dst, int srcSize, int dstCapacity)
+{
+    DEBUGLOG(5, "LZ4_compress_HC_continue");
+    if (dstCapacity < LZ4_compressBound(srcSize))
+        return LZ4_compressHC_continue_generic (LZ4_streamHCPtr, src, dst, &srcSize, dstCapacity, limitedOutput);
+    else
+        return LZ4_compressHC_continue_generic (LZ4_streamHCPtr, src, dst, &srcSize, dstCapacity, notLimited);
+}
+
+int LZ4_compress_HC_continue_destSize (LZ4_streamHC_t* LZ4_streamHCPtr, const char* src, char* dst, int* srcSizePtr, int targetDestSize)
+{
+    return LZ4_compressHC_continue_generic(LZ4_streamHCPtr, src, dst, srcSizePtr, targetDestSize, fillOutput);
+}
+
+
+/* LZ4_saveDictHC :
+ * save history content
+ * into a user-provided buffer
+ * which is then used to continue compression
+ */
+int LZ4_saveDictHC (LZ4_streamHC_t* LZ4_streamHCPtr, char* safeBuffer, int dictSize)
+{
+    LZ4HC_CCtx_internal* const streamPtr = &LZ4_streamHCPtr->internal_donotuse;
+    int const prefixSize = (int)(streamPtr->end - streamPtr->prefixStart);
+    DEBUGLOG(5, "LZ4_saveDictHC(%p, %p, %d)", LZ4_streamHCPtr, safeBuffer, dictSize);
+    assert(prefixSize >= 0);
+    if (dictSize > 64 KB) dictSize = 64 KB;
+    if (dictSize < 4) dictSize = 0;
+    if (dictSize > prefixSize) dictSize = prefixSize;
+    if (safeBuffer == NULL) assert(dictSize == 0);
+    if (dictSize > 0)
+        LZ4_memmove(safeBuffer, streamPtr->end - dictSize, (size_t)dictSize);
+    {   U32 const endIndex = (U32)(streamPtr->end - streamPtr->prefixStart) + streamPtr->dictLimit;
+        streamPtr->end = (safeBuffer == NULL) ? NULL : (const BYTE*)safeBuffer + dictSize;
+        streamPtr->prefixStart = (const BYTE*)safeBuffer;
+        streamPtr->dictLimit = endIndex - (U32)dictSize;
+        streamPtr->lowLimit = endIndex - (U32)dictSize;
+        streamPtr->dictStart = streamPtr->prefixStart;
+        if (streamPtr->nextToUpdate < streamPtr->dictLimit)
+            streamPtr->nextToUpdate = streamPtr->dictLimit;
+    }
+    return dictSize;
+}
+
+
+/* ================================================
+ *  LZ4 Optimal parser (levels [LZ4HC_CLEVEL_OPT_MIN - LZ4HC_CLEVEL_MAX])
+ * ===============================================*/
+typedef struct {
+    int price;
+    int off;
+    int mlen;
+    int litlen;
+} LZ4HC_optimal_t;
+
+/* price in bytes */
+LZ4_FORCE_INLINE int LZ4HC_literalsPrice(int const litlen)
+{
+    int price = litlen;
+    assert(litlen >= 0);
+    if (litlen >= (int)RUN_MASK)
+        price += 1 + ((litlen-(int)RUN_MASK) / 255);
+    return price;
+}
+
+/* requires mlen >= MINMATCH */
+LZ4_FORCE_INLINE int LZ4HC_sequencePrice(int litlen, int mlen)
+{
+    int price = 1 + 2 ; /* token + 16-bit offset */
+    assert(litlen >= 0);
+    assert(mlen >= MINMATCH);
+
+    price += LZ4HC_literalsPrice(litlen);
+
+    if (mlen >= (int)(ML_MASK+MINMATCH))
+        price += 1 + ((mlen-(int)(ML_MASK+MINMATCH)) / 255);
+
+    return price;
+}
+
+LZ4_FORCE_INLINE LZ4HC_match_t
+LZ4HC_FindLongerMatch(LZ4HC_CCtx_internal* const ctx,
+                      const BYTE* ip, const BYTE* const iHighLimit,
+                      int minLen, int nbSearches,
+                      const dictCtx_directive dict,
+                      const HCfavor_e favorDecSpeed)
+{
+    LZ4HC_match_t const match0 = { 0 , 0, 0 };
+    /* note : LZ4HC_InsertAndGetWiderMatch() is able to modify the starting position of a match (*startpos),
+     * but this won't be the case here, as we define iLowLimit==ip,
+    ** so LZ4HC_InsertAndGetWiderMatch() won't be allowed to search past ip */
+    LZ4HC_match_t md = LZ4HC_InsertAndGetWiderMatch(ctx, ip, ip, iHighLimit, minLen, nbSearches, 1 /*patternAnalysis*/, 1 /*chainSwap*/, dict, favorDecSpeed);
+    assert(md.back == 0);
+    if (md.len <= minLen) return match0;
+    if (favorDecSpeed) {
+        if ((md.len>18) & (md.len<=36)) md.len=18;   /* favor dec.speed (shortcut) */
+    }
+    return md;
+}
+
+
+static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
+                                    const char* const source,
+                                    char* dst,
+                                    int* srcSizePtr,
+                                    int dstCapacity,
+                                    int const nbSearches,
+                                    size_t sufficient_len,
+                                    const limitedOutput_directive limit,
+                                    int const fullUpdate,
+                                    const dictCtx_directive dict,
+                                    const HCfavor_e favorDecSpeed)
+{
+    int retval = 0;
+#define TRAILING_LITERALS 3
+#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
+    LZ4HC_optimal_t* const opt = (LZ4HC_optimal_t*)ALLOC(sizeof(LZ4HC_optimal_t) * (LZ4_OPT_NUM + TRAILING_LITERALS));
+#else
+    LZ4HC_optimal_t opt[LZ4_OPT_NUM + TRAILING_LITERALS];   /* ~64 KB, which is a bit large for stack... */
+#endif
+
+    const BYTE* ip = (const BYTE*) source;
+    const BYTE* anchor = ip;
+    const BYTE* const iend = ip + *srcSizePtr;
+    const BYTE* const mflimit = iend - MFLIMIT;
+    const BYTE* const matchlimit = iend - LASTLITERALS;
+    BYTE* op = (BYTE*) dst;
+    BYTE* opSaved = (BYTE*) dst;
+    BYTE* oend = op + dstCapacity;
+    int ovml = MINMATCH;  /* overflow - last sequence */
+    int ovoff = 0;
+
+    /* init */
+#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
+    if (opt == NULL) goto _return_label;
+#endif
+    DEBUGLOG(5, "LZ4HC_compress_optimal(dst=%p, dstCapa=%u)", dst, (unsigned)dstCapacity);
+    *srcSizePtr = 0;
+    if (limit == fillOutput) oend -= LASTLITERALS;   /* Hack for support LZ4 format restriction */
+    if (sufficient_len >= LZ4_OPT_NUM) sufficient_len = LZ4_OPT_NUM-1;
+
+    /* Main Loop */
+    while (ip <= mflimit) {
+         int const llen = (int)(ip - anchor);
+         int best_mlen, best_off;
+         int cur, last_match_pos = 0;
+
+         LZ4HC_match_t const firstMatch = LZ4HC_FindLongerMatch(ctx, ip, matchlimit, MINMATCH-1, nbSearches, dict, favorDecSpeed);
+         if (firstMatch.len==0) { ip++; continue; }
+
+         if ((size_t)firstMatch.len > sufficient_len) {
+             /* good enough solution : immediate encoding */
+             int const firstML = firstMatch.len;
+             opSaved = op;
+             if ( LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), firstML, firstMatch.off, limit, oend) ) {  /* updates ip, op and anchor */
+                 ovml = firstML;
+                 ovoff = firstMatch.off;
+                 goto _dest_overflow;
+             }
+             continue;
+         }
+
+         /* set prices for first positions (literals) */
+         {   int rPos;
+             for (rPos = 0 ; rPos < MINMATCH ; rPos++) {
+                 int const cost = LZ4HC_literalsPrice(llen + rPos);
+                 opt[rPos].mlen = 1;
+                 opt[rPos].off = 0;
+                 opt[rPos].litlen = llen + rPos;
+                 opt[rPos].price = cost;
+                 DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i) -- initial setup",
+                             rPos, cost, opt[rPos].litlen);
+         }   }
+         /* set prices using initial match */
+         {   int const matchML = firstMatch.len;   /* necessarily < sufficient_len < LZ4_OPT_NUM */
+             int const offset = firstMatch.off;
+             int mlen;
+             assert(matchML < LZ4_OPT_NUM);
+             for (mlen = MINMATCH ; mlen <= matchML ; mlen++) {
+                 int const cost = LZ4HC_sequencePrice(llen, mlen);
+                 opt[mlen].mlen = mlen;
+                 opt[mlen].off = offset;
+                 opt[mlen].litlen = llen;
+                 opt[mlen].price = cost;
+                 DEBUGLOG(7, "rPos:%3i => price:%3i (matchlen=%i) -- initial setup",
+                             mlen, cost, mlen);
+         }   }
+         last_match_pos = firstMatch.len;
+         {   int addLit;
+             for (addLit = 1; addLit <= TRAILING_LITERALS; addLit ++) {
+                 opt[last_match_pos+addLit].mlen = 1; /* literal */
+                 opt[last_match_pos+addLit].off = 0;
+                 opt[last_match_pos+addLit].litlen = addLit;
+                 opt[last_match_pos+addLit].price = opt[last_match_pos].price + LZ4HC_literalsPrice(addLit);
+                 DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i) -- initial setup",
+                             last_match_pos+addLit, opt[last_match_pos+addLit].price, addLit);
+         }   }
+
+         /* check further positions */
+         for (cur = 1; cur < last_match_pos; cur++) {
+             const BYTE* const curPtr = ip + cur;
+             LZ4HC_match_t newMatch;
+
+             if (curPtr > mflimit) break;
+             DEBUGLOG(7, "rPos:%u[%u] vs [%u]%u",
+                     cur, opt[cur].price, opt[cur+1].price, cur+1);
+             if (fullUpdate) {
+                 /* not useful to search here if next position has same (or lower) cost */
+                 if ( (opt[cur+1].price <= opt[cur].price)
+                   /* in some cases, next position has same cost, but cost rises sharply after, so a small match would still be beneficial */
+                   && (opt[cur+MINMATCH].price < opt[cur].price + 3/*min seq price*/) )
+                     continue;
+             } else {
+                 /* not useful to search here if next position has same (or lower) cost */
+                 if (opt[cur+1].price <= opt[cur].price) continue;
+             }
+
+             DEBUGLOG(7, "search at rPos:%u", cur);
+             if (fullUpdate)
+                 newMatch = LZ4HC_FindLongerMatch(ctx, curPtr, matchlimit, MINMATCH-1, nbSearches, dict, favorDecSpeed);
+             else
+                 /* only test matches of minimum length; slightly faster, but misses a few bytes */
+                 newMatch = LZ4HC_FindLongerMatch(ctx, curPtr, matchlimit, last_match_pos - cur, nbSearches, dict, favorDecSpeed);
+             if (!newMatch.len) continue;
+
+             if ( ((size_t)newMatch.len > sufficient_len)
+               || (newMatch.len + cur >= LZ4_OPT_NUM) ) {
+                 /* immediate encoding */
+                 best_mlen = newMatch.len;
+                 best_off = newMatch.off;
+                 last_match_pos = cur + 1;
+                 goto encode;
+             }
+
+             /* before match : set price with literals at beginning */
+             {   int const baseLitlen = opt[cur].litlen;
+                 int litlen;
+                 for (litlen = 1; litlen < MINMATCH; litlen++) {
+                     int const price = opt[cur].price - LZ4HC_literalsPrice(baseLitlen) + LZ4HC_literalsPrice(baseLitlen+litlen);
+                     int const pos = cur + litlen;
+                     if (price < opt[pos].price) {
+                         opt[pos].mlen = 1; /* literal */
+                         opt[pos].off = 0;
+                         opt[pos].litlen = baseLitlen+litlen;
+                         opt[pos].price = price;
+                         DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i)",
+                                     pos, price, opt[pos].litlen);
+             }   }   }
+
+             /* set prices using match at position = cur */
+             {   int const matchML = newMatch.len;
+                 int ml = MINMATCH;
+
+                 assert(cur + newMatch.len < LZ4_OPT_NUM);
+                 for ( ; ml <= matchML ; ml++) {
+                     int const pos = cur + ml;
+                     int const offset = newMatch.off;
+                     int price;
+                     int ll;
+                     DEBUGLOG(7, "testing price rPos %i (last_match_pos=%i)",
+                                 pos, last_match_pos);
+                     if (opt[cur].mlen == 1) {
+                         ll = opt[cur].litlen;
+                         price = ((cur > ll) ? opt[cur - ll].price : 0)
+                               + LZ4HC_sequencePrice(ll, ml);
+                     } else {
+                         ll = 0;
+                         price = opt[cur].price + LZ4HC_sequencePrice(0, ml);
+                     }
+
+                    assert((U32)favorDecSpeed <= 1);
+                     if (pos > last_match_pos+TRAILING_LITERALS
+                      || price <= opt[pos].price - (int)favorDecSpeed) {
+                         DEBUGLOG(7, "rPos:%3i => price:%3i (matchlen=%i)",
+                                     pos, price, ml);
+                         assert(pos < LZ4_OPT_NUM);
+                         if ( (ml == matchML)  /* last pos of last match */
+                           && (last_match_pos < pos) )
+                             last_match_pos = pos;
+                         opt[pos].mlen = ml;
+                         opt[pos].off = offset;
+                         opt[pos].litlen = ll;
+                         opt[pos].price = price;
+             }   }   }
+             /* complete following positions with literals */
+             {   int addLit;
+                 for (addLit = 1; addLit <= TRAILING_LITERALS; addLit ++) {
+                     opt[last_match_pos+addLit].mlen = 1; /* literal */
+                     opt[last_match_pos+addLit].off = 0;
+                     opt[last_match_pos+addLit].litlen = addLit;
+                     opt[last_match_pos+addLit].price = opt[last_match_pos].price + LZ4HC_literalsPrice(addLit);
+                     DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i)", last_match_pos+addLit, opt[last_match_pos+addLit].price, addLit);
+             }   }
+         }  /* for (cur = 1; cur <= last_match_pos; cur++) */
+
+         assert(last_match_pos < LZ4_OPT_NUM + TRAILING_LITERALS);
+         best_mlen = opt[last_match_pos].mlen;
+         best_off = opt[last_match_pos].off;
+         cur = last_match_pos - best_mlen;
+
+encode: /* cur, last_match_pos, best_mlen, best_off must be set */
+         assert(cur < LZ4_OPT_NUM);
+         assert(last_match_pos >= 1);  /* == 1 when only one candidate */
+         DEBUGLOG(6, "reverse traversal, looking for shortest path (last_match_pos=%i)", last_match_pos);
+         {   int candidate_pos = cur;
+             int selected_matchLength = best_mlen;
+             int selected_offset = best_off;
+             while (1) {  /* from end to beginning */
+                 int const next_matchLength = opt[candidate_pos].mlen;  /* can be 1, means literal */
+                 int const next_offset = opt[candidate_pos].off;
+                 DEBUGLOG(7, "pos %i: sequence length %i", candidate_pos, selected_matchLength);
+                 opt[candidate_pos].mlen = selected_matchLength;
+                 opt[candidate_pos].off = selected_offset;
+                 selected_matchLength = next_matchLength;
+                 selected_offset = next_offset;
+                 if (next_matchLength > candidate_pos) break; /* last match elected, first match to encode */
+                 assert(next_matchLength > 0);  /* can be 1, means literal */
+                 candidate_pos -= next_matchLength;
+         }   }
+
+         /* encode all recorded sequences in order */
+         {   int rPos = 0;  /* relative position (to ip) */
+             while (rPos < last_match_pos) {
+                 int const ml = opt[rPos].mlen;
+                 int const offset = opt[rPos].off;
+                 if (ml == 1) { ip++; rPos++; continue; }  /* literal; note: can end up with several literals, in which case, skip them */
+                 rPos += ml;
+                 assert(ml >= MINMATCH);
+                 assert((offset >= 1) && (offset <= LZ4_DISTANCE_MAX));
+                 opSaved = op;
+                 if ( LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, offset, limit, oend) ) {  /* updates ip, op and anchor */
+                     ovml = ml;
+                     ovoff = offset;
+                     goto _dest_overflow;
+         }   }   }
+     }  /* while (ip <= mflimit) */
+
+_last_literals:
+     /* Encode Last Literals */
+     {   size_t lastRunSize = (size_t)(iend - anchor);  /* literals */
+         size_t llAdd = (lastRunSize + 255 - RUN_MASK) / 255;
+         size_t const totalSize = 1 + llAdd + lastRunSize;
+         if (limit == fillOutput) oend += LASTLITERALS;  /* restore correct value */
+         if (limit && (op + totalSize > oend)) {
+             if (limit == limitedOutput) { /* Check output limit */
+                retval = 0;
+                goto _return_label;
+             }
+             /* adapt lastRunSize to fill 'dst' */
+             lastRunSize  = (size_t)(oend - op) - 1 /*token*/;
+             llAdd = (lastRunSize + 256 - RUN_MASK) / 256;
+             lastRunSize -= llAdd;
+         }
+         DEBUGLOG(6, "Final literal run : %i literals", (int)lastRunSize);
+         ip = anchor + lastRunSize; /* can be != iend if limit==fillOutput */
+
+         if (lastRunSize >= RUN_MASK) {
+             size_t accumulator = lastRunSize - RUN_MASK;
+             *op++ = (RUN_MASK << ML_BITS);
+             for(; accumulator >= 255 ; accumulator -= 255) *op++ = 255;
+             *op++ = (BYTE) accumulator;
+         } else {
+             *op++ = (BYTE)(lastRunSize << ML_BITS);
+         }
+         LZ4_memcpy(op, anchor, lastRunSize);
+         op += lastRunSize;
+     }
+
+     /* End */
+     *srcSizePtr = (int) (((const char*)ip) - source);
+     retval = (int) ((char*)op-dst);
+     goto _return_label;
+
+_dest_overflow:
+if (limit == fillOutput) {
+     /* Assumption : ip, anchor, ovml and ovref must be set correctly */
+     size_t const ll = (size_t)(ip - anchor);
+     size_t const ll_addbytes = (ll + 240) / 255;
+     size_t const ll_totalCost = 1 + ll_addbytes + ll;
+     BYTE* const maxLitPos = oend - 3; /* 2 for offset, 1 for token */
+     DEBUGLOG(6, "Last sequence overflowing (only %i bytes remaining)", (int)(oend-1-opSaved));
+     op = opSaved;  /* restore correct out pointer */
+     if (op + ll_totalCost <= maxLitPos) {
+         /* ll validated; now adjust match length */
+         size_t const bytesLeftForMl = (size_t)(maxLitPos - (op+ll_totalCost));
+         size_t const maxMlSize = MINMATCH + (ML_MASK-1) + (bytesLeftForMl * 255);
+         assert(maxMlSize < INT_MAX); assert(ovml >= 0);
+         if ((size_t)ovml > maxMlSize) ovml = (int)maxMlSize;
+         if ((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1 + ovml >= MFLIMIT) {
+             DEBUGLOG(6, "Space to end : %i + ml (%i)", (int)((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1), ovml);
+             DEBUGLOG(6, "Before : ip = %p, anchor = %p", ip, anchor);
+             LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ovml, ovoff, notLimited, oend);
+             DEBUGLOG(6, "After : ip = %p, anchor = %p", ip, anchor);
+     }   }
+     goto _last_literals;
+}
+_return_label:
+#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
+     if (opt) FREEMEM(opt);
+#endif
+     return retval;
+}
+
+
+/***************************************************
+*  Deprecated Functions
+***************************************************/
+
+/* These functions currently generate deprecation warnings */
+
+/* Wrappers for deprecated compression functions */
+int LZ4_compressHC(const char* src, char* dst, int srcSize) { return LZ4_compress_HC (src, dst, srcSize, LZ4_compressBound(srcSize), 0); }
+int LZ4_compressHC_limitedOutput(const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_HC(src, dst, srcSize, maxDstSize, 0); }
+int LZ4_compressHC2(const char* src, char* dst, int srcSize, int cLevel) { return LZ4_compress_HC (src, dst, srcSize, LZ4_compressBound(srcSize), cLevel); }
+int LZ4_compressHC2_limitedOutput(const char* src, char* dst, int srcSize, int maxDstSize, int cLevel) { return LZ4_compress_HC(src, dst, srcSize, maxDstSize, cLevel); }
+int LZ4_compressHC_withStateHC (void* state, const char* src, char* dst, int srcSize) { return LZ4_compress_HC_extStateHC (state, src, dst, srcSize, LZ4_compressBound(srcSize), 0); }
+int LZ4_compressHC_limitedOutput_withStateHC (void* state, const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_HC_extStateHC (state, src, dst, srcSize, maxDstSize, 0); }
+int LZ4_compressHC2_withStateHC (void* state, const char* src, char* dst, int srcSize, int cLevel) { return LZ4_compress_HC_extStateHC(state, src, dst, srcSize, LZ4_compressBound(srcSize), cLevel); }
+int LZ4_compressHC2_limitedOutput_withStateHC (void* state, const char* src, char* dst, int srcSize, int maxDstSize, int cLevel) { return LZ4_compress_HC_extStateHC(state, src, dst, srcSize, maxDstSize, cLevel); }
+int LZ4_compressHC_continue (LZ4_streamHC_t* ctx, const char* src, char* dst, int srcSize) { return LZ4_compress_HC_continue (ctx, src, dst, srcSize, LZ4_compressBound(srcSize)); }
+int LZ4_compressHC_limitedOutput_continue (LZ4_streamHC_t* ctx, const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_HC_continue (ctx, src, dst, srcSize, maxDstSize); }
+
+
+/* Deprecated streaming functions */
+int LZ4_sizeofStreamStateHC(void) { return sizeof(LZ4_streamHC_t); }
+
+/* state is presumed correctly sized, aka >= sizeof(LZ4_streamHC_t)
+ * @return : 0 on success, !=0 if error */
+int LZ4_resetStreamStateHC(void* state, char* inputBuffer)
+{
+    LZ4_streamHC_t* const hc4 = LZ4_initStreamHC(state, sizeof(*hc4));
+    if (hc4 == NULL) return 1;   /* init failed */
+    LZ4HC_init_internal (&hc4->internal_donotuse, (const BYTE*)inputBuffer);
+    return 0;
+}
+
+#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
+void* LZ4_createHC (const char* inputBuffer)
+{
+    LZ4_streamHC_t* const hc4 = LZ4_createStreamHC();
+    if (hc4 == NULL) return NULL;   /* not enough memory */
+    LZ4HC_init_internal (&hc4->internal_donotuse, (const BYTE*)inputBuffer);
+    return hc4;
+}
+
+int LZ4_freeHC (void* LZ4HC_Data)
+{
+    if (!LZ4HC_Data) return 0;  /* support free on NULL */
+    FREEMEM(LZ4HC_Data);
+    return 0;
+}
+#endif
+
+int LZ4_compressHC2_continue (void* LZ4HC_Data, const char* src, char* dst, int srcSize, int cLevel)
+{
+    return LZ4HC_compress_generic (&((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse, src, dst, &srcSize, 0, cLevel, notLimited);
+}
+
+int LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* src, char* dst, int srcSize, int dstCapacity, int cLevel)
+{
+    return LZ4HC_compress_generic (&((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse, src, dst, &srcSize, dstCapacity, cLevel, limitedOutput);
+}
+
+char* LZ4_slideInputBufferHC(void* LZ4HC_Data)
+{
+    LZ4HC_CCtx_internal* const s = &((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse;
+    const BYTE* const bufferStart = s->prefixStart - s->dictLimit + s->lowLimit;
+    LZ4_resetStreamHC_fast((LZ4_streamHC_t*)LZ4HC_Data, s->compressionLevel);
+    /* ugly conversion trick, required to evade (const char*) -> (char*) cast-qual warning :( */
+    return (char*)(uptrval)bufferStart;
+}
diff --git a/native/lz4/vendor/lib/lz4hc.h b/native/lz4/vendor/lib/lz4hc.h
new file mode 100644
index 0000000..992bc8c
--- /dev/null
+++ b/native/lz4/vendor/lib/lz4hc.h
@@ -0,0 +1,414 @@
+/*
+   LZ4 HC - High Compression Mode of LZ4
+   Header File
+   Copyright (C) 2011-2020, Yann Collet.
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - LZ4 source repository : https://github.com/lz4/lz4
+   - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
+*/
+#ifndef LZ4_HC_H_19834876238432
+#define LZ4_HC_H_19834876238432
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/* --- Dependency --- */
+/* note : lz4hc requires lz4.h/lz4.c for compilation */
+#include "lz4.h"   /* stddef, LZ4LIB_API, LZ4_DEPRECATED */
+
+
+/* --- Useful constants --- */
+#define LZ4HC_CLEVEL_MIN         2
+#define LZ4HC_CLEVEL_DEFAULT     9
+#define LZ4HC_CLEVEL_OPT_MIN    10
+#define LZ4HC_CLEVEL_MAX        12
+
+
+/*-************************************
+ *  Block Compression
+ **************************************/
+/*! LZ4_compress_HC() :
+ *  Compress data from `src` into `dst`, using the powerful but slower "HC" algorithm.
+ * `dst` must be already allocated.
+ *  Compression is guaranteed to succeed if `dstCapacity >= LZ4_compressBound(srcSize)` (see "lz4.h")
+ *  Max supported `srcSize` value is LZ4_MAX_INPUT_SIZE (see "lz4.h")
+ * `compressionLevel` : any value between 1 and LZ4HC_CLEVEL_MAX will work.
+ *                      Values > LZ4HC_CLEVEL_MAX behave the same as LZ4HC_CLEVEL_MAX.
+ * @return : the number of bytes written into 'dst'
+ *           or 0 if compression fails.
+ */
+LZ4LIB_API int LZ4_compress_HC (const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel);
+
+
+/* Note :
+ *   Decompression functions are provided within "lz4.h" (BSD license)
+ */
+
+
+/*! LZ4_compress_HC_extStateHC() :
+ *  Same as LZ4_compress_HC(), but using an externally allocated memory segment for `state`.
+ * `state` size is provided by LZ4_sizeofStateHC().
+ *  Memory segment must be aligned on 8-bytes boundaries (which a normal malloc() should do properly).
+ */
+LZ4LIB_API int LZ4_sizeofStateHC(void);
+LZ4LIB_API int LZ4_compress_HC_extStateHC(void* stateHC, const char* src, char* dst, int srcSize, int maxDstSize, int compressionLevel);
+
+
+/*! LZ4_compress_HC_destSize() : v1.9.0+
+ *  Will compress as much data as possible from `src`
+ *  to fit into `targetDstSize` budget.
+ *  Result is provided in 2 parts :
+ * @return : the number of bytes written into 'dst' (necessarily <= targetDstSize)
+ *           or 0 if compression fails.
+ * `srcSizePtr` : on success, *srcSizePtr is updated to indicate how much bytes were read from `src`
+ */
+LZ4LIB_API int LZ4_compress_HC_destSize(void* stateHC,
+                                  const char* src, char* dst,
+                                        int* srcSizePtr, int targetDstSize,
+                                        int compressionLevel);
+
+
+/*-************************************
+ *  Streaming Compression
+ *  Bufferless synchronous API
+ **************************************/
+ typedef union LZ4_streamHC_u LZ4_streamHC_t;   /* incomplete type (defined later) */
+
+/*! LZ4_createStreamHC() and LZ4_freeStreamHC() :
+ *  These functions create and release memory for LZ4 HC streaming state.
+ *  Newly created states are automatically initialized.
+ *  A same state can be used multiple times consecutively,
+ *  starting with LZ4_resetStreamHC_fast() to start a new stream of blocks.
+ */
+LZ4LIB_API LZ4_streamHC_t* LZ4_createStreamHC(void);
+LZ4LIB_API int             LZ4_freeStreamHC (LZ4_streamHC_t* streamHCPtr);
+
+/*
+  These functions compress data in successive blocks of any size,
+  using previous blocks as dictionary, to improve compression ratio.
+  One key assumption is that previous blocks (up to 64 KB) remain read-accessible while compressing next blocks.
+  There is an exception for ring buffers, which can be smaller than 64 KB.
+  Ring-buffer scenario is automatically detected and handled within LZ4_compress_HC_continue().
+
+  Before starting compression, state must be allocated and properly initialized.
+  LZ4_createStreamHC() does both, though compression level is set to LZ4HC_CLEVEL_DEFAULT.
+
+  Selecting the compression level can be done with LZ4_resetStreamHC_fast() (starts a new stream)
+  or LZ4_setCompressionLevel() (anytime, between blocks in the same stream) (experimental).
+  LZ4_resetStreamHC_fast() only works on states which have been properly initialized at least once,
+  which is automatically the case when state is created using LZ4_createStreamHC().
+
+  After reset, a first "fictional block" can be designated as initial dictionary,
+  using LZ4_loadDictHC() (Optional).
+  Note: In order for LZ4_loadDictHC() to create the correct data structure,
+  it is essential to set the compression level _before_ loading the dictionary.
+
+  Invoke LZ4_compress_HC_continue() to compress each successive block.
+  The number of blocks is unlimited.
+  Previous input blocks, including initial dictionary when present,
+  must remain accessible and unmodified during compression.
+
+  It's allowed to update compression level anytime between blocks,
+  using LZ4_setCompressionLevel() (experimental).
+
+ @dst buffer should be sized to handle worst case scenarios
+  (see LZ4_compressBound(), it ensures compression success).
+  In case of failure, the API does not guarantee recovery,
+  so the state _must_ be reset.
+  To ensure compression success
+  whenever @dst buffer size cannot be made >= LZ4_compressBound(),
+  consider using LZ4_compress_HC_continue_destSize().
+
+  Whenever previous input blocks can't be preserved unmodified in-place during compression of next blocks,
+  it's possible to copy the last blocks into a more stable memory space, using LZ4_saveDictHC().
+  Return value of LZ4_saveDictHC() is the size of dictionary effectively saved into 'safeBuffer' (<= 64 KB)
+
+  After completing a streaming compression,
+  it's possible to start a new stream of blocks, using the same LZ4_streamHC_t state,
+  just by resetting it, using LZ4_resetStreamHC_fast().
+*/
+
+LZ4LIB_API void LZ4_resetStreamHC_fast(LZ4_streamHC_t* streamHCPtr, int compressionLevel);   /* v1.9.0+ */
+LZ4LIB_API int  LZ4_loadDictHC (LZ4_streamHC_t* streamHCPtr, const char* dictionary, int dictSize);
+
+LZ4LIB_API int LZ4_compress_HC_continue (LZ4_streamHC_t* streamHCPtr,
+                                   const char* src, char* dst,
+                                         int srcSize, int maxDstSize);
+
+/*! LZ4_compress_HC_continue_destSize() : v1.9.0+
+ *  Similar to LZ4_compress_HC_continue(),
+ *  but will read as much data as possible from `src`
+ *  to fit into `targetDstSize` budget.
+ *  Result is provided into 2 parts :
+ * @return : the number of bytes written into 'dst' (necessarily <= targetDstSize)
+ *           or 0 if compression fails.
+ * `srcSizePtr` : on success, *srcSizePtr will be updated to indicate how much bytes were read from `src`.
+ *           Note that this function may not consume the entire input.
+ */
+LZ4LIB_API int LZ4_compress_HC_continue_destSize(LZ4_streamHC_t* LZ4_streamHCPtr,
+                                           const char* src, char* dst,
+                                                 int* srcSizePtr, int targetDstSize);
+
+LZ4LIB_API int LZ4_saveDictHC (LZ4_streamHC_t* streamHCPtr, char* safeBuffer, int maxDictSize);
+
+
+/*! LZ4_attach_HC_dictionary() : stable since v1.10.0
+ *  This API allows for the efficient re-use of a static dictionary many times.
+ *
+ *  Rather than re-loading the dictionary buffer into a working context before
+ *  each compression, or copying a pre-loaded dictionary's LZ4_streamHC_t into a
+ *  working LZ4_streamHC_t, this function introduces a no-copy setup mechanism,
+ *  in which the working stream references the dictionary stream in-place.
+ *
+ *  Several assumptions are made about the state of the dictionary stream.
+ *  Currently, only streams which have been prepared by LZ4_loadDictHC() should
+ *  be expected to work.
+ *
+ *  Alternatively, the provided dictionary stream pointer may be NULL, in which
+ *  case any existing dictionary stream is unset.
+ *
+ *  A dictionary should only be attached to a stream without any history (i.e.,
+ *  a stream that has just been reset).
+ *
+ *  The dictionary will remain attached to the working stream only for the
+ *  current stream session. Calls to LZ4_resetStreamHC(_fast) will remove the
+ *  dictionary context association from the working stream. The dictionary
+ *  stream (and source buffer) must remain in-place / accessible / unchanged
+ *  through the lifetime of the stream session.
+ */
+LZ4LIB_API void
+LZ4_attach_HC_dictionary(LZ4_streamHC_t* working_stream,
+                   const LZ4_streamHC_t* dictionary_stream);
+
+
+/*^**********************************************
+ * !!!!!!   STATIC LINKING ONLY   !!!!!!
+ ***********************************************/
+
+/*-******************************************************************
+ * PRIVATE DEFINITIONS :
+ * Do not use these definitions directly.
+ * They are merely exposed to allow static allocation of `LZ4_streamHC_t`.
+ * Declare an `LZ4_streamHC_t` directly, rather than any type below.
+ * Even then, only do so in the context of static linking, as definitions may change between versions.
+ ********************************************************************/
+
+#define LZ4HC_DICTIONARY_LOGSIZE 16
+#define LZ4HC_MAXD (1<<LZ4HC_DICTIONARY_LOGSIZE)
+#define LZ4HC_MAXD_MASK (LZ4HC_MAXD - 1)
+
+#define LZ4HC_HASH_LOG 15
+#define LZ4HC_HASHTABLESIZE (1 << LZ4HC_HASH_LOG)
+#define LZ4HC_HASH_MASK (LZ4HC_HASHTABLESIZE - 1)
+
+
+/* Never ever use these definitions directly !
+ * Declare or allocate an LZ4_streamHC_t instead.
+**/
+typedef struct LZ4HC_CCtx_internal LZ4HC_CCtx_internal;
+struct LZ4HC_CCtx_internal
+{
+    LZ4_u32 hashTable[LZ4HC_HASHTABLESIZE];
+    LZ4_u16 chainTable[LZ4HC_MAXD];
+    const LZ4_byte* end;     /* next block here to continue on current prefix */
+    const LZ4_byte* prefixStart;  /* Indexes relative to this position */
+    const LZ4_byte* dictStart; /* alternate reference for extDict */
+    LZ4_u32 dictLimit;       /* below that point, need extDict */
+    LZ4_u32 lowLimit;        /* below that point, no more history */
+    LZ4_u32 nextToUpdate;    /* index from which to continue dictionary update */
+    short   compressionLevel;
+    LZ4_i8  favorDecSpeed;   /* favor decompression speed if this flag set,
+                                otherwise, favor compression ratio */
+    LZ4_i8  dirty;           /* stream has to be fully reset if this flag is set */
+    const LZ4HC_CCtx_internal* dictCtx;
+};
+
+#define LZ4_STREAMHC_MINSIZE  262200  /* static size, for inter-version compatibility */
+union LZ4_streamHC_u {
+    char minStateSize[LZ4_STREAMHC_MINSIZE];
+    LZ4HC_CCtx_internal internal_donotuse;
+}; /* previously typedef'd to LZ4_streamHC_t */
+
+/* LZ4_streamHC_t :
+ * This structure allows static allocation of LZ4 HC streaming state.
+ * This can be used to allocate statically on stack, or as part of a larger structure.
+ *
+ * Such state **must** be initialized using LZ4_initStreamHC() before first use.
+ *
+ * Note that invoking LZ4_initStreamHC() is not required when
+ * the state was created using LZ4_createStreamHC() (which is recommended).
+ * Using the normal builder, a newly created state is automatically initialized.
+ *
+ * Static allocation shall only be used in combination with static linking.
+ */
+
+/* LZ4_initStreamHC() : v1.9.0+
+ * Required before first use of a statically allocated LZ4_streamHC_t.
+ * Before v1.9.0 : use LZ4_resetStreamHC() instead
+ */
+LZ4LIB_API LZ4_streamHC_t* LZ4_initStreamHC(void* buffer, size_t size);
+
+
+/*-************************************
+*  Deprecated Functions
+**************************************/
+/* see lz4.h LZ4_DISABLE_DEPRECATE_WARNINGS to turn off deprecation warnings */
+
+/* deprecated compression functions */
+LZ4_DEPRECATED("use LZ4_compress_HC() instead") LZ4LIB_API int LZ4_compressHC               (const char* source, char* dest, int inputSize);
+LZ4_DEPRECATED("use LZ4_compress_HC() instead") LZ4LIB_API int LZ4_compressHC_limitedOutput (const char* source, char* dest, int inputSize, int maxOutputSize);
+LZ4_DEPRECATED("use LZ4_compress_HC() instead") LZ4LIB_API int LZ4_compressHC2              (const char* source, char* dest, int inputSize, int compressionLevel);
+LZ4_DEPRECATED("use LZ4_compress_HC() instead") LZ4LIB_API int LZ4_compressHC2_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
+LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") LZ4LIB_API int LZ4_compressHC_withStateHC               (void* state, const char* source, char* dest, int inputSize);
+LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") LZ4LIB_API int LZ4_compressHC_limitedOutput_withStateHC (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
+LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") LZ4LIB_API int LZ4_compressHC2_withStateHC              (void* state, const char* source, char* dest, int inputSize, int compressionLevel);
+LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") LZ4LIB_API int LZ4_compressHC2_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
+LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") LZ4LIB_API int LZ4_compressHC_continue               (LZ4_streamHC_t* LZ4_streamHCPtr, const char* source, char* dest, int inputSize);
+LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") LZ4LIB_API int LZ4_compressHC_limitedOutput_continue (LZ4_streamHC_t* LZ4_streamHCPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
+
+/* Obsolete streaming functions; degraded functionality; do not use!
+ *
+ * In order to perform streaming compression, these functions depended on data
+ * that is no longer tracked in the state. They have been preserved as well as
+ * possible: using them will still produce a correct output. However, use of
+ * LZ4_slideInputBufferHC() will truncate the history of the stream, rather
+ * than preserve a window-sized chunk of history.
+ */
+#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
+LZ4_DEPRECATED("use LZ4_createStreamHC() instead") LZ4LIB_API void* LZ4_createHC (const char* inputBuffer);
+LZ4_DEPRECATED("use LZ4_freeStreamHC() instead") LZ4LIB_API   int   LZ4_freeHC (void* LZ4HC_Data);
+#endif
+LZ4_DEPRECATED("use LZ4_saveDictHC() instead") LZ4LIB_API     char* LZ4_slideInputBufferHC (void* LZ4HC_Data);
+LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") LZ4LIB_API int LZ4_compressHC2_continue               (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int compressionLevel);
+LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") LZ4LIB_API int LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
+LZ4_DEPRECATED("use LZ4_createStreamHC() instead") LZ4LIB_API int   LZ4_sizeofStreamStateHC(void);
+LZ4_DEPRECATED("use LZ4_initStreamHC() instead") LZ4LIB_API  int   LZ4_resetStreamStateHC(void* state, char* inputBuffer);
+
+
+/* LZ4_resetStreamHC() is now replaced by LZ4_initStreamHC().
+ * The intention is to emphasize the difference with LZ4_resetStreamHC_fast(),
+ * which is now the recommended function to start a new stream of blocks,
+ * but cannot be used to initialize a memory segment containing arbitrary garbage data.
+ *
+ * It is recommended to switch to LZ4_initStreamHC().
+ * LZ4_resetStreamHC() will generate deprecation warnings in a future version.
+ */
+LZ4LIB_API void LZ4_resetStreamHC (LZ4_streamHC_t* streamHCPtr, int compressionLevel);
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* LZ4_HC_H_19834876238432 */
+
+
+/*-**************************************************
+ * !!!!!     STATIC LINKING ONLY     !!!!!
+ * Following definitions are considered experimental.
+ * They should not be linked from DLL,
+ * as there is no guarantee of API stability yet.
+ * Prototypes will be promoted to "stable" status
+ * after successful usage in real-life scenarios.
+ ***************************************************/
+#ifdef LZ4_HC_STATIC_LINKING_ONLY   /* protection macro */
+#ifndef LZ4_HC_SLO_098092834
+#define LZ4_HC_SLO_098092834
+
+#define LZ4_STATIC_LINKING_ONLY   /* LZ4LIB_STATIC_API */
+#include "lz4.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+/*! LZ4_setCompressionLevel() : v1.8.0+ (experimental)
+ *  It's possible to change compression level
+ *  between successive invocations of LZ4_compress_HC_continue*()
+ *  for dynamic adaptation.
+ */
+LZ4LIB_STATIC_API void LZ4_setCompressionLevel(
+    LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel);
+
+/*! LZ4_favorDecompressionSpeed() : v1.8.2+ (experimental)
+ *  Opt. Parser will favor decompression speed over compression ratio.
+ *  Only applicable to levels >= LZ4HC_CLEVEL_OPT_MIN.
+ */
+LZ4LIB_STATIC_API void LZ4_favorDecompressionSpeed(
+    LZ4_streamHC_t* LZ4_streamHCPtr, int favor);
+
+/*! LZ4_resetStreamHC_fast() : v1.9.0+
+ *  When an LZ4_streamHC_t is known to be in a internally coherent state,
+ *  it can often be prepared for a new compression with almost no work, only
+ *  sometimes falling back to the full, expensive reset that is always required
+ *  when the stream is in an indeterminate state (i.e., the reset performed by
+ *  LZ4_resetStreamHC()).
+ *
+ *  LZ4_streamHCs are guaranteed to be in a valid state when:
+ *  - returned from LZ4_createStreamHC()
+ *  - reset by LZ4_resetStreamHC()
+ *  - memset(stream, 0, sizeof(LZ4_streamHC_t))
+ *  - the stream was in a valid state and was reset by LZ4_resetStreamHC_fast()
+ *  - the stream was in a valid state and was then used in any compression call
+ *    that returned success
+ *  - the stream was in an indeterminate state and was used in a compression
+ *    call that fully reset the state (LZ4_compress_HC_extStateHC()) and that
+ *    returned success
+ *
+ *  Note:
+ *  A stream that was last used in a compression call that returned an error
+ *  may be passed to this function. However, it will be fully reset, which will
+ *  clear any existing history and settings from the context.
+ */
+LZ4LIB_STATIC_API void LZ4_resetStreamHC_fast(
+    LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel);
+
+/*! LZ4_compress_HC_extStateHC_fastReset() :
+ *  A variant of LZ4_compress_HC_extStateHC().
+ *
+ *  Using this variant avoids an expensive initialization step. It is only safe
+ *  to call if the state buffer is known to be correctly initialized already
+ *  (see above comment on LZ4_resetStreamHC_fast() for a definition of
+ *  "correctly initialized"). From a high level, the difference is that this
+ *  function initializes the provided state with a call to
+ *  LZ4_resetStreamHC_fast() while LZ4_compress_HC_extStateHC() starts with a
+ *  call to LZ4_resetStreamHC().
+ */
+LZ4LIB_STATIC_API int LZ4_compress_HC_extStateHC_fastReset (
+    void* state,
+    const char* src, char* dst,
+    int srcSize, int dstCapacity,
+    int compressionLevel);
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif   /* LZ4_HC_SLO_098092834 */
+#endif   /* LZ4_HC_STATIC_LINKING_ONLY */
diff --git a/native/lz4/vendor/lib/xxhash.c b/native/lz4/vendor/lib/xxhash.c
new file mode 100644
index 0000000..e132619
--- /dev/null
+++ b/native/lz4/vendor/lib/xxhash.c
@@ -0,0 +1,1030 @@
+/*
+*  xxHash - Fast Hash algorithm
+*  Copyright (C) 2012-2016, Yann Collet
+*
+*  BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+*
+*  Redistribution and use in source and binary forms, with or without
+*  modification, are permitted provided that the following conditions are
+*  met:
+*
+*  * Redistributions of source code must retain the above copyright
+*  notice, this list of conditions and the following disclaimer.
+*  * Redistributions in binary form must reproduce the above
+*  copyright notice, this list of conditions and the following disclaimer
+*  in the documentation and/or other materials provided with the
+*  distribution.
+*
+*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+*  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+*  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*
+*  You can contact the author at :
+*  - xxHash homepage: http://www.xxhash.com
+*  - xxHash source repository : https://github.com/Cyan4973/xxHash
+*/
+
+
+/* *************************************
+*  Tuning parameters
+***************************************/
+/*!XXH_FORCE_MEMORY_ACCESS :
+ * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
+ * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
+ * The below switch allow to select different access method for improved performance.
+ * Method 0 (default) : use `memcpy()`. Safe and portable.
+ * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
+ *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
+ * Method 2 : direct access. This method doesn't depend on compiler but violate C standard.
+ *            It can generate buggy code on targets which do not support unaligned memory accesses.
+ *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
+ * See http://stackoverflow.com/a/32095106/646947 for details.
+ * Prefer these methods in priority order (0 > 1 > 2)
+ */
+#ifndef XXH_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
+#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) \
+                        || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) \
+                        || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
+#    define XXH_FORCE_MEMORY_ACCESS 2
+#  elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || \
+  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) \
+                    || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) \
+                    || defined(__ARM_ARCH_7S__) ))
+#    define XXH_FORCE_MEMORY_ACCESS 1
+#  endif
+#endif
+
+/*!XXH_ACCEPT_NULL_INPUT_POINTER :
+ * If input pointer is NULL, xxHash default behavior is to dereference it, triggering a segfault.
+ * When this macro is enabled, xxHash actively checks input for null pointer.
+ * It it is, result for null input pointers is the same as a null-length input.
+ */
+#ifndef XXH_ACCEPT_NULL_INPUT_POINTER   /* can be defined externally */
+#  define XXH_ACCEPT_NULL_INPUT_POINTER 0
+#endif
+
+/*!XXH_FORCE_NATIVE_FORMAT :
+ * By default, xxHash library provides endian-independent Hash values, based on little-endian convention.
+ * Results are therefore identical for little-endian and big-endian CPU.
+ * This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format.
+ * Should endian-independence be of no importance for your application, you may set the #define below to 1,
+ * to improve speed for Big-endian CPU.
+ * This option has no impact on Little_Endian CPU.
+ */
+#ifndef XXH_FORCE_NATIVE_FORMAT   /* can be defined externally */
+#  define XXH_FORCE_NATIVE_FORMAT 0
+#endif
+
+/*!XXH_FORCE_ALIGN_CHECK :
+ * This is a minor performance trick, only useful with lots of very small keys.
+ * It means : check for aligned/unaligned input.
+ * The check costs one initial branch per hash;
+ * set it to 0 when the input is guaranteed to be aligned,
+ * or when alignment doesn't matter for performance.
+ */
+#ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */
+#  if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
+#    define XXH_FORCE_ALIGN_CHECK 0
+#  else
+#    define XXH_FORCE_ALIGN_CHECK 1
+#  endif
+#endif
+
+
+/* *************************************
+*  Includes & Memory related functions
+***************************************/
+/*! Modify the local functions below should you wish to use some other memory routines
+*   for malloc(), free() */
+#include <stdlib.h>
+static void* XXH_malloc(size_t s) { return malloc(s); }
+static void  XXH_free  (void* p)  { free(p); }
+/*! and for memcpy() */
+#include <string.h>
+static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); }
+
+#include <assert.h>   /* assert */
+
+#define XXH_STATIC_LINKING_ONLY
+#include "xxhash.h"
+
+
+/* *************************************
+*  Compiler Specific Options
+***************************************/
+#if defined (_MSC_VER) && !defined (__clang__)    /* MSVC */
+#  pragma warning(disable : 4127)      /* disable: C4127: conditional expression is constant */
+#  define FORCE_INLINE static __forceinline
+#else
+#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#    if defined (__GNUC__) || defined (__clang__)
+#      define FORCE_INLINE static inline __attribute__((always_inline))
+#    else
+#      define FORCE_INLINE static inline
+#    endif
+#  else
+#    define FORCE_INLINE static
+#  endif /* __STDC_VERSION__ */
+#endif
+
+
+/* *************************************
+*  Basic Types
+***************************************/
+#ifndef MEM_MODULE
+# if !defined (__VMS) \
+  && (defined (__cplusplus) \
+  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+#   include <stdint.h>
+    typedef uint8_t  BYTE;
+    typedef uint16_t U16;
+    typedef uint32_t U32;
+# else
+    typedef unsigned char      BYTE;
+    typedef unsigned short     U16;
+    typedef unsigned int       U32;
+# endif
+#endif
+
+#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))
+
+/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */
+static U32 XXH_read32(const void* memPtr) { return *(const U32*) memPtr; }
+
+#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))
+
+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
+/* currently only defined for gcc and icc */
+typedef union { U32 u32; } __attribute__((packed)) unalign;
+static U32 XXH_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
+
+#else
+
+/* portable and safe solution. Generally efficient.
+ * see : http://stackoverflow.com/a/32095106/646947
+ */
+static U32 XXH_read32(const void* memPtr)
+{
+    U32 val;
+    memcpy(&val, memPtr, sizeof(val));
+    return val;
+}
+
+#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */
+
+
+/* ****************************************
+*  Compiler-specific Functions and Macros
+******************************************/
+#define XXH_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+
+/* Note : although _rotl exists for minGW (GCC under windows), performance seems poor */
+#if defined(_MSC_VER)
+#  define XXH_rotl32(x,r) _rotl(x,r)
+#  define XXH_rotl64(x,r) _rotl64(x,r)
+#else
+#  define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r)))
+#  define XXH_rotl64(x,r) ((x << r) | (x >> (64 - r)))
+#endif
+
+#if defined(_MSC_VER)     /* Visual Studio */
+#  define XXH_swap32 _byteswap_ulong
+#elif XXH_GCC_VERSION >= 403
+#  define XXH_swap32 __builtin_bswap32
+#else
+static U32 XXH_swap32 (U32 x)
+{
+    return  ((x << 24) & 0xff000000 ) |
+            ((x <<  8) & 0x00ff0000 ) |
+            ((x >>  8) & 0x0000ff00 ) |
+            ((x >> 24) & 0x000000ff );
+}
+#endif
+
+
+/* *************************************
+*  Architecture Macros
+***************************************/
+typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianness;
+
+/* XXH_CPU_LITTLE_ENDIAN can be defined externally, for example on the compiler command line */
+#ifndef XXH_CPU_LITTLE_ENDIAN
+static int XXH_isLittleEndian(void)
+{
+    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
+    return one.c[0];
+}
+#   define XXH_CPU_LITTLE_ENDIAN   XXH_isLittleEndian()
+#endif
+
+
+/* ***************************
+*  Memory reads
+*****************************/
+typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;
+
+FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianness endian, XXH_alignment align)
+{
+    if (align==XXH_unaligned)
+        return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));
+    else
+        return endian==XXH_littleEndian ? *(const U32*)ptr : XXH_swap32(*(const U32*)ptr);
+}
+
+FORCE_INLINE U32 XXH_readLE32(const void* ptr, XXH_endianness endian)
+{
+    return XXH_readLE32_align(ptr, endian, XXH_unaligned);
+}
+
+static U32 XXH_readBE32(const void* ptr)
+{
+    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr);
+}
+
+
+/* *************************************
+*  Macros
+***************************************/
+#define XXH_STATIC_ASSERT(c)  { enum { XXH_sa = 1/(int)(!!(c)) }; }  /* use after variable declarations */
+XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; }
+
+
+/* *******************************************************************
+*  32-bit hash functions
+*********************************************************************/
+static const U32 PRIME32_1 = 2654435761U;
+static const U32 PRIME32_2 = 2246822519U;
+static const U32 PRIME32_3 = 3266489917U;
+static const U32 PRIME32_4 =  668265263U;
+static const U32 PRIME32_5 =  374761393U;
+
+static U32 XXH32_round(U32 seed, U32 input)
+{
+    seed += input * PRIME32_2;
+    seed  = XXH_rotl32(seed, 13);
+    seed *= PRIME32_1;
+    return seed;
+}
+
+/* mix all bits */
+static U32 XXH32_avalanche(U32 h32)
+{
+    h32 ^= h32 >> 15;
+    h32 *= PRIME32_2;
+    h32 ^= h32 >> 13;
+    h32 *= PRIME32_3;
+    h32 ^= h32 >> 16;
+    return(h32);
+}
+
+#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align)
+
+static U32
+XXH32_finalize(U32 h32, const void* ptr, size_t len,
+                XXH_endianness endian, XXH_alignment align)
+
+{
+    const BYTE* p = (const BYTE*)ptr;
+
+#define PROCESS1               \
+    h32 += (*p++) * PRIME32_5; \
+    h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;
+
+#define PROCESS4                         \
+    h32 += XXH_get32bits(p) * PRIME32_3; \
+    p+=4;                                \
+    h32  = XXH_rotl32(h32, 17) * PRIME32_4 ;
+
+    switch(len&15)  /* or switch(bEnd - p) */
+    {
+      case 12:      PROCESS4;
+                    /* fallthrough */
+      case 8:       PROCESS4;
+                    /* fallthrough */
+      case 4:       PROCESS4;
+                    return XXH32_avalanche(h32);
+
+      case 13:      PROCESS4;
+                    /* fallthrough */
+      case 9:       PROCESS4;
+                    /* fallthrough */
+      case 5:       PROCESS4;
+                    PROCESS1;
+                    return XXH32_avalanche(h32);
+
+      case 14:      PROCESS4;
+                    /* fallthrough */
+      case 10:      PROCESS4;
+                    /* fallthrough */
+      case 6:       PROCESS4;
+                    PROCESS1;
+                    PROCESS1;
+                    return XXH32_avalanche(h32);
+
+      case 15:      PROCESS4;
+                    /* fallthrough */
+      case 11:      PROCESS4;
+                    /* fallthrough */
+      case 7:       PROCESS4;
+                    /* fallthrough */
+      case 3:       PROCESS1;
+                    /* fallthrough */
+      case 2:       PROCESS1;
+                    /* fallthrough */
+      case 1:       PROCESS1;
+                    /* fallthrough */
+      case 0:       return XXH32_avalanche(h32);
+    }
+    assert(0);
+    return h32;   /* reaching this point is deemed impossible */
+}
+
+
+FORCE_INLINE U32
+XXH32_endian_align(const void* input, size_t len, U32 seed,
+                    XXH_endianness endian, XXH_alignment align)
+{
+    const BYTE* p = (const BYTE*)input;
+    const BYTE* bEnd = p + len;
+    U32 h32;
+
+#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
+    if (p==NULL) {
+        len=0;
+        bEnd=p=(const BYTE*)(size_t)16;
+    }
+#endif
+
+    if (len>=16) {
+        const BYTE* const limit = bEnd - 15;
+        U32 v1 = seed + PRIME32_1 + PRIME32_2;
+        U32 v2 = seed + PRIME32_2;
+        U32 v3 = seed + 0;
+        U32 v4 = seed - PRIME32_1;
+
+        do {
+            v1 = XXH32_round(v1, XXH_get32bits(p)); p+=4;
+            v2 = XXH32_round(v2, XXH_get32bits(p)); p+=4;
+            v3 = XXH32_round(v3, XXH_get32bits(p)); p+=4;
+            v4 = XXH32_round(v4, XXH_get32bits(p)); p+=4;
+        } while (p < limit);
+
+        h32 = XXH_rotl32(v1, 1)  + XXH_rotl32(v2, 7)
+            + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
+    } else {
+        h32  = seed + PRIME32_5;
+    }
+
+    h32 += (U32)len;
+
+    return XXH32_finalize(h32, p, len&15, endian, align);
+}
+
+
+XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int seed)
+{
+#if 0
+    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
+    XXH32_state_t state;
+    XXH32_reset(&state, seed);
+    XXH32_update(&state, input, len);
+    return XXH32_digest(&state);
+#else
+    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
+
+    if (XXH_FORCE_ALIGN_CHECK) {
+        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
+            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+                return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
+            else
+                return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
+    }   }
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
+    else
+        return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
+#endif
+}
+
+
+
+/*======   Hash streaming   ======*/
+
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)
+{
+    return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));
+}
+XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
+{
+    XXH_free(statePtr);
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dstState, const XXH32_state_t* srcState)
+{
+    memcpy(dstState, srcState, sizeof(*dstState));
+}
+
+XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed)
+{
+    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
+    memset(&state, 0, sizeof(state));
+    state.v1 = seed + PRIME32_1 + PRIME32_2;
+    state.v2 = seed + PRIME32_2;
+    state.v3 = seed + 0;
+    state.v4 = seed - PRIME32_1;
+    /* do not write into reserved, planned to be removed in a future version */
+    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
+    return XXH_OK;
+}
+
+
+FORCE_INLINE XXH_errorcode
+XXH32_update_endian(XXH32_state_t* state, const void* input, size_t len, XXH_endianness endian)
+{
+    if (input==NULL)
+#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
+        return XXH_OK;
+#else
+        return XXH_ERROR;
+#endif
+
+    {   const BYTE* p = (const BYTE*)input;
+        const BYTE* const bEnd = p + len;
+
+        state->total_len_32 += (unsigned)len;
+        state->large_len |= (len>=16) | (state->total_len_32>=16);
+
+        if (state->memsize + len < 16)  {   /* fill in tmp buffer */
+            XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len);
+            state->memsize += (unsigned)len;
+            return XXH_OK;
+        }
+
+        if (state->memsize) {   /* some data left from previous update */
+            XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize);
+            {   const U32* p32 = state->mem32;
+                state->v1 = XXH32_round(state->v1, XXH_readLE32(p32, endian)); p32++;
+                state->v2 = XXH32_round(state->v2, XXH_readLE32(p32, endian)); p32++;
+                state->v3 = XXH32_round(state->v3, XXH_readLE32(p32, endian)); p32++;
+                state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian));
+            }
+            p += 16-state->memsize;
+            state->memsize = 0;
+        }
+
+        if (p <= bEnd-16) {
+            const BYTE* const limit = bEnd - 16;
+            U32 v1 = state->v1;
+            U32 v2 = state->v2;
+            U32 v3 = state->v3;
+            U32 v4 = state->v4;
+
+            do {
+                v1 = XXH32_round(v1, XXH_readLE32(p, endian)); p+=4;
+                v2 = XXH32_round(v2, XXH_readLE32(p, endian)); p+=4;
+                v3 = XXH32_round(v3, XXH_readLE32(p, endian)); p+=4;
+                v4 = XXH32_round(v4, XXH_readLE32(p, endian)); p+=4;
+            } while (p<=limit);
+
+            state->v1 = v1;
+            state->v2 = v2;
+            state->v3 = v3;
+            state->v4 = v4;
+        }
+
+        if (p < bEnd) {
+            XXH_memcpy(state->mem32, p, (size_t)(bEnd-p));
+            state->memsize = (unsigned)(bEnd-p);
+        }
+    }
+
+    return XXH_OK;
+}
+
+
+XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t len)
+{
+    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH32_update_endian(state_in, input, len, XXH_littleEndian);
+    else
+        return XXH32_update_endian(state_in, input, len, XXH_bigEndian);
+}
+
+
+FORCE_INLINE U32
+XXH32_digest_endian (const XXH32_state_t* state, XXH_endianness endian)
+{
+    U32 h32;
+
+    if (state->large_len) {
+        h32 = XXH_rotl32(state->v1, 1)
+            + XXH_rotl32(state->v2, 7)
+            + XXH_rotl32(state->v3, 12)
+            + XXH_rotl32(state->v4, 18);
+    } else {
+        h32 = state->v3 /* == seed */ + PRIME32_5;
+    }
+
+    h32 += state->total_len_32;
+
+    return XXH32_finalize(h32, state->mem32, state->memsize, endian, XXH_aligned);
+}
+
+
+XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in)
+{
+    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH32_digest_endian(state_in, XXH_littleEndian);
+    else
+        return XXH32_digest_endian(state_in, XXH_bigEndian);
+}
+
+
+/*======   Canonical representation   ======*/
+
+/*! Default XXH result types are basic unsigned 32 and 64 bits.
+*   The canonical representation follows human-readable write convention, aka big-endian (large digits first).
+*   These functions allow transformation of hash result into and from its canonical format.
+*   This way, hash values can be written into a file or buffer, remaining comparable across different systems.
+*/
+
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash)
+{
+    XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t));
+    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);
+    memcpy(dst, &hash, sizeof(*dst));
+}
+
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src)
+{
+    return XXH_readBE32(src);
+}
+
+
+#ifndef XXH_NO_LONG_LONG
+
+/* *******************************************************************
+*  64-bit hash functions
+*********************************************************************/
+
+/*======   Memory access   ======*/
+
+#ifndef MEM_MODULE
+# define MEM_MODULE
+# if !defined (__VMS) \
+  && (defined (__cplusplus) \
+  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+#   include <stdint.h>
+    typedef uint64_t U64;
+# else
+    /* if compiler doesn't support unsigned long long, replace by another 64-bit type */
+    typedef unsigned long long U64;
+# endif
+#endif
+
+
+#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))
+
+/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */
+static U64 XXH_read64(const void* memPtr) { return *(const U64*) memPtr; }
+
+#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))
+
+/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
+/* currently only defined for gcc and icc */
+typedef union { U32 u32; U64 u64; } __attribute__((packed)) unalign64;
+static U64 XXH_read64(const void* ptr) { return ((const unalign64*)ptr)->u64; }
+
+#else
+
+/* portable and safe solution. Generally efficient.
+ * see : http://stackoverflow.com/a/32095106/646947
+ */
+
+static U64 XXH_read64(const void* memPtr)
+{
+    U64 val;
+    memcpy(&val, memPtr, sizeof(val));
+    return val;
+}
+
+#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */
+
+#if defined(_MSC_VER)     /* Visual Studio */
+#  define XXH_swap64 _byteswap_uint64
+#elif XXH_GCC_VERSION >= 403
+#  define XXH_swap64 __builtin_bswap64
+#else
+static U64 XXH_swap64 (U64 x)
+{
+    return  ((x << 56) & 0xff00000000000000ULL) |
+            ((x << 40) & 0x00ff000000000000ULL) |
+            ((x << 24) & 0x0000ff0000000000ULL) |
+            ((x << 8)  & 0x000000ff00000000ULL) |
+            ((x >> 8)  & 0x00000000ff000000ULL) |
+            ((x >> 24) & 0x0000000000ff0000ULL) |
+            ((x >> 40) & 0x000000000000ff00ULL) |
+            ((x >> 56) & 0x00000000000000ffULL);
+}
+#endif
+
+FORCE_INLINE U64 XXH_readLE64_align(const void* ptr, XXH_endianness endian, XXH_alignment align)
+{
+    if (align==XXH_unaligned)
+        return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));
+    else
+        return endian==XXH_littleEndian ? *(const U64*)ptr : XXH_swap64(*(const U64*)ptr);
+}
+
+FORCE_INLINE U64 XXH_readLE64(const void* ptr, XXH_endianness endian)
+{
+    return XXH_readLE64_align(ptr, endian, XXH_unaligned);
+}
+
+static U64 XXH_readBE64(const void* ptr)
+{
+    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr);
+}
+
+
+/*======   xxh64   ======*/
+
+static const U64 PRIME64_1 = 11400714785074694791ULL;
+static const U64 PRIME64_2 = 14029467366897019727ULL;
+static const U64 PRIME64_3 =  1609587929392839161ULL;
+static const U64 PRIME64_4 =  9650029242287828579ULL;
+static const U64 PRIME64_5 =  2870177450012600261ULL;
+
+static U64 XXH64_round(U64 acc, U64 input)
+{
+    acc += input * PRIME64_2;
+    acc  = XXH_rotl64(acc, 31);
+    acc *= PRIME64_1;
+    return acc;
+}
+
+static U64 XXH64_mergeRound(U64 acc, U64 val)
+{
+    val  = XXH64_round(0, val);
+    acc ^= val;
+    acc  = acc * PRIME64_1 + PRIME64_4;
+    return acc;
+}
+
+static U64 XXH64_avalanche(U64 h64)
+{
+    h64 ^= h64 >> 33;
+    h64 *= PRIME64_2;
+    h64 ^= h64 >> 29;
+    h64 *= PRIME64_3;
+    h64 ^= h64 >> 32;
+    return h64;
+}
+
+
+#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align)
+
+static U64
+XXH64_finalize(U64 h64, const void* ptr, size_t len,
+               XXH_endianness endian, XXH_alignment align)
+{
+    const BYTE* p = (const BYTE*)ptr;
+
+#define PROCESS1_64            \
+    h64 ^= (*p++) * PRIME64_5; \
+    h64 = XXH_rotl64(h64, 11) * PRIME64_1;
+
+#define PROCESS4_64          \
+    h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1; \
+    p+=4;                    \
+    h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
+
+#define PROCESS8_64 {        \
+    U64 const k1 = XXH64_round(0, XXH_get64bits(p)); \
+    p+=8;                    \
+    h64 ^= k1;               \
+    h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; \
+}
+
+    switch(len&31) {
+      case 24: PROCESS8_64;
+                    /* fallthrough */
+      case 16: PROCESS8_64;
+                    /* fallthrough */
+      case  8: PROCESS8_64;
+               return XXH64_avalanche(h64);
+
+      case 28: PROCESS8_64;
+                    /* fallthrough */
+      case 20: PROCESS8_64;
+                    /* fallthrough */
+      case 12: PROCESS8_64;
+                    /* fallthrough */
+      case  4: PROCESS4_64;
+               return XXH64_avalanche(h64);
+
+      case 25: PROCESS8_64;
+                    /* fallthrough */
+      case 17: PROCESS8_64;
+                    /* fallthrough */
+      case  9: PROCESS8_64;
+               PROCESS1_64;
+               return XXH64_avalanche(h64);
+
+      case 29: PROCESS8_64;
+                    /* fallthrough */
+      case 21: PROCESS8_64;
+                    /* fallthrough */
+      case 13: PROCESS8_64;
+                    /* fallthrough */
+      case  5: PROCESS4_64;
+               PROCESS1_64;
+               return XXH64_avalanche(h64);
+
+      case 26: PROCESS8_64;
+                    /* fallthrough */
+      case 18: PROCESS8_64;
+                    /* fallthrough */
+      case 10: PROCESS8_64;
+               PROCESS1_64;
+               PROCESS1_64;
+               return XXH64_avalanche(h64);
+
+      case 30: PROCESS8_64;
+                    /* fallthrough */
+      case 22: PROCESS8_64;
+                    /* fallthrough */
+      case 14: PROCESS8_64;
+                    /* fallthrough */
+      case  6: PROCESS4_64;
+               PROCESS1_64;
+               PROCESS1_64;
+               return XXH64_avalanche(h64);
+
+      case 27: PROCESS8_64;
+                    /* fallthrough */
+      case 19: PROCESS8_64;
+                    /* fallthrough */
+      case 11: PROCESS8_64;
+               PROCESS1_64;
+               PROCESS1_64;
+               PROCESS1_64;
+               return XXH64_avalanche(h64);
+
+      case 31: PROCESS8_64;
+                    /* fallthrough */
+      case 23: PROCESS8_64;
+                    /* fallthrough */
+      case 15: PROCESS8_64;
+                    /* fallthrough */
+      case  7: PROCESS4_64;
+                    /* fallthrough */
+      case  3: PROCESS1_64;
+                    /* fallthrough */
+      case  2: PROCESS1_64;
+                    /* fallthrough */
+      case  1: PROCESS1_64;
+                    /* fallthrough */
+      case  0: return XXH64_avalanche(h64);
+    }
+
+    /* impossible to reach */
+    assert(0);
+    return 0;  /* unreachable, but some compilers complain without it */
+}
+
+FORCE_INLINE U64
+XXH64_endian_align(const void* input, size_t len, U64 seed,
+                XXH_endianness endian, XXH_alignment align)
+{
+    const BYTE* p = (const BYTE*)input;
+    const BYTE* bEnd = p + len;
+    U64 h64;
+
+#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
+    if (p==NULL) {
+        len=0;
+        bEnd=p=(const BYTE*)(size_t)32;
+    }
+#endif
+
+    if (len>=32) {
+        const BYTE* const limit = bEnd - 32;
+        U64 v1 = seed + PRIME64_1 + PRIME64_2;
+        U64 v2 = seed + PRIME64_2;
+        U64 v3 = seed + 0;
+        U64 v4 = seed - PRIME64_1;
+
+        do {
+            v1 = XXH64_round(v1, XXH_get64bits(p)); p+=8;
+            v2 = XXH64_round(v2, XXH_get64bits(p)); p+=8;
+            v3 = XXH64_round(v3, XXH_get64bits(p)); p+=8;
+            v4 = XXH64_round(v4, XXH_get64bits(p)); p+=8;
+        } while (p<=limit);
+
+        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
+        h64 = XXH64_mergeRound(h64, v1);
+        h64 = XXH64_mergeRound(h64, v2);
+        h64 = XXH64_mergeRound(h64, v3);
+        h64 = XXH64_mergeRound(h64, v4);
+
+    } else {
+        h64  = seed + PRIME64_5;
+    }
+
+    h64 += (U64) len;
+
+    return XXH64_finalize(h64, p, len, endian, align);
+}
+
+
+XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed)
+{
+#if 0
+    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
+    XXH64_state_t state;
+    XXH64_reset(&state, seed);
+    XXH64_update(&state, input, len);
+    return XXH64_digest(&state);
+#else
+    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
+
+    if (XXH_FORCE_ALIGN_CHECK) {
+        if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */
+            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+                return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
+            else
+                return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
+    }   }
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
+    else
+        return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
+#endif
+}
+
+/*======   Hash Streaming   ======*/
+
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)
+{
+    return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));
+}
+XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)
+{
+    XXH_free(statePtr);
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dstState, const XXH64_state_t* srcState)
+{
+    memcpy(dstState, srcState, sizeof(*dstState));
+}
+
+XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed)
+{
+    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
+    memset(&state, 0, sizeof(state));
+    state.v1 = seed + PRIME64_1 + PRIME64_2;
+    state.v2 = seed + PRIME64_2;
+    state.v3 = seed + 0;
+    state.v4 = seed - PRIME64_1;
+     /* do not write into reserved, planned to be removed in a future version */
+    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
+    return XXH_OK;
+}
+
+FORCE_INLINE XXH_errorcode
+XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianness endian)
+{
+    if (input==NULL)
+#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
+        return XXH_OK;
+#else
+        return XXH_ERROR;
+#endif
+
+    {   const BYTE* p = (const BYTE*)input;
+        const BYTE* const bEnd = p + len;
+
+        state->total_len += len;
+
+        if (state->memsize + len < 32) {  /* fill in tmp buffer */
+            XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len);
+            state->memsize += (U32)len;
+            return XXH_OK;
+        }
+
+        if (state->memsize) {   /* tmp buffer is full */
+            XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize);
+            state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0, endian));
+            state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1, endian));
+            state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2, endian));
+            state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3, endian));
+            p += 32-state->memsize;
+            state->memsize = 0;
+        }
+
+        if (p+32 <= bEnd) {
+            const BYTE* const limit = bEnd - 32;
+            U64 v1 = state->v1;
+            U64 v2 = state->v2;
+            U64 v3 = state->v3;
+            U64 v4 = state->v4;
+
+            do {
+                v1 = XXH64_round(v1, XXH_readLE64(p, endian)); p+=8;
+                v2 = XXH64_round(v2, XXH_readLE64(p, endian)); p+=8;
+                v3 = XXH64_round(v3, XXH_readLE64(p, endian)); p+=8;
+                v4 = XXH64_round(v4, XXH_readLE64(p, endian)); p+=8;
+            } while (p<=limit);
+
+            state->v1 = v1;
+            state->v2 = v2;
+            state->v3 = v3;
+            state->v4 = v4;
+        }
+
+        if (p < bEnd) {
+            XXH_memcpy(state->mem64, p, (size_t)(bEnd-p));
+            state->memsize = (unsigned)(bEnd-p);
+        }
+    }
+
+    return XXH_OK;
+}
+
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len)
+{
+    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH64_update_endian(state_in, input, len, XXH_littleEndian);
+    else
+        return XXH64_update_endian(state_in, input, len, XXH_bigEndian);
+}
+
+FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianness endian)
+{
+    U64 h64;
+
+    if (state->total_len >= 32) {
+        U64 const v1 = state->v1;
+        U64 const v2 = state->v2;
+        U64 const v3 = state->v3;
+        U64 const v4 = state->v4;
+
+        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
+        h64 = XXH64_mergeRound(h64, v1);
+        h64 = XXH64_mergeRound(h64, v2);
+        h64 = XXH64_mergeRound(h64, v3);
+        h64 = XXH64_mergeRound(h64, v4);
+    } else {
+        h64  = state->v3 /*seed*/ + PRIME64_5;
+    }
+
+    h64 += (U64) state->total_len;
+
+    return XXH64_finalize(h64, state->mem64, (size_t)state->total_len, endian, XXH_aligned);
+}
+
+XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in)
+{
+    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
+
+    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
+        return XXH64_digest_endian(state_in, XXH_littleEndian);
+    else
+        return XXH64_digest_endian(state_in, XXH_bigEndian);
+}
+
+
+/*====== Canonical representation   ======*/
+
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash)
+{
+    XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));
+    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);
+    memcpy(dst, &hash, sizeof(*dst));
+}
+
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src)
+{
+    return XXH_readBE64(src);
+}
+
+#endif  /* XXH_NO_LONG_LONG */
diff --git a/native/lz4/vendor/lib/xxhash.h b/native/lz4/vendor/lib/xxhash.h
new file mode 100644
index 0000000..d6bad94
--- /dev/null
+++ b/native/lz4/vendor/lib/xxhash.h
@@ -0,0 +1,328 @@
+/*
+   xxHash - Extremely Fast Hash algorithm
+   Header File
+   Copyright (C) 2012-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - xxHash source repository : https://github.com/Cyan4973/xxHash
+*/
+
+/* Notice extracted from xxHash homepage :
+
+xxHash is an extremely fast Hash algorithm, running at RAM speed limits.
+It also successfully passes all tests from the SMHasher suite.
+
+Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)
+
+Name            Speed       Q.Score   Author
+xxHash          5.4 GB/s     10
+CrapWow         3.2 GB/s      2       Andrew
+MumurHash 3a    2.7 GB/s     10       Austin Appleby
+SpookyHash      2.0 GB/s     10       Bob Jenkins
+SBox            1.4 GB/s      9       Bret Mulvey
+Lookup3         1.2 GB/s      9       Bob Jenkins
+SuperFastHash   1.2 GB/s      1       Paul Hsieh
+CityHash64      1.05 GB/s    10       Pike & Alakuijala
+FNV             0.55 GB/s     5       Fowler, Noll, Vo
+CRC32           0.43 GB/s     9
+MD5-32          0.33 GB/s    10       Ronald L. Rivest
+SHA1-32         0.28 GB/s    10
+
+Q.Score is a measure of quality of the hash function.
+It depends on successfully passing SMHasher test set.
+10 is a perfect score.
+
+A 64-bit version, named XXH64, is available since r35.
+It offers much better speed, but for 64-bit applications only.
+Name     Speed on 64 bits    Speed on 32 bits
+XXH64       13.8 GB/s            1.9 GB/s
+XXH32        6.8 GB/s            6.0 GB/s
+*/
+
+#ifndef XXHASH_H_5627135585666179
+#define XXHASH_H_5627135585666179 1
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/* ****************************
+*  Definitions
+******************************/
+#include <stddef.h>   /* size_t */
+typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
+
+
+/* ****************************
+ *  API modifier
+ ******************************/
+/** XXH_INLINE_ALL (and XXH_PRIVATE_API)
+ *  This is useful to include xxhash functions in `static` mode
+ *  in order to inline them, and remove their symbol from the public list.
+ *  Inlining can offer dramatic performance improvement on small keys.
+ *  Methodology :
+ *     #define XXH_INLINE_ALL
+ *     #include "xxhash.h"
+ * `xxhash.c` is automatically included.
+ *  It's not useful to compile and link it as a separate module.
+ */
+#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
+#  ifndef XXH_STATIC_LINKING_ONLY
+#    define XXH_STATIC_LINKING_ONLY
+#  endif
+#  if defined(__GNUC__)
+#    define XXH_PUBLIC_API static __inline __attribute__((unused))
+#  elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#    define XXH_PUBLIC_API static inline
+#  elif defined(_MSC_VER)
+#    define XXH_PUBLIC_API static __inline
+#  else
+     /* this version may generate warnings for unused static functions */
+#    define XXH_PUBLIC_API static
+#  endif
+#else
+#  define XXH_PUBLIC_API   /* do nothing */
+#endif /* XXH_INLINE_ALL || XXH_PRIVATE_API */
+
+/*! XXH_NAMESPACE, aka Namespace Emulation :
+ *
+ * If you want to include _and expose_ xxHash functions from within your own library,
+ * but also want to avoid symbol collisions with other libraries which may also include xxHash,
+ *
+ * you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library
+ * with the value of XXH_NAMESPACE (therefore, avoid NULL and numeric values).
+ *
+ * Note that no change is required within the calling program as long as it includes `xxhash.h` :
+ * regular symbol name will be automatically translated by this header.
+ */
+#ifdef XXH_NAMESPACE
+#  define XXH_CAT(A,B) A##B
+#  define XXH_NAME2(A,B) XXH_CAT(A,B)
+#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)
+#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)
+#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)
+#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)
+#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)
+#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)
+#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)
+#  define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)
+#  define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)
+#  define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)
+#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)
+#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)
+#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)
+#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)
+#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)
+#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)
+#  define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)
+#  define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)
+#  define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)
+#endif
+
+
+/* *************************************
+*  Version
+***************************************/
+#define XXH_VERSION_MAJOR    0
+#define XXH_VERSION_MINOR    6
+#define XXH_VERSION_RELEASE  5
+#define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
+XXH_PUBLIC_API unsigned XXH_versionNumber (void);
+
+
+/*-**********************************************************************
+*  32-bit hash
+************************************************************************/
+typedef unsigned int XXH32_hash_t;
+
+/*! XXH32() :
+    Calculate the 32-bit hash of sequence "length" bytes stored at memory address "input".
+    The memory between input & input+length must be valid (allocated and read-accessible).
+    "seed" can be used to alter the result predictably.
+    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s */
+XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed);
+
+/*======   Streaming   ======*/
+typedef struct XXH32_state_s XXH32_state_t;   /* incomplete type */
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
+XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dst_state, const XXH32_state_t* src_state);
+
+XXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, unsigned int seed);
+XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr);
+
+/*
+ * Streaming functions generate the xxHash of an input provided in multiple segments.
+ * Note that, for small input, they are slower than single-call functions, due to state management.
+ * For small inputs, prefer `XXH32()` and `XXH64()`, which are better optimized.
+ *
+ * XXH state must first be allocated, using XXH*_createState() .
+ *
+ * Start a new hash by initializing state with a seed, using XXH*_reset().
+ *
+ * Then, feed the hash state by calling XXH*_update() as many times as necessary.
+ * The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
+ *
+ * Finally, a hash value can be produced anytime, by using XXH*_digest().
+ * This function returns the nn-bits hash as an int or long long.
+ *
+ * It's still possible to continue inserting input into the hash state after a digest,
+ * and generate some new hashes later on, by calling again XXH*_digest().
+ *
+ * When done, free XXH state space if it was allocated dynamically.
+ */
+
+/*======   Canonical representation   ======*/
+
+typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
+
+/* Default result type for XXH functions are primitive unsigned 32 and 64 bits.
+ * The canonical representation uses human-readable write convention, aka big-endian (large digits first).
+ * These functions allow transformation of hash result into and from its canonical format.
+ * This way, hash values can be written into a file / memory, and remain comparable on different systems and programs.
+ */
+
+
+#ifndef XXH_NO_LONG_LONG
+/*-**********************************************************************
+*  64-bit hash
+************************************************************************/
+typedef unsigned long long XXH64_hash_t;
+
+/*! XXH64() :
+    Calculate the 64-bit hash of sequence of length "len" stored at memory address "input".
+    "seed" can be used to alter the result predictably.
+    This function runs faster on 64-bit systems, but slower on 32-bit systems (see benchmark).
+*/
+XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed);
+
+/*======   Streaming   ======*/
+typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
+XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state);
+
+XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, unsigned long long seed);
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr);
+
+/*======   Canonical representation   ======*/
+typedef struct { unsigned char digest[8]; } XXH64_canonical_t;
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
+#endif  /* XXH_NO_LONG_LONG */
+
+
+
+#ifdef XXH_STATIC_LINKING_ONLY
+
+/* ================================================================================================
+   This section contains declarations which are not guaranteed to remain stable.
+   They may change in future versions, becoming incompatible with a different version of the library.
+   These declarations should only be used with static linking.
+   Never use them in association with dynamic linking !
+=================================================================================================== */
+
+/* These definitions are only present to allow
+ * static allocation of XXH state, on stack or in a struct for example.
+ * Never **ever** use members directly. */
+
+#if !defined (__VMS) \
+  && (defined (__cplusplus) \
+  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+#   include <stdint.h>
+
+struct XXH32_state_s {
+   uint32_t total_len_32;
+   uint32_t large_len;
+   uint32_t v1;
+   uint32_t v2;
+   uint32_t v3;
+   uint32_t v4;
+   uint32_t mem32[4];
+   uint32_t memsize;
+   uint32_t reserved;   /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH32_state_t */
+
+struct XXH64_state_s {
+   uint64_t total_len;
+   uint64_t v1;
+   uint64_t v2;
+   uint64_t v3;
+   uint64_t v4;
+   uint64_t mem64[4];
+   uint32_t memsize;
+   uint32_t reserved[2];          /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH64_state_t */
+
+# else
+
+struct XXH32_state_s {
+   unsigned total_len_32;
+   unsigned large_len;
+   unsigned v1;
+   unsigned v2;
+   unsigned v3;
+   unsigned v4;
+   unsigned mem32[4];
+   unsigned memsize;
+   unsigned reserved;   /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH32_state_t */
+
+#   ifndef XXH_NO_LONG_LONG  /* remove 64-bit support */
+struct XXH64_state_s {
+   unsigned long long total_len;
+   unsigned long long v1;
+   unsigned long long v2;
+   unsigned long long v3;
+   unsigned long long v4;
+   unsigned long long mem64[4];
+   unsigned memsize;
+   unsigned reserved[2];     /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH64_state_t */
+#    endif
+
+# endif
+
+
+#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
+#  include "xxhash.c"   /* include xxhash function bodies as `static`, for inlining */
+#endif
+
+#endif /* XXH_STATIC_LINKING_ONLY */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* XXHASH_H_5627135585666179 */
diff --git a/src/lib.rs b/src/lib.rs
index 66c69b5..f5cc521 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,6 +3,7 @@
 mod chromeos_update_engine {
     include!(concat!(env!("OUT_DIR"), "/chromeos_update_engine.rs"));
 }
+pub mod lz4;
 mod payload;
 mod puffin;
 #[cfg(feature = "python")]
diff --git a/src/lz4.rs b/src/lz4.rs
new file mode 100644
index 0000000..b4335d5
--- /dev/null
+++ b/src/lz4.rs
@@ -0,0 +1,487 @@
+use std::error;
+use std::fmt;
+
+const MAX_INPUT_SIZE: usize = 0x7e00_0000;
+pub const HC_LEVEL_MIN: i32 = 2;
+pub const HC_LEVEL_MAX: i32 = 12;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Status {
+    InvalidArgument,
+    CompressionFailed,
+    DecompressionFailed,
+    AllocationFailure,
+    CompressionDivergence,
+    UnsupportedTarget,
+    Unknown(i32),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Error {
+    status: Status,
+    message: String,
+}
+
+impl Error {
+    pub fn status(&self) -> Status {
+        self.status
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str(&self.message)
+    }
+}
+
+impl error::Error for Error {}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Decompresses one LZ4 block into a newly allocated, exact-size buffer.
+pub fn decompress_safe_partial(input: &[u8], output_size: usize) -> Result<Vec<u8>> {
+    ensure_supported()?;
+    validate_sizes(input.len(), output_size)?;
+    if input.len() >= output_size {
+        return Err(invalid_argument("stored LZ4 block must be smaller than its raw block"));
+    }
+    let mut output = allocate_output(output_size, "decompression")?;
+    let result = decompress_native(input, &mut output)?;
+    if result.output_size != output_size {
+        return Err(Error {
+            status: Status::DecompressionFailed,
+            message: format!(
+                "LZ4 decompressed {} bytes, expected {output_size}",
+                result.output_size
+            ),
+        });
+    }
+    Ok(output)
+}
+
+/// Compresses one complete block with LZ4 acceleration 1.
+///
+/// The returned buffer always has `output_size` bytes. Short compressed output
+/// receives leading zeros when `zero_padding` is true and trailing zeros otherwise.
+pub fn compress_dest_size(input: &[u8], output_size: usize, zero_padding: bool) -> Result<Vec<u8>> {
+    compress(input, output_size, zero_padding, None)
+}
+
+/// Compresses one complete block with the metadata-selected LZ4HC level.
+pub fn compress_hc_dest_size(
+    input: &[u8],
+    output_size: usize,
+    compression_level: i32,
+    zero_padding: bool,
+) -> Result<Vec<u8>> {
+    if !(HC_LEVEL_MIN..=HC_LEVEL_MAX).contains(&compression_level) {
+        return Err(invalid_argument(format!(
+            "LZ4HC compression level must be in {HC_LEVEL_MIN}..={HC_LEVEL_MAX}"
+        )));
+    }
+    compress(input, output_size, zero_padding, Some(compression_level))
+}
+
+fn compress(
+    input: &[u8],
+    output_size: usize,
+    zero_padding: bool,
+    compression_level: Option<i32>,
+) -> Result<Vec<u8>> {
+    ensure_supported()?;
+    validate_sizes(input.len(), output_size)?;
+    if output_size >= input.len() {
+        return Err(invalid_argument("stored LZ4 block must be smaller than its raw block"));
+    }
+    let mut output = allocate_output(output_size, "compression")?;
+    let result = compress_native(input, &mut output, compression_level)?;
+    if result.source_size != input.len() {
+        return Err(Error {
+            status: Status::CompressionDivergence,
+            message: format!(
+                "LZ4 compression consumed {} of {} source bytes",
+                result.source_size,
+                input.len()
+            ),
+        });
+    }
+    if result.output_size == 0 || result.output_size > output_size {
+        return Err(Error {
+            status: Status::CompressionDivergence,
+            message: format!(
+                "LZ4 compression produced {} bytes for capacity {output_size}",
+                result.output_size
+            ),
+        });
+    }
+
+    let padding = output_size - result.output_size;
+    if padding > 0 {
+        if zero_padding {
+            output.copy_within(0..result.output_size, padding);
+            output[..padding].fill(0);
+        } else {
+            output[result.output_size..].fill(0);
+        }
+    }
+    Ok(output)
+}
+
+fn validate_sizes(input_size: usize, output_size: usize) -> Result<()> {
+    if input_size == 0 || output_size == 0 {
+        return Err(invalid_argument("LZ4 block sizes must be greater than zero"));
+    }
+    if input_size > MAX_INPUT_SIZE || output_size > MAX_INPUT_SIZE {
+        return Err(invalid_argument("LZ4 block exceeds LZ4_MAX_INPUT_SIZE"));
+    }
+    i32::try_from(input_size).map_err(|_| invalid_argument("LZ4 input size exceeds int"))?;
+    i32::try_from(output_size).map_err(|_| invalid_argument("LZ4 output size exceeds int"))?;
+    Ok(())
+}
+
+fn allocate_output(size: usize, operation: &str) -> Result<Vec<u8>> {
+    let mut output = Vec::new();
+    output.try_reserve_exact(size).map_err(|error| Error {
+        status: Status::AllocationFailure,
+        message: format!("unable to allocate LZ4 {operation} output: {error}"),
+    })?;
+    output.resize(size, 0);
+    Ok(output)
+}
+
+fn invalid_argument(message: impl Into<String>) -> Error {
+    Error { status: Status::InvalidArgument, message: message.into() }
+}
+
+#[derive(Clone, Copy)]
+struct NativeResult {
+    source_size: usize,
+    output_size: usize,
+}
+
+#[cfg(otadump_lz4)]
+fn decompress_native(input: &[u8], output: &mut [u8]) -> Result<NativeResult> {
+    native_call(input, output, None, true)
+}
+
+#[cfg(not(otadump_lz4))]
+fn decompress_native(_input: &[u8], _output: &mut [u8]) -> Result<NativeResult> {
+    Err(unsupported_target())
+}
+
+#[cfg(otadump_lz4)]
+fn compress_native(
+    input: &[u8],
+    output: &mut [u8],
+    compression_level: Option<i32>,
+) -> Result<NativeResult> {
+    native_call(input, output, compression_level, false)
+}
+
+#[cfg(not(otadump_lz4))]
+fn compress_native(
+    _input: &[u8],
+    _output: &mut [u8],
+    _compression_level: Option<i32>,
+) -> Result<NativeResult> {
+    Err(unsupported_target())
+}
+
+#[cfg(not(otadump_lz4))]
+fn ensure_supported() -> Result<()> {
+    Err(unsupported_target())
+}
+
+#[cfg(otadump_lz4)]
+fn ensure_supported() -> Result<()> {
+    Ok(())
+}
+
+#[allow(dead_code)]
+fn unsupported_target() -> Error {
+    Error {
+        status: Status::UnsupportedTarget,
+        message: "LZ4 block operations are supported only on Linux x86_64 GNU hosts".into(),
+    }
+}
+
+#[cfg(otadump_lz4)]
+fn native_call(
+    input: &[u8],
+    output: &mut [u8],
+    compression_level: Option<i32>,
+    decompress: bool,
+) -> Result<NativeResult> {
+    use std::ffi::c_int;
+
+    #[repr(C)]
+    struct FfiResult {
+        status: c_int,
+        source_size: c_int,
+        output_size: c_int,
+    }
+
+    unsafe extern "C" {
+        fn otadump_lz4_decompress_safe_partial(
+            source: *const u8,
+            source_size: c_int,
+            output: *mut u8,
+            output_capacity: c_int,
+            target_output_size: c_int,
+        ) -> FfiResult;
+        fn otadump_lz4_compress_dest_size(
+            source: *const u8,
+            source_size: c_int,
+            output: *mut u8,
+            output_capacity: c_int,
+        ) -> FfiResult;
+        fn otadump_lz4_compress_hc_dest_size(
+            source: *const u8,
+            source_size: c_int,
+            output: *mut u8,
+            output_capacity: c_int,
+            compression_level: c_int,
+        ) -> FfiResult;
+    }
+
+    let source_size =
+        i32::try_from(input.len()).map_err(|_| invalid_argument("LZ4 input size exceeds int"))?;
+    let output_size =
+        i32::try_from(output.len()).map_err(|_| invalid_argument("LZ4 output size exceeds int"))?;
+    // SAFETY: The immutable input and mutable output slices cannot alias. They
+    // remain alive for the call, and their checked lengths match the pointers.
+    let result = unsafe {
+        if decompress {
+            otadump_lz4_decompress_safe_partial(
+                input.as_ptr(),
+                source_size,
+                output.as_mut_ptr(),
+                output_size,
+                output_size,
+            )
+        } else if let Some(level) = compression_level {
+            otadump_lz4_compress_hc_dest_size(
+                input.as_ptr(),
+                source_size,
+                output.as_mut_ptr(),
+                output_size,
+                level,
+            )
+        } else {
+            otadump_lz4_compress_dest_size(
+                input.as_ptr(),
+                source_size,
+                output.as_mut_ptr(),
+                output_size,
+            )
+        }
+    };
+    if result.status != 0 {
+        return Err(Error {
+            status: native_status(result.status),
+            message: native_message(result.status).into(),
+        });
+    }
+    Ok(NativeResult {
+        source_size: usize::try_from(result.source_size)
+            .map_err(|_| invalid_argument("native LZ4 returned a negative source size"))?,
+        output_size: usize::try_from(result.output_size)
+            .map_err(|_| invalid_argument("native LZ4 returned a negative output size"))?,
+    })
+}
+
+#[cfg(otadump_lz4)]
+fn native_status(status: i32) -> Status {
+    match status {
+        1 => Status::InvalidArgument,
+        2 => Status::CompressionFailed,
+        3 => Status::DecompressionFailed,
+        4 => Status::AllocationFailure,
+        status => Status::Unknown(status),
+    }
+}
+
+#[cfg(otadump_lz4)]
+fn native_message(status: i32) -> &'static str {
+    match status {
+        1 => "native LZ4 rejected an argument",
+        2 => "native LZ4 compression failed",
+        3 => "native LZ4 decompression failed",
+        4 => "native LZ4 allocation failed",
+        _ => "native LZ4 failed with an unknown status",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn matches_frozen_lz4_reference() {
+        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
+        let expected = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.lz4");
+
+        let compressed = compress_dest_size(raw, expected.len(), false).unwrap();
+        assert_eq!(compressed, expected);
+        assert_eq!(decompress_safe_partial(expected, raw.len()).unwrap(), raw);
+    }
+
+    #[test]
+    fn matches_frozen_lz4hc9_reference() {
+        let raw = include_bytes!("../tests/fixtures/lz4/lz4hc9-no-postfix.raw");
+        let expected = include_bytes!("../tests/fixtures/lz4/lz4hc9-no-postfix.lz4");
+
+        let compressed = compress_hc_dest_size(raw, expected.len(), 9, false).unwrap();
+        assert_eq!(compressed, expected);
+        assert_eq!(decompress_safe_partial(expected, raw.len()).unwrap(), raw);
+    }
+
+    #[test]
+    fn matches_frozen_zero_padding_layout() {
+        let raw = include_bytes!("../tests/fixtures/lz4/zero-padding-layout.raw");
+        let expected = include_bytes!("../tests/fixtures/lz4/zero-padding-layout.lz4");
+        let (raw_block, compressed_raw) = raw.split_at(32);
+        let (expected_raw, expected_compressed) = expected.split_at(32);
+
+        assert_eq!(raw_block, expected_raw);
+        let compressed =
+            compress_dest_size(compressed_raw, expected_compressed.len(), true).unwrap();
+        assert_eq!(compressed, expected_compressed);
+
+        let first_byte = compressed.iter().position(|byte| *byte != 0).unwrap();
+        assert_eq!(
+            decompress_safe_partial(&compressed[first_byte..], compressed_raw.len()).unwrap(),
+            compressed_raw
+        );
+    }
+
+    #[test]
+    fn round_trip_synthetic_data() {
+        let mut raw = Vec::with_capacity(2048);
+        for i in 0..2048 {
+            raw.push((i % 37) as u8);
+        }
+        let output_size = 512;
+        let compressed = compress_dest_size(&raw, output_size, false).unwrap();
+        assert_eq!(compressed.len(), output_size);
+        let decompressed = decompress_safe_partial(&compressed, raw.len()).unwrap();
+        assert_eq!(decompressed, raw);
+    }
+
+    #[test]
+    fn round_trip_hc_levels() {
+        let mut raw = Vec::with_capacity(2048);
+        for i in 0..2048 {
+            raw.push((i % 37) as u8);
+        }
+        let output_size = 512;
+        for level in [HC_LEVEL_MIN, 6, 9, HC_LEVEL_MAX] {
+            let compressed = compress_hc_dest_size(&raw, output_size, level, false).unwrap();
+            assert_eq!(compressed.len(), output_size);
+            let decompressed = decompress_safe_partial(&compressed, raw.len()).unwrap();
+            assert_eq!(decompressed, raw);
+        }
+    }
+
+    #[test]
+    fn rejects_invalid_compression_levels() {
+        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
+        assert_eq!(
+            compress_hc_dest_size(raw, 512, HC_LEVEL_MIN - 1, false).unwrap_err().status(),
+            Status::InvalidArgument
+        );
+        assert_eq!(
+            compress_hc_dest_size(raw, 512, HC_LEVEL_MAX + 1, false).unwrap_err().status(),
+            Status::InvalidArgument
+        );
+    }
+
+    #[test]
+    fn rejects_zero_or_oversized_inputs() {
+        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
+        let expected = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.lz4");
+
+        assert_eq!(
+            compress_dest_size(&[], 512, false).unwrap_err().status(),
+            Status::InvalidArgument
+        );
+        assert_eq!(
+            compress_dest_size(raw, 0, false).unwrap_err().status(),
+            Status::InvalidArgument
+        );
+        assert_eq!(
+            compress_dest_size(raw, MAX_INPUT_SIZE + 1, false).unwrap_err().status(),
+            Status::InvalidArgument
+        );
+        assert_eq!(
+            decompress_safe_partial(&[], 512).unwrap_err().status(),
+            Status::InvalidArgument
+        );
+        assert_eq!(
+            decompress_safe_partial(expected, 0).unwrap_err().status(),
+            Status::InvalidArgument
+        );
+        assert_eq!(
+            decompress_safe_partial(expected, MAX_INPUT_SIZE + 1).unwrap_err().status(),
+            Status::InvalidArgument
+        );
+    }
+
+    #[test]
+    fn rejects_stored_not_smaller_than_raw() {
+        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
+        assert_eq!(
+            compress_dest_size(raw, raw.len(), false).unwrap_err().status(),
+            Status::InvalidArgument
+        );
+        assert_eq!(
+            compress_dest_size(raw, raw.len() + 10, false).unwrap_err().status(),
+            Status::InvalidArgument
+        );
+        assert_eq!(
+            decompress_safe_partial(raw, raw.len() / 2).unwrap_err().status(),
+            Status::InvalidArgument
+        );
+    }
+
+    #[test]
+    fn fails_on_corrupted_decompression_input() {
+        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
+        let expected = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.lz4");
+        let mut corrupted = expected.to_vec();
+        corrupted[0] = 0xff;
+        corrupted[1] = 0xff;
+        assert_eq!(
+            decompress_safe_partial(&corrupted, raw.len()).unwrap_err().status(),
+            Status::DecompressionFailed
+        );
+    }
+
+    #[test]
+    fn fails_on_decompression_size_mismatch() {
+        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
+        let expected = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.lz4");
+        let compressed_end = expected.iter().rposition(|byte| *byte != 0).map_or(0, |i| i + 1);
+        assert_eq!(
+            decompress_safe_partial(&expected[..compressed_end], raw.len() + 256)
+                .unwrap_err()
+                .status(),
+            Status::DecompressionFailed
+        );
+    }
+
+    #[test]
+    fn fails_when_output_budget_too_small() {
+        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
+        let error = compress_dest_size(raw, 16, false).unwrap_err();
+        assert!(
+            error.status() == Status::CompressionDivergence
+                || error.status() == Status::CompressionFailed
+        );
+    }
+
+    #[test]
+    fn unsupported_target_status() {
+        assert_eq!(unsupported_target().status(), Status::UnsupportedTarget);
+    }
+}
diff --git a/tests/fixtures/lz4/LICENSE b/tests/fixtures/lz4/LICENSE
new file mode 100644
index 0000000..a1221be
--- /dev/null
+++ b/tests/fixtures/lz4/LICENSE
@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, Milestone 6a proof contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/tests/fixtures/lz4/README.md b/tests/fixtures/lz4/README.md
new file mode 100644
index 0000000..5e8ba8b
--- /dev/null
+++ b/tests/fixtures/lz4/README.md
@@ -0,0 +1,14 @@
+# Frozen Milestone 6a fixtures
+
+These files contain only the raw and expected block bytes needed by the Milestone 6b1 Rust boundary tests.
+They were extracted without transformation from the frozen Milestone 6a fixtures produced under the BSD-2-Clause license in `LICENSE`.
+
+The source proof pins AOSP `platform/external/lz4` commit `734e07032602e9a72fcc9701028b0aee45147fcd` and AOSP `platform/system/update_engine` commit `dc84c2552b2d4cf00d2a843cb1c091d99d0499f1`.
+
+| Case | Raw bytes | Stored bytes | Algorithm | Level | Layout |
+| --- | ---: | ---: | --- | ---: | --- |
+| `lz4-no-postfix` | 1024 | 768 | LZ4 | implicit acceleration 1 | trailing zero padding |
+| `lz4hc9-no-postfix` | 1536 | 1152 | LZ4HC | 9 | trailing zero padding |
+| `zero-padding-layout` | 800 | 608 | LZ4 | implicit acceleration 1 | 32 raw bytes, then 576 stored bytes with leading zero padding |
+
+Run `sha256sum -c SHA256SUMS` from this directory to verify every fixture file.
diff --git a/tests/fixtures/lz4/SHA256SUMS b/tests/fixtures/lz4/SHA256SUMS
new file mode 100644
index 0000000..e432239
--- /dev/null
+++ b/tests/fixtures/lz4/SHA256SUMS
@@ -0,0 +1,7 @@
+4054755099cdd5b41a7957816ba51a24e989dab110f702783743bc080dbf7fbd  LICENSE
+d0f1ef7cd255d13146f34b70060f21a545428534feeb90837aace772c80331dc  lz4-no-postfix.raw
+6ea395fcef53c8e4de2fc708f4c8e1db7de05b53e48a891c77cbebee4e914e65  lz4-no-postfix.lz4
+ae91406138d4876551426d6e267b62e15a297e4f4d06a807a1adfce08440af88  lz4hc9-no-postfix.raw
+12a28b1f3d4cc5f8b0bfa534f062abae2b9bdbcd886fa2d657cf81e10b2e273e  lz4hc9-no-postfix.lz4
+9ec1afaf310fcf60f084bae0daca993d6ff54966a5bae97f4c0bce71db996920  zero-padding-layout.raw
+1e5b41d7f2e7c5d541a65b683be0c357da12241a036509853962e8888e900c87  zero-padding-layout.lz4
diff --git a/tests/fixtures/lz4/lz4-no-postfix.lz4 b/tests/fixtures/lz4/lz4-no-postfix.lz4
new file mode 100644
index 0000000000000000000000000000000000000000..c635da170bdc86177413483ad902b18646ae61cf
GIT binary patch
literal 768
zcmew_k(a7#mZ<9!WulvsT9R6no0*qcT#}iro0eHoQd*R%@0*#ET3nK^&LHuA;=0o>
zSe5K!DyMC}@RrMuL6?6H1H=2i)hC`Z$=gJhP2O<!75f|pDSkf&2L4w-neG)wAN`lH
z3@e_n_SAD0K}J2kQik^(OAp=uBWV^~(7WpR6UKN(X+A#&{<Vw@?^_q`zw=YfI3Txc
z`H_eJt}yEJ0#!H7-*fYuuz_z@`;vqAek(D_@B&r00ae$}*?H}=fUZ}1%ffxPe@tgG
z-~p<xnYr!q2VO1rl*W0xZ+v~qB+CO)&BVamukMmqH+#p`Pf^T<+@%a45f#U{>KR)v
Sy<fpBmjDR?hEXuWLI3~)c5lD{

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4/lz4-no-postfix.raw b/tests/fixtures/lz4/lz4-no-postfix.raw
new file mode 100644
index 0000000..fabd401
--- /dev/null
+++ b/tests/fixtures/lz4/lz4-no-postfix.raw
@@ -0,0 +1,3 @@
+ne-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6‘®Ëè"?\y–³Ðí
+istic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministicŽ«Èå<Yv“°Íêtone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-‹¨Åâÿ9Vs�­Êçnistic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministiˆ¥Âßü6Sp�ªÇä
stone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone…¢¿Üù3PmŠ§Äáþinistic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-determinist‚Ÿ¼Ùö0Mj‡¤ÁÞûestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestonœ¹Öó-Jg„¡¾Ûøministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-determinis|™¶Óð
*Gd�ž»Øõlestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestoy–³Ðí
+'Da~›¸Õòrministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-determiniv“°Íê$A^{˜µÒïilestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-
\ No newline at end of file
diff --git a/tests/fixtures/lz4/lz4hc9-no-postfix.lz4 b/tests/fixtures/lz4/lz4hc9-no-postfix.lz4
new file mode 100644
index 0000000000000000000000000000000000000000..6c24b45279e4b9fbe194b34726148821e3c52d04
GIT binary patch
literal 1152
zcmew_5oMyAl3J2ll$)8CSzMBtteciuQBqozs_&bblUiJopO>m@mZ<Ba&LIAN_l>VY
z`aYR$ix1rWC2r!!pv$k$!0>Lz)ld97o@vbs_TKs~V(7=ff0#k<Kf~5b?|C%ck{jmk
zy8cB_Pxml`{eOl{=ihLuIVaT4+J5CDpSBrTZ2g&+Y|0L?Rnxaze8;Vk3>I5+@)@&&
zZB+S`jptr-s6zCvJocDD)+)SY;=0o>Sd}ut>XsdT@K?$_q_A)GiKk5RsX#F%2Il#J
zdEG0HKKd_H0_FQ<cPu@0|BqxIl<%F<x@iBMpJK&OzDH`){5?0n3Fkxku1WQCc3%4|
t0I~yQo>P3y%x#xH@WRZqkExut`NCT+pm|mS;4ott1*0J_8Uo~m005r}iYEX7

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4/lz4hc9-no-postfix.raw b/tests/fixtures/lz4/lz4hc9-no-postfix.raw
new file mode 100644
index 0000000000000000000000000000000000000000..a6d68dfb8c6a7aff4c4fc42fa3944905fc3806f8
GIT binary patch
literal 1536
zcmazt(M?G$NiE9F%*!k;$xPNw%d99VElSn*&CE$HF3HbJ)iq1h^@$={+3p)(h4g(g
z+ZG?V`%Bz}Qq!=wZO7G5{5qa#%?tM4`YvKflH0JDhQ+5_FTLl{bW3iSyX*QFK|P8C
z1k=(@=ihLuIVaT4+J5CDpEha1i)k8`$Xb8qC7ZHCY}NEF7vFJfP#&ikmaaMZj9I}p
zs(i}EbFVp6NlYOareR5MD~~;9khKagnYixs3sxm6BujKlmmPlaSIRu3uy6H=r%dvs
zCUSJsuw)rX`VY+OUUBr%e;I1zEHq0Y>EAEAW9gy$e<VrHr)Z{O$@P%*@14=QX#bs`
zVpJ&{P%VX|e~;9r`Fn1D6DGZ=K{X9aQ3FZ;u1WQCc3%4|K%Mdp#ZpN6cZ#o>x$W`?
eUNTBc6w|O2HIVdgA5%GP^M$uuR4Ss8Ed>C|fLXWz

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4/zero-padding-layout.lz4 b/tests/fixtures/lz4/zero-padding-layout.lz4
new file mode 100644
index 0000000000000000000000000000000000000000..8185bd833dcc04217a9fbcaba60b9fb963e79db8
GIT binary patch
literal 608
zcmXTQ&CJUzF3C*RP0Oq(DJ@FX_sz^nEiTE=OVu??)b(K)1=I_HuM$xvx+$q8sYL`r
zU7g|mQzm(v$g;^B&c0$-ag0-EVB_~=5aCy6V0i!Nzl>#A@r1Rfp0g<0MbBZ70?IJ(
z9|p?Y|08J@T+qAf_!CAs>xfqj>_8b|ehWs1_ji7Z83*KcEkE+`pR`42Jfk#!DTC1a
zo8N>De6!k@9K82i!Zc_tBL`5u5ZI1up9OTi(pwhpyZuAd$X|&`2B==}{pAn5TJ9;0
u^LF3(Dx~jIz{CkuFUa4<$nf;STP}5%#Jbr#u72Xz@!ZG6>BkTNPD=pD31yi8

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4/zero-padding-layout.raw b/tests/fixtures/lz4/zero-padding-layout.raw
new file mode 100644
index 0000000..90c2247
--- /dev/null
+++ b/tests/fixtures/lz4/zero-padding-layout.raw
@@ -0,0 +1,2 @@
+rministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-determå<Yv“°Íê$A^e/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milâÿ9Vs�­Êç!>[deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterßü6Sp�ªÇä
;Xre/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/MiÜù3PmŠ§Äáþ8U-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deteÙö0Mj‡¤ÁÞû5Rure/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/MÖó-Jg„¡¾Ûø2O4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-detÓð
*Gd�ž»Øõ/Lture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Ðí
+'Da~›¸Õò,IZ4-deterministic-fixture/Mi
\ No newline at end of file

From 4b0af5c4ce0441685f8f24430b91aac091b9c84f Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Sat, 12 Sep 2026 08:52:58 +0530
Subject: [PATCH 12/42] lz4diff: Apply delta patch operations

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 README.md                                     |   5 +-
 src/lib.rs                                    |  42 +-
 src/lz4.rs                                    |  32 +-
 src/lz4diff.rs                                | 683 ++++++++++++++++++
 tests/delta_extraction.rs                     | 225 ++++++
 tests/fixtures/lz4diff/LICENSE.lz4            |  25 +
 tests/fixtures/lz4diff/LICENSE.puffin         |  27 +
 tests/fixtures/lz4diff/README.md              |  26 +
 tests/fixtures/lz4diff/SHA256SUMS             |  15 +
 .../fixtures/lz4diff/lz4-bsdiff/patch.lz4diff | Bin 0 -> 181 bytes
 tests/fixtures/lz4diff/lz4-bsdiff/source.bin  | Bin 0 -> 768 bytes
 tests/fixtures/lz4diff/lz4-bsdiff/target.bin  | Bin 0 -> 768 bytes
 .../lz4diff/lz4hc9-bsdiff/patch.lz4diff       | Bin 0 -> 185 bytes
 .../fixtures/lz4diff/lz4hc9-bsdiff/source.bin | Bin 0 -> 1152 bytes
 .../fixtures/lz4diff/lz4hc9-bsdiff/target.bin | Bin 0 -> 1152 bytes
 .../lz4diff/postfix-bsdiff/patch.lz4diff      | Bin 0 -> 366 bytes
 .../lz4diff/postfix-bsdiff/source.bin         | Bin 0 -> 768 bytes
 .../lz4diff/postfix-bsdiff/target.bin         | Bin 0 -> 768 bytes
 .../lz4diff/raw-puffdiff/patch.lz4diff        | Bin 0 -> 304 bytes
 .../fixtures/lz4diff/raw-puffdiff/source.bin  | Bin 0 -> 17 bytes
 .../fixtures/lz4diff/raw-puffdiff/target.bin  | Bin 0 -> 22 bytes
 .../lz4diff/zero-padding-bsdiff/patch.lz4diff | Bin 0 -> 202 bytes
 .../lz4diff/zero-padding-bsdiff/source.bin    | Bin 0 -> 608 bytes
 .../lz4diff/zero-padding-bsdiff/target.bin    | Bin 0 -> 608 bytes
 24 files changed, 1071 insertions(+), 9 deletions(-)
 create mode 100644 src/lz4diff.rs
 create mode 100644 tests/fixtures/lz4diff/LICENSE.lz4
 create mode 100644 tests/fixtures/lz4diff/LICENSE.puffin
 create mode 100644 tests/fixtures/lz4diff/README.md
 create mode 100644 tests/fixtures/lz4diff/SHA256SUMS
 create mode 100644 tests/fixtures/lz4diff/lz4-bsdiff/patch.lz4diff
 create mode 100644 tests/fixtures/lz4diff/lz4-bsdiff/source.bin
 create mode 100644 tests/fixtures/lz4diff/lz4-bsdiff/target.bin
 create mode 100644 tests/fixtures/lz4diff/lz4hc9-bsdiff/patch.lz4diff
 create mode 100644 tests/fixtures/lz4diff/lz4hc9-bsdiff/source.bin
 create mode 100644 tests/fixtures/lz4diff/lz4hc9-bsdiff/target.bin
 create mode 100644 tests/fixtures/lz4diff/postfix-bsdiff/patch.lz4diff
 create mode 100644 tests/fixtures/lz4diff/postfix-bsdiff/source.bin
 create mode 100644 tests/fixtures/lz4diff/postfix-bsdiff/target.bin
 create mode 100644 tests/fixtures/lz4diff/raw-puffdiff/patch.lz4diff
 create mode 100644 tests/fixtures/lz4diff/raw-puffdiff/source.bin
 create mode 100644 tests/fixtures/lz4diff/raw-puffdiff/target.bin
 create mode 100644 tests/fixtures/lz4diff/zero-padding-bsdiff/patch.lz4diff
 create mode 100644 tests/fixtures/lz4diff/zero-padding-bsdiff/source.bin
 create mode 100644 tests/fixtures/lz4diff/zero-padding-bsdiff/target.bin

diff --git a/README.md b/README.md
index 90dbc70..03dea2a 100644
--- a/README.md
+++ b/README.md
@@ -82,8 +82,9 @@ otadump ota.zip
 otadump payload.bin
 
 # Apply a SOURCE_COPY, SOURCE_BSDIFF, BROTLI_BSDIFF, PUFFDIFF (inner BSDIFF or
-# ZUCCHINI), or standalone ZUCCHINI delta payload with matching base images.
-# ZUCCHINI requires Linux x86-64 GNU.
+# ZUCCHINI), standalone ZUCCHINI, or LZ4DIFF (inner BSDIFF or PUFFDIFF) delta
+# payload with matching base images.
+# ZUCCHINI and LZ4DIFF require Linux x86-64 GNU.
 otadump delta.zip --output-dir output --source-dir source-images
 ```
 
diff --git a/src/lib.rs b/src/lib.rs
index f5cc521..abcd5e6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,6 +4,7 @@ mod chromeos_update_engine {
     include!(concat!(env!("OUT_DIR"), "/chromeos_update_engine.rs"));
 }
 pub mod lz4;
+mod lz4diff;
 mod payload;
 mod puffin;
 #[cfg(feature = "python")]
@@ -909,6 +910,10 @@ impl Task<'_> {
                 let patch = self.extract_data(op).context("Error extracting PUFFDIFF data")?;
                 self.run_op_puffdiff(op, patch, &mut dst_extents)
             }
+            Type::Lz4diffBsdiff | Type::Lz4diffPuffdiff => {
+                let patch = self.extract_data(op).context("Error extracting LZ4DIFF data")?;
+                self.run_op_lz4diff(op, patch, &mut dst_extents)
+            }
             Type::Zero | Type::Discard => {
                 for extent in dst_extents {
                     for chunk in extent.chunks_mut(VERIFY_CHUNK_SIZE) {
@@ -921,7 +926,6 @@ impl Task<'_> {
             Type::Move | Type::Bsdiff => {
                 bail!("Deprecated operation is not supported: {:?}", Type::try_from(op.r#type)?)
             }
-            op => bail!("Unimplemented operation: {op:?}"),
         }?;
         self.cancellation_token.check()
     }
@@ -1023,6 +1027,33 @@ impl Task<'_> {
         self.write_exact(&output, dst_extents)
     }
 
+    fn run_op_lz4diff(
+        &self,
+        op: &InstallOperation,
+        patch: &[u8],
+        dst_extents: &mut [&mut [u8]],
+    ) -> Result<()> {
+        let source_partition = self.source.as_ref().context("Source partition was not opened")?;
+        let source_ranges = extent_ranges(&op.src_extents, self.block_size, source_partition.len)?;
+        let source_size = ranges_len(&source_ranges)?;
+        let destination_size = dst_extents.iter().try_fold(0usize, |size, extent| {
+            size.checked_add(extent.len()).context("Combined LZ4DIFF destination length overflow")
+        })?;
+        let inner = match Type::try_from(op.r#type).context("Invalid operation")? {
+            Type::Lz4diffBsdiff => lz4diff::InnerPatch::Bsdiff,
+            Type::Lz4diffPuffdiff => lz4diff::InnerPatch::Puffdiff,
+            _ => bail!("Invalid LZ4DIFF operation type"),
+        };
+        let parsed =
+            lz4diff::parse(patch, source_size, destination_size, inner, self.cancellation_token)
+                .map_err(lz4diff_error)?;
+        let source = self.extract_source_data(op)?;
+        let output =
+            lz4diff::apply(&source, parsed, self.cancellation_token).map_err(lz4diff_error)?;
+        self.cancellation_token.check()?;
+        self.write_exact(&output, dst_extents)
+    }
+
     fn write_exact(&self, data: &[u8], dst_extents: &mut [&mut [u8]]) -> Result<()> {
         let dst_len = dst_extents.iter().try_fold(0usize, |len, extent| {
             len.checked_add(extent.len()).context("Combined destination length overflow")
@@ -1111,6 +1142,15 @@ impl Task<'_> {
     }
 }
 
+fn lz4diff_error(error: Error) -> Error {
+    if is_cancellation(error.as_ref()) {
+        error
+    } else {
+        let message = error.to_string();
+        error.context(format!("Error in LZ4DIFF operation: {message}"))
+    }
+}
+
 pub(crate) fn decode_zucchini_patch(
     compressed_patch: &[u8],
     cancellation_token: &CancellationToken,
diff --git a/src/lz4.rs b/src/lz4.rs
index b4335d5..6655ba3 100644
--- a/src/lz4.rs
+++ b/src/lz4.rs
@@ -64,7 +64,7 @@ pub fn decompress_safe_partial(input: &[u8], output_size: usize) -> Result<Vec<u
 /// The returned buffer always has `output_size` bytes. Short compressed output
 /// receives leading zeros when `zero_padding` is true and trailing zeros otherwise.
 pub fn compress_dest_size(input: &[u8], output_size: usize, zero_padding: bool) -> Result<Vec<u8>> {
-    compress(input, output_size, zero_padding, None)
+    compress(input, input.len(), output_size, zero_padding, None)
 }
 
 /// Compresses one complete block with the metadata-selected LZ4HC level.
@@ -79,29 +79,49 @@ pub fn compress_hc_dest_size(
             "LZ4HC compression level must be in {HC_LEVEL_MIN}..={HC_LEVEL_MAX}"
         )));
     }
-    compress(input, output_size, zero_padding, Some(compression_level))
+    compress(input, input.len(), output_size, zero_padding, Some(compression_level))
+}
+
+pub(crate) fn compress_dest_size_partial(
+    input: &[u8],
+    source_size: usize,
+    output_size: usize,
+    compression_level: Option<i32>,
+    zero_padding: bool,
+) -> Result<Vec<u8>> {
+    if let Some(level) = compression_level
+        && !(HC_LEVEL_MIN..=HC_LEVEL_MAX).contains(&level)
+    {
+        return Err(invalid_argument(format!(
+            "LZ4HC compression level must be in {HC_LEVEL_MIN}..={HC_LEVEL_MAX}"
+        )));
+    }
+    compress(input, source_size, output_size, zero_padding, compression_level)
 }
 
 fn compress(
     input: &[u8],
+    source_size: usize,
     output_size: usize,
     zero_padding: bool,
     compression_level: Option<i32>,
 ) -> Result<Vec<u8>> {
     ensure_supported()?;
     validate_sizes(input.len(), output_size)?;
-    if output_size >= input.len() {
+    if source_size == 0 || source_size > input.len() {
+        return Err(invalid_argument("LZ4 source consumption size is invalid"));
+    }
+    if output_size >= source_size {
         return Err(invalid_argument("stored LZ4 block must be smaller than its raw block"));
     }
     let mut output = allocate_output(output_size, "compression")?;
     let result = compress_native(input, &mut output, compression_level)?;
-    if result.source_size != input.len() {
+    if result.source_size != source_size {
         return Err(Error {
             status: Status::CompressionDivergence,
             message: format!(
                 "LZ4 compression consumed {} of {} source bytes",
-                result.source_size,
-                input.len()
+                result.source_size, source_size
             ),
         });
     }
diff --git a/src/lz4diff.rs b/src/lz4diff.rs
new file mode 100644
index 0000000..35eceee
--- /dev/null
+++ b/src/lz4diff.rs
@@ -0,0 +1,683 @@
+// Copyright 2026 otadump contributors
+// SPDX-License-Identifier: MIT
+
+use anyhow::{Context as _, Result, bail, ensure};
+use bsdiff_android::patch_bsdf2;
+use prost::Message as _;
+use ring::digest;
+
+use crate::{CancellationToken, lz4, puffin, validate_bsdiff_output_len, zucchini};
+
+const MAGIC: &[u8; 7] = b"LZ4DIFF";
+const FRAMING_SIZE: usize = 16;
+const VERSION: u32 = 1;
+const EROFS_BLOCK_SIZE: usize = 4096;
+const PROTOBUF_RECURSION_LIMIT: usize = 100;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum InnerPatch {
+    Bsdiff,
+    Puffdiff,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum Algorithm {
+    Uncompressed,
+    Lz4,
+    Lz4hc,
+}
+
+struct Block<'a> {
+    uncompressed_offset: usize,
+    uncompressed_length: usize,
+    compressed_length: usize,
+    sha256_hash: &'a [u8],
+    postfix_bspatch: &'a [u8],
+}
+
+struct CompressionInfo<'a> {
+    algorithm: Algorithm,
+    level: i32,
+    blocks: Vec<Block<'a>>,
+    zero_padding_enabled: bool,
+    uncompressed_size: usize,
+    physical_size: usize,
+}
+
+pub(crate) struct Patch<'a> {
+    source: CompressionInfo<'a>,
+    destination: CompressionInfo<'a>,
+    inner_patch: &'a [u8],
+    inner_type: InnerPatch,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, prost::Message)]
+struct CompressionAlgorithmProto {
+    #[prost(enumeration = "AlgorithmProto", tag = "1")]
+    r#type: i32,
+    #[prost(int32, tag = "2")]
+    level: i32,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, prost::Enumeration)]
+#[repr(i32)]
+enum AlgorithmProto {
+    Uncompressed = 0,
+    Lz4 = 1,
+    Lz4hc = 2,
+}
+
+#[derive(Clone, PartialEq, Eq, prost::Message)]
+struct BlockProto {
+    #[prost(uint64, tag = "1")]
+    uncompressed_offset: u64,
+    #[prost(uint64, tag = "2")]
+    uncompressed_length: u64,
+    #[prost(uint64, tag = "3")]
+    compressed_length: u64,
+}
+
+#[derive(Clone, PartialEq, prost::Message)]
+struct CompressionInfoProto {
+    #[prost(message, optional, tag = "1")]
+    algo: Option<CompressionAlgorithmProto>,
+    #[prost(message, repeated, tag = "2")]
+    block_info: Vec<BlockProto>,
+    #[prost(bool, tag = "3")]
+    zero_padding_enabled: bool,
+}
+
+#[derive(Clone, PartialEq, prost::Message)]
+struct HeaderProto {
+    #[prost(message, optional, tag = "1")]
+    src_info: Option<CompressionInfoProto>,
+    #[prost(message, optional, tag = "2")]
+    dst_info: Option<CompressionInfoProto>,
+    #[prost(enumeration = "InnerPatchProto", tag = "3")]
+    inner_type: i32,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, prost::Enumeration)]
+#[repr(i32)]
+enum InnerPatchProto {
+    Bsdiff = 0,
+    Puffdiff = 1,
+}
+
+struct HeaderLayout<'a> {
+    source_seen: bool,
+    destination_seen: bool,
+    source_blocks: Vec<&'a [u8]>,
+    destination_blocks: Vec<&'a [u8]>,
+}
+
+struct ProtoCursor<'a> {
+    bytes: &'a [u8],
+    position: usize,
+}
+
+impl<'a> ProtoCursor<'a> {
+    fn new(bytes: &'a [u8]) -> Self {
+        Self { bytes, position: 0 }
+    }
+
+    fn at_end(&self) -> bool {
+        self.position == self.bytes.len()
+    }
+
+    fn varint(&mut self) -> Result<u64> {
+        let mut value = 0u64;
+        for index in 0..10 {
+            let byte =
+                *self.bytes.get(self.position).context("truncated LZ4DIFF protobuf varint")?;
+            self.position += 1;
+            if index == 9 && byte > 1 {
+                bail!("LZ4DIFF protobuf varint overflows u64");
+            }
+            value |= u64::from(byte & 0x7f) << (index * 7);
+            if byte & 0x80 == 0 {
+                return Ok(value);
+            }
+        }
+        bail!("LZ4DIFF protobuf varint is too long")
+    }
+
+    fn key(&mut self) -> Result<(u64, u8)> {
+        let key = self.varint()?;
+        ensure!(key >> 3 != 0, "LZ4DIFF protobuf field number is zero");
+        Ok((key >> 3, (key & 7) as u8))
+    }
+
+    fn bytes(&mut self) -> Result<&'a [u8]> {
+        let length = usize::try_from(self.varint()?)
+            .context("LZ4DIFF protobuf field length is too large")?;
+        let end =
+            self.position.checked_add(length).context("LZ4DIFF protobuf field range overflow")?;
+        let bytes =
+            self.bytes.get(self.position..end).context("LZ4DIFF protobuf field overruns header")?;
+        self.position = end;
+        Ok(bytes)
+    }
+
+    fn advance(&mut self, length: usize) -> Result<()> {
+        let end =
+            self.position.checked_add(length).context("LZ4DIFF protobuf field range overflow")?;
+        ensure!(end <= self.bytes.len(), "LZ4DIFF protobuf field overruns header");
+        self.position = end;
+        Ok(())
+    }
+
+    fn skip(&mut self, field: u64, wire_type: u8) -> Result<()> {
+        self.skip_with_depth(field, wire_type, 0)
+    }
+
+    fn skip_with_depth(&mut self, field: u64, wire_type: u8, depth: usize) -> Result<()> {
+        match wire_type {
+            0 => {
+                self.varint()?;
+            }
+            1 => self.advance(8)?,
+            2 => {
+                self.bytes()?;
+            }
+            3 => {
+                ensure!(
+                    depth < PROTOBUF_RECURSION_LIMIT,
+                    "LZ4DIFF protobuf recursion limit exceeded"
+                );
+                loop {
+                    let (nested_field, nested_wire_type) = self.key()?;
+                    if nested_wire_type == 4 {
+                        ensure!(nested_field == field, "mismatched LZ4DIFF protobuf end group");
+                        break;
+                    }
+                    self.skip_with_depth(nested_field, nested_wire_type, depth + 1)?;
+                }
+            }
+            4 => bail!("unexpected LZ4DIFF protobuf end group"),
+            5 => self.advance(4)?,
+            _ => bail!("unsupported LZ4DIFF protobuf wire type {wire_type}"),
+        }
+        Ok(())
+    }
+}
+
+fn scan_header(bytes: &[u8]) -> Result<HeaderLayout<'_>> {
+    let mut layout = HeaderLayout {
+        source_seen: false,
+        destination_seen: false,
+        source_blocks: Vec::new(),
+        destination_blocks: Vec::new(),
+    };
+    let mut cursor = ProtoCursor::new(bytes);
+    while !cursor.at_end() {
+        let (field, wire_type) = cursor.key()?;
+        match (field, wire_type) {
+            (1, 2) => {
+                layout.source_seen = true;
+                scan_compression_info(cursor.bytes()?, &mut layout.source_blocks)?;
+            }
+            (2, 2) => {
+                layout.destination_seen = true;
+                scan_compression_info(cursor.bytes()?, &mut layout.destination_blocks)?;
+            }
+            _ => cursor.skip(field, wire_type)?,
+        }
+    }
+    Ok(layout)
+}
+
+fn scan_compression_info<'a>(bytes: &'a [u8], blocks: &mut Vec<&'a [u8]>) -> Result<()> {
+    let mut cursor = ProtoCursor::new(bytes);
+    while !cursor.at_end() {
+        let (field, wire_type) = cursor.key()?;
+        if (field, wire_type) == (2, 2) {
+            let block = cursor.bytes()?;
+            blocks.try_reserve(1).context("unable to allocate LZ4DIFF block preflight")?;
+            blocks.push(block);
+        } else {
+            cursor.skip(field, wire_type)?;
+        }
+    }
+    Ok(())
+}
+
+fn scan_block_blobs(bytes: &[u8]) -> Result<(&[u8], &[u8])> {
+    let mut sha256_hash = &[][..];
+    let mut postfix_bspatch = &[][..];
+    let mut cursor = ProtoCursor::new(bytes);
+    while !cursor.at_end() {
+        let (field, wire_type) = cursor.key()?;
+        match (field, wire_type) {
+            (4, 2) => sha256_hash = cursor.bytes()?,
+            (5, 2) => postfix_bspatch = cursor.bytes()?,
+            _ => cursor.skip(field, wire_type)?,
+        }
+    }
+    Ok((sha256_hash, postfix_bspatch))
+}
+
+fn preallocated_info(block_count: usize) -> Result<CompressionInfoProto> {
+    let mut block_info = Vec::new();
+    block_info
+        .try_reserve_exact(block_count)
+        .context("unable to allocate LZ4DIFF protobuf block metadata")?;
+    Ok(CompressionInfoProto { algo: None, block_info, zero_padding_enabled: false })
+}
+
+pub(crate) fn apply(
+    source: &[u8],
+    patch: Patch<'_>,
+    cancellation_token: &CancellationToken,
+) -> Result<Vec<u8>> {
+    cancellation_token.check()?;
+    ensure!(
+        source.len() == patch.source.physical_size,
+        "LZ4DIFF source size changed after validation"
+    );
+    let uncompressed_source = decompress_source(source, &patch.source, cancellation_token)?;
+    cancellation_token.check()?;
+    let uncompressed_destination = match patch.inner_type {
+        InnerPatch::Bsdiff => apply_bsdiff(
+            &uncompressed_source,
+            patch.inner_patch,
+            patch.destination.uncompressed_size,
+            "inner BSDIFF",
+            cancellation_token,
+        )?,
+        InnerPatch::Puffdiff => puffin::apply(
+            &uncompressed_source,
+            patch.inner_patch,
+            patch.destination.uncompressed_size,
+            cancellation_token,
+        )
+        .map_err(|error| preserve_puffin_error(error, "inner PUFFDIFF patch is invalid"))?,
+    };
+    ensure!(
+        uncompressed_destination.len() == patch.destination.uncompressed_size,
+        "LZ4DIFF inner output size mismatch: expected {}, got {}",
+        patch.destination.uncompressed_size,
+        uncompressed_destination.len()
+    );
+    cancellation_token.check()?;
+    compress_destination(&uncompressed_destination, &patch.destination, cancellation_token)
+}
+
+pub(crate) fn parse<'a>(
+    patch_data: &'a [u8],
+    source_size: usize,
+    destination_size: usize,
+    expected_inner: InnerPatch,
+    cancellation_token: &CancellationToken,
+) -> Result<Patch<'a>> {
+    ensure_below_bound(patch_data.len(), "patch")?;
+    let framing = patch_data.get(..FRAMING_SIZE).context("LZ4DIFF framing is truncated")?;
+    ensure!(&framing[..MAGIC.len()] == MAGIC, "invalid LZ4DIFF magic");
+    let version =
+        u32::from_be_bytes(framing[7..11].try_into().context("invalid LZ4DIFF version field")?);
+    ensure!(version == VERSION, "unsupported LZ4DIFF version {version}");
+    let header_size = usize::try_from(u32::from_be_bytes(
+        framing[11..15].try_into().context("invalid LZ4DIFF header size field")?,
+    ))
+    .context("LZ4DIFF protobuf header is too large")?;
+    ensure!(framing[15] == 0, "LZ4DIFF framing padding byte is not zero");
+    ensure_below_bound(header_size, "protobuf header")?;
+    let header_end =
+        FRAMING_SIZE.checked_add(header_size).context("LZ4DIFF protobuf header range overflow")?;
+    let header_bytes = patch_data
+        .get(FRAMING_SIZE..header_end)
+        .context("LZ4DIFF protobuf header overruns patch")?;
+    let layout = scan_header(header_bytes)?;
+    ensure!(layout.source_seen, "LZ4DIFF source compression info is missing");
+    ensure!(layout.destination_seen, "LZ4DIFF destination compression info is missing");
+    let mut header = HeaderProto {
+        src_info: Some(preallocated_info(layout.source_blocks.len())?),
+        dst_info: Some(preallocated_info(layout.destination_blocks.len())?),
+        inner_type: 0,
+    };
+    header.merge(header_bytes).context("invalid LZ4DIFF protobuf header")?;
+    let inner = InnerPatchProto::try_from(header.inner_type)
+        .map_err(|_| anyhow::anyhow!("unknown LZ4DIFF inner patch type {}", header.inner_type))?;
+    let actual_inner = match inner {
+        InnerPatchProto::Bsdiff => InnerPatch::Bsdiff,
+        InnerPatchProto::Puffdiff => InnerPatch::Puffdiff,
+    };
+    ensure!(
+        actual_inner == expected_inner,
+        "LZ4DIFF operation type does not match inner patch type"
+    );
+    let source = validate_info(
+        header.src_info.context("LZ4DIFF source compression info is missing")?,
+        &layout.source_blocks,
+        "source",
+        true,
+        cancellation_token,
+    )?;
+    let destination = validate_info(
+        header.dst_info.context("LZ4DIFF destination compression info is missing")?,
+        &layout.destination_blocks,
+        "destination",
+        false,
+        cancellation_token,
+    )?;
+    ensure!(
+        source.physical_size == source_size,
+        "LZ4DIFF source physical size mismatch: metadata describes {}, operation provides {source_size}",
+        source.physical_size
+    );
+    ensure!(
+        destination.physical_size == destination_size,
+        "LZ4DIFF destination physical size mismatch: metadata describes {}, operation provides {destination_size}",
+        destination.physical_size
+    );
+    let inner_patch = patch_data.get(header_end..).context("invalid LZ4DIFF inner patch offset")?;
+    ensure!(!inner_patch.is_empty(), "LZ4DIFF inner patch is empty");
+    ensure_below_bound(inner_patch.len(), "inner patch")?;
+    Ok(Patch { source, destination, inner_patch, inner_type: actual_inner })
+}
+
+fn validate_info<'a>(
+    info: CompressionInfoProto,
+    block_messages: &[&'a [u8]],
+    label: &str,
+    is_source: bool,
+    cancellation_token: &CancellationToken,
+) -> Result<CompressionInfo<'a>> {
+    cancellation_token.check()?;
+    let algorithm = info.algo.context(format!("LZ4DIFF {label} algorithm is missing"))?;
+    let algorithm_type = AlgorithmProto::try_from(algorithm.r#type).map_err(|_| {
+        anyhow::anyhow!("unknown LZ4DIFF {label} compression algorithm {}", algorithm.r#type)
+    })?;
+    let algorithm_type = match algorithm_type {
+        AlgorithmProto::Uncompressed => {
+            ensure!(algorithm.level == 0, "LZ4DIFF {label} uncompressed level must be zero");
+            Algorithm::Uncompressed
+        }
+        AlgorithmProto::Lz4 => {
+            ensure!(algorithm.level == 0, "LZ4DIFF {label} LZ4 level must be zero");
+            Algorithm::Lz4
+        }
+        AlgorithmProto::Lz4hc => {
+            ensure!(
+                (lz4::HC_LEVEL_MIN..=lz4::HC_LEVEL_MAX).contains(&algorithm.level),
+                "LZ4DIFF {label} LZ4HC level must be in {}..={}",
+                lz4::HC_LEVEL_MIN,
+                lz4::HC_LEVEL_MAX
+            );
+            Algorithm::Lz4hc
+        }
+    };
+    ensure!(!info.block_info.is_empty(), "LZ4DIFF {label} block list is empty");
+    if info.zero_padding_enabled {
+        ensure!(
+            algorithm_type != Algorithm::Uncompressed,
+            "LZ4DIFF {label} zero padding requires LZ4 compression"
+        );
+    }
+
+    let mut blocks = Vec::new();
+    blocks
+        .try_reserve_exact(info.block_info.len())
+        .context("unable to allocate LZ4DIFF block metadata")?;
+    let mut uncompressed_size = 0usize;
+    let mut physical_size = 0usize;
+    let mut has_compressed_block = false;
+    ensure!(
+        info.block_info.len() == block_messages.len(),
+        "LZ4DIFF {label} block preflight count mismatch"
+    );
+    for (index, (block, block_message)) in
+        info.block_info.into_iter().zip(block_messages).enumerate()
+    {
+        cancellation_token.check()?;
+        let (sha256_hash, postfix_bspatch) = scan_block_blobs(block_message)?;
+        let uncompressed_offset = to_size(block.uncompressed_offset, label, index, "offset")?;
+        let uncompressed_length = to_size(block.uncompressed_length, label, index, "length")?;
+        let compressed_length = to_size(block.compressed_length, label, index, "physical length")?;
+        ensure!(
+            uncompressed_offset == uncompressed_size,
+            "LZ4DIFF {label} blocks are not contiguous at block {index}"
+        );
+        ensure!(
+            uncompressed_length > 0 && compressed_length > 0,
+            "LZ4DIFF {label} block {index} has an empty length"
+        );
+        ensure!(
+            compressed_length <= uncompressed_length,
+            "LZ4DIFF {label} block {index} physical length exceeds its raw length"
+        );
+        has_compressed_block |= compressed_length < uncompressed_length;
+        uncompressed_size = uncompressed_size
+            .checked_add(uncompressed_length)
+            .context(format!("LZ4DIFF {label} uncompressed size overflow"))?;
+        physical_size = physical_size
+            .checked_add(compressed_length)
+            .context(format!("LZ4DIFF {label} physical size overflow"))?;
+        ensure_below_bound(uncompressed_size, &format!("{label} uncompressed stream"))?;
+        ensure_below_bound(physical_size, &format!("{label} physical stream"))?;
+
+        if is_source {
+            ensure!(
+                sha256_hash.is_empty() && postfix_bspatch.is_empty(),
+                "LZ4DIFF source block {index} contains destination-only metadata"
+            );
+        } else {
+            ensure!(
+                sha256_hash.is_empty() || sha256_hash.len() == digest::SHA256_OUTPUT_LEN,
+                "LZ4DIFF destination block {index} SHA-256 hash must be empty or 32 bytes"
+            );
+            if !postfix_bspatch.is_empty() {
+                ensure!(
+                    compressed_length < uncompressed_length,
+                    "LZ4DIFF destination raw block {index} cannot have a postfix patch"
+                );
+                ensure!(
+                    sha256_hash.len() == digest::SHA256_OUTPUT_LEN,
+                    "LZ4DIFF destination block {index} postfix patch requires a SHA-256 hash"
+                );
+                ensure_below_bound(postfix_bspatch.len(), "postfix patch")?;
+                validate_bsdiff_output_len(postfix_bspatch, compressed_length)
+                    .with_context(|| format!("LZ4DIFF destination block {index} postfix patch"))?;
+                puffin::validate_bsdiff_resources(
+                    postfix_bspatch,
+                    compressed_length,
+                    cancellation_token,
+                )
+                .map_err(|error| {
+                    preserve_puffin_error(
+                        error,
+                        &format!("LZ4DIFF destination block {index} postfix patch is invalid"),
+                    )
+                })?;
+            }
+        }
+        blocks.push(Block {
+            uncompressed_offset,
+            uncompressed_length,
+            compressed_length,
+            sha256_hash,
+            postfix_bspatch,
+        });
+    }
+    ensure!(
+        algorithm_type != Algorithm::Uncompressed || !has_compressed_block,
+        "LZ4DIFF {label} uses compressed blocks with the uncompressed algorithm"
+    );
+    Ok(CompressionInfo {
+        algorithm: algorithm_type,
+        level: algorithm.level,
+        blocks,
+        zero_padding_enabled: info.zero_padding_enabled,
+        uncompressed_size,
+        physical_size,
+    })
+}
+
+fn to_size(value: u64, label: &str, index: usize, field: &str) -> Result<usize> {
+    usize::try_from(value)
+        .with_context(|| format!("LZ4DIFF {label} block {index} {field} is too large"))
+}
+
+fn ensure_below_bound(size: usize, label: &str) -> Result<()> {
+    ensure!(
+        size < zucchini::OFFSET_BOUND,
+        "LZ4DIFF {label} exceeds the maximum size of {} bytes",
+        zucchini::OFFSET_BOUND - 1
+    );
+    Ok(())
+}
+
+fn decompress_source(
+    source: &[u8],
+    info: &CompressionInfo,
+    cancellation_token: &CancellationToken,
+) -> Result<Vec<u8>> {
+    let mut output = Vec::new();
+    output
+        .try_reserve_exact(info.uncompressed_size)
+        .context("unable to allocate LZ4DIFF uncompressed source")?;
+    let mut physical_offset = 0usize;
+    for (index, block) in info.blocks.iter().enumerate() {
+        cancellation_token.check()?;
+        let end = physical_offset
+            .checked_add(block.compressed_length)
+            .context("LZ4DIFF source block range overflow")?;
+        let physical = source
+            .get(physical_offset..end)
+            .with_context(|| format!("LZ4DIFF source block {index} exceeds source data"))?;
+        if block.compressed_length == block.uncompressed_length {
+            output.extend_from_slice(physical);
+        } else {
+            let margin = if info.zero_padding_enabled {
+                physical
+                    .iter()
+                    .take(EROFS_BLOCK_SIZE.min(physical.len()))
+                    .take_while(|byte| **byte == 0)
+                    .count()
+            } else {
+                0
+            };
+            let compressed = physical
+                .get(margin..)
+                .with_context(|| format!("invalid LZ4DIFF source block {index} input margin"))?;
+            let decompressed = lz4::decompress_safe_partial(compressed, block.uncompressed_length)
+                .with_context(|| format!("unable to decompress LZ4DIFF source block {index}"))?;
+            output.extend_from_slice(&decompressed);
+        }
+        physical_offset = end;
+    }
+    ensure!(
+        physical_offset == source.len() && output.len() == info.uncompressed_size,
+        "LZ4DIFF source block layout size mismatch"
+    );
+    Ok(output)
+}
+
+fn apply_bsdiff(
+    source: &[u8],
+    patch: &[u8],
+    output_size: usize,
+    label: &str,
+    cancellation_token: &CancellationToken,
+) -> Result<Vec<u8>> {
+    validate_bsdiff_output_len(patch, output_size)
+        .with_context(|| format!("LZ4DIFF {label} patch is invalid"))?;
+    cancellation_token.check()?;
+    puffin::validate_bsdiff_resources(patch, output_size, cancellation_token).map_err(|error| {
+        preserve_puffin_error(error, &format!("LZ4DIFF {label} patch is invalid"))
+    })?;
+    cancellation_token.check()?;
+    let mut output = Vec::new();
+    output
+        .try_reserve_exact(output_size)
+        .with_context(|| format!("unable to allocate LZ4DIFF {label} output"))?;
+    patch_bsdf2(source, patch, &mut output)
+        .with_context(|| format!("LZ4DIFF {label} patch is invalid"))?;
+    cancellation_token.check()?;
+    ensure!(
+        output.len() == output_size,
+        "LZ4DIFF {label} output size mismatch: expected {output_size}, got {}",
+        output.len()
+    );
+    Ok(output)
+}
+
+fn preserve_puffin_error(error: puffin::Error, context: &str) -> anyhow::Error {
+    let message = error.to_string();
+    anyhow::Error::new(error).context(format!("{context}: {message}"))
+}
+
+fn compress_destination(
+    uncompressed: &[u8],
+    info: &CompressionInfo,
+    cancellation_token: &CancellationToken,
+) -> Result<Vec<u8>> {
+    ensure!(
+        uncompressed.len() == info.uncompressed_size,
+        "LZ4DIFF destination uncompressed size mismatch"
+    );
+    let mut output = Vec::new();
+    output
+        .try_reserve_exact(info.physical_size)
+        .context("unable to allocate LZ4DIFF destination")?;
+    for (index, block) in info.blocks.iter().enumerate() {
+        cancellation_token.check()?;
+        let raw_end = block
+            .uncompressed_offset
+            .checked_add(block.uncompressed_length)
+            .context("LZ4DIFF destination block range overflow")?;
+        let raw = uncompressed
+            .get(block.uncompressed_offset..raw_end)
+            .with_context(|| format!("LZ4DIFF destination block {index} exceeds inner output"))?;
+        if block.compressed_length == block.uncompressed_length {
+            output.extend_from_slice(raw);
+            continue;
+        }
+        let mut physical = {
+            let remaining = uncompressed
+                .get(block.uncompressed_offset..)
+                .with_context(|| format!("invalid LZ4DIFF destination block {index} offset"))?;
+            let level = match info.algorithm {
+                Algorithm::Lz4 => None,
+                Algorithm::Lz4hc => Some(info.level),
+                Algorithm::Uncompressed => {
+                    bail!("LZ4DIFF destination compressed block uses uncompressed algorithm")
+                }
+            };
+            lz4::compress_dest_size_partial(
+                remaining,
+                block.uncompressed_length,
+                block.compressed_length,
+                level,
+                info.zero_padding_enabled,
+            )
+            .with_context(|| format!("unable to compress LZ4DIFF destination block {index}"))?
+        };
+        ensure!(
+            physical.len() == block.compressed_length,
+            "LZ4DIFF destination block {index} physical size mismatch"
+        );
+        if !block.postfix_bspatch.is_empty() {
+            cancellation_token.check()?;
+            let actual = digest::digest(&digest::SHA256, &physical);
+            ensure!(
+                actual.as_ref() == block.sha256_hash,
+                "LZ4DIFF destination block {index} reference recompression hash mismatch"
+            );
+            physical = apply_bsdiff(
+                &physical,
+                block.postfix_bspatch,
+                block.compressed_length,
+                "postfix BSDIFF",
+                cancellation_token,
+            )?;
+        }
+        output.extend_from_slice(&physical);
+    }
+    ensure!(
+        output.len() == info.physical_size,
+        "LZ4DIFF destination physical size mismatch after compression"
+    );
+    cancellation_token.check()?;
+    Ok(output)
+}
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index 97b861f..7ed104a 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -81,6 +81,48 @@ struct DeltaArchiveManifest {
     partitions: Vec<PartitionUpdate>,
 }
 
+#[derive(Clone, Copy, PartialEq, Message)]
+struct Lz4diffAlgorithm {
+    #[prost(int32, tag = "1")]
+    algorithm_type: i32,
+    #[prost(int32, tag = "2")]
+    level: i32,
+}
+
+#[derive(Clone, PartialEq, Message)]
+struct Lz4diffBlock {
+    #[prost(uint64, tag = "1")]
+    uncompressed_offset: u64,
+    #[prost(uint64, tag = "2")]
+    uncompressed_length: u64,
+    #[prost(uint64, tag = "3")]
+    compressed_length: u64,
+    #[prost(bytes = "vec", tag = "4")]
+    sha256_hash: Vec<u8>,
+    #[prost(bytes = "vec", tag = "5")]
+    postfix_bspatch: Vec<u8>,
+}
+
+#[derive(Clone, PartialEq, Message)]
+struct Lz4diffCompressionInfo {
+    #[prost(message, optional, tag = "1")]
+    algo: Option<Lz4diffAlgorithm>,
+    #[prost(message, repeated, tag = "2")]
+    block_info: Vec<Lz4diffBlock>,
+    #[prost(bool, tag = "3")]
+    zero_padding_enabled: bool,
+}
+
+#[derive(Clone, PartialEq, Message)]
+struct Lz4diffHeader {
+    #[prost(message, optional, tag = "1")]
+    src_info: Option<Lz4diffCompressionInfo>,
+    #[prost(message, optional, tag = "2")]
+    dst_info: Option<Lz4diffCompressionInfo>,
+    #[prost(int32, tag = "3")]
+    inner_type: i32,
+}
+
 fn sha256(bytes: &[u8]) -> Vec<u8> {
     digest::digest(&digest::SHA256, bytes).as_ref().to_vec()
 }
@@ -106,6 +148,189 @@ const BROTLI_INVALID_HEADER_PATCH: &[u8] = &[
 ];
 
 const PUFFIN_FIXTURES: &str = "tests/fixtures/puffin";
+const LZ4DIFF_FIXTURES: &str = "tests/fixtures/lz4diff";
+
+fn run_lz4diff_bytes(
+    source: &[u8],
+    target: &[u8],
+    patch: &[u8],
+    operation_type: i32,
+) -> Result<Vec<u8>, String> {
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+    fs::write(source_dir.join("system.img"), source).unwrap();
+
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(1),
+        minor_version: Some(9),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(source)),
+            new_partition_info: Some(partition_info(target)),
+            operations: vec![InstallOperation {
+                operation_type,
+                data_offset: Some(0),
+                data_length: Some(patch.len() as u64),
+                src_extents: vec![extent(0, source.len() as u64)],
+                src_length: Some(source.len() as u64),
+                dst_extents: vec![extent(0, target.len() as u64)],
+                dst_length: Some(target.len() as u64),
+                data_sha256_hash: Some(sha256(patch)),
+                src_sha256_hash: Some(sha256(source)),
+            }],
+            ..Default::default()
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, patch);
+
+    match ExtractOptions::new().source_dir(&source_dir).extract(&payload, &output_dir) {
+        Ok(()) => {
+            assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+            assert_eq!(fs::read_dir(&output_dir).unwrap().count(), 1);
+            Ok(fs::read(output_dir.join("system.img")).unwrap())
+        }
+        Err(error) => {
+            assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+            assert!(!output_dir.join("system.img").exists());
+            assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
+            Err(error.to_string())
+        }
+    }
+}
+
+fn run_lz4diff_extraction(name: &str, operation_type: i32) -> Result<Vec<u8>, String> {
+    let fixtures = Path::new(LZ4DIFF_FIXTURES).join(name);
+    let source = fs::read(fixtures.join("source.bin")).unwrap();
+    let target = fs::read(fixtures.join("target.bin")).unwrap();
+    let patch = fs::read(fixtures.join("patch.lz4diff")).unwrap();
+    run_lz4diff_bytes(&source, &target, &patch, operation_type)
+}
+
+fn rewrite_lz4diff_header(patch: &[u8], change: impl FnOnce(&mut Lz4diffHeader)) -> Vec<u8> {
+    let header_size = u32::from_be_bytes(patch[11..15].try_into().unwrap()) as usize;
+    let mut header = Lz4diffHeader::decode(&patch[16..16 + header_size]).unwrap();
+    change(&mut header);
+    let header = header.encode_to_vec();
+    let mut changed = Vec::with_capacity(16 + header.len() + patch.len() - 16 - header_size);
+    changed.extend_from_slice(b"LZ4DIFF");
+    changed.extend_from_slice(&1u32.to_be_bytes());
+    changed.extend_from_slice(&(header.len() as u32).to_be_bytes());
+    changed.push(0);
+    changed.extend_from_slice(&header);
+    changed.extend_from_slice(&patch[16 + header_size..]);
+    changed
+}
+
+#[test]
+fn lz4diff_operations_reconstruct_frozen_targets() {
+    for (name, operation_type) in [
+        ("lz4-bsdiff", 12),
+        ("lz4hc9-bsdiff", 12),
+        ("zero-padding-bsdiff", 12),
+        ("postfix-bsdiff", 12),
+        ("raw-puffdiff", 13),
+    ] {
+        let expected = fs::read(Path::new(LZ4DIFF_FIXTURES).join(name).join("target.bin")).unwrap();
+        let output = run_lz4diff_extraction(name, operation_type).unwrap();
+        assert_eq!(output, expected, "fixture {name}");
+    }
+}
+
+#[test]
+fn malformed_lz4diff_data_fails_without_publication_or_process_failure() {
+    let fixtures = Path::new(LZ4DIFF_FIXTURES).join("postfix-bsdiff");
+    let source = fs::read(fixtures.join("source.bin")).unwrap();
+    let target = fs::read(fixtures.join("target.bin")).unwrap();
+    let valid = fs::read(fixtures.join("patch.lz4diff")).unwrap();
+
+    let mut bad_magic = valid.clone();
+    bad_magic[0] = b'X';
+    let mut bad_version = valid.clone();
+    bad_version[7..11].copy_from_slice(&2u32.to_be_bytes());
+    let mut bad_padding = valid.clone();
+    bad_padding[15] = 1;
+    let mut overrun = valid.clone();
+    overrun[11..15].copy_from_slice(&u32::MAX.to_be_bytes());
+    let malformed_proto =
+        [b"LZ4DIFF".as_slice(), &1u32.to_be_bytes(), &1u32.to_be_bytes(), &[0, 0x80]].concat();
+    let mut nested_header = vec![0x23; 101];
+    nested_header.extend(std::iter::repeat_n(0x24, 101));
+    let mut excessive_nesting = Vec::new();
+    excessive_nesting.extend_from_slice(b"LZ4DIFF");
+    excessive_nesting.extend_from_slice(&1u32.to_be_bytes());
+    excessive_nesting.extend_from_slice(&(nested_header.len() as u32).to_be_bytes());
+    excessive_nesting.push(0);
+    excessive_nesting.extend_from_slice(&nested_header);
+    excessive_nesting.push(0);
+    let unknown_algorithm = rewrite_lz4diff_header(&valid, |header| {
+        header.dst_info.as_mut().unwrap().algo.as_mut().unwrap().algorithm_type = 99;
+    });
+    let missing_algorithm = rewrite_lz4diff_header(&valid, |header| {
+        header.src_info.as_mut().unwrap().algo = None;
+    });
+    let bad_hc_level = rewrite_lz4diff_header(&valid, |header| {
+        let algo = header.dst_info.as_mut().unwrap().algo.as_mut().unwrap();
+        algo.algorithm_type = 2;
+        algo.level = 13;
+    });
+    let unknown_inner = rewrite_lz4diff_header(&valid, |header| header.inner_type = 7);
+    let unsorted = rewrite_lz4diff_header(&valid, |header| {
+        header.src_info.as_mut().unwrap().block_info[0].uncompressed_offset = 1;
+    });
+    let out_of_bound = rewrite_lz4diff_header(&valid, |header| {
+        header.src_info.as_mut().unwrap().block_info[0].uncompressed_length = u64::MAX;
+    });
+    let invalid_physical = rewrite_lz4diff_header(&valid, |header| {
+        let block = &mut header.src_info.as_mut().unwrap().block_info[0];
+        block.compressed_length = block.uncompressed_length + 1;
+    });
+    let short_hash = rewrite_lz4diff_header(&valid, |header| {
+        header.dst_info.as_mut().unwrap().block_info[0].sha256_hash.pop();
+    });
+    let wrong_hash = rewrite_lz4diff_header(&valid, |header| {
+        header.dst_info.as_mut().unwrap().block_info[0].sha256_hash[0] ^= 1;
+    });
+    let missing_postfix_hash = rewrite_lz4diff_header(&valid, |header| {
+        header.dst_info.as_mut().unwrap().block_info[0].sha256_hash.clear();
+    });
+    let malformed_postfix = rewrite_lz4diff_header(&valid, |header| {
+        header.dst_info.as_mut().unwrap().block_info[0].postfix_bspatch[0] = b'X';
+    });
+    let source_only_metadata = rewrite_lz4diff_header(&valid, |header| {
+        header.src_info.as_mut().unwrap().block_info[0].sha256_hash = vec![0; 32];
+    });
+
+    for (patch, expected_error) in [
+        (bad_magic, "invalid LZ4DIFF magic"),
+        (bad_version, "unsupported LZ4DIFF version"),
+        (bad_padding, "framing padding byte is not zero"),
+        (overrun, "protobuf header exceeds the maximum size"),
+        (malformed_proto, "truncated LZ4DIFF protobuf varint"),
+        (excessive_nesting, "protobuf recursion limit exceeded"),
+        (unknown_algorithm, "unknown LZ4DIFF destination compression algorithm"),
+        (missing_algorithm, "LZ4DIFF source algorithm is missing"),
+        (bad_hc_level, "LZ4HC level must be"),
+        (unknown_inner, "unknown LZ4DIFF inner patch type"),
+        (unsorted, "source blocks are not contiguous"),
+        (out_of_bound, "source uncompressed stream exceeds"),
+        (invalid_physical, "physical length exceeds its raw length"),
+        (short_hash, "SHA-256 hash must be empty or 32 bytes"),
+        (wrong_hash, "reference recompression hash mismatch"),
+        (missing_postfix_hash, "postfix patch requires a SHA-256 hash"),
+        (malformed_postfix, "postfix patch"),
+        (source_only_metadata, "contains destination-only metadata"),
+    ] {
+        let error = run_lz4diff_bytes(&source, &target, &patch, 12).unwrap_err();
+        assert!(error.contains(expected_error), "unexpected error: {error}");
+    }
+
+    let mismatched_inner = rewrite_lz4diff_header(&valid, |header| header.inner_type = 1);
+    let error = run_lz4diff_bytes(&source, &target, &mismatched_inner, 12).unwrap_err();
+    assert!(error.contains("operation type does not match"), "unexpected error: {error}");
+}
 
 fn run_puffdiff_extraction(source: &[u8], target: &[u8], patch: &[u8]) -> Result<Vec<u8>, String> {
     let temporary = TempDir::new().unwrap();
diff --git a/tests/fixtures/lz4diff/LICENSE.lz4 b/tests/fixtures/lz4diff/LICENSE.lz4
new file mode 100644
index 0000000..a1221be
--- /dev/null
+++ b/tests/fixtures/lz4diff/LICENSE.lz4
@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2026, Milestone 6a proof contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/tests/fixtures/lz4diff/LICENSE.puffin b/tests/fixtures/lz4diff/LICENSE.puffin
new file mode 100644
index 0000000..f6d41c6
--- /dev/null
+++ b/tests/fixtures/lz4diff/LICENSE.puffin
@@ -0,0 +1,27 @@
+// Copyright 2017 The ChromiumOS Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/tests/fixtures/lz4diff/README.md b/tests/fixtures/lz4diff/README.md
new file mode 100644
index 0000000..ef9bace
--- /dev/null
+++ b/tests/fixtures/lz4diff/README.md
@@ -0,0 +1,26 @@
+# Frozen LZ4DIFF operation fixtures
+
+These static fixtures exercise complete version-1 `LZ4DIFF` operation data.
+Each case contains the physical source bytes, the independently frozen physical target bytes, and the complete container patch.
+
+The LZ4, LZ4HC9, and zero-padding source and target bytes come unchanged from the Milestone 6a reference proof.
+That proof pins AOSP `platform/external/lz4` commit `734e07032602e9a72fcc9701028b0aee45147fcd` and `platform/system/update_engine` commit `dc84c2552b2d4cf00d2a843cb1c091d99d0499f1`.
+The postfix target starts from the frozen LZ4 reference block and changes byte 23 with XOR `0x5a` before patch generation.
+The PUFFDIFF source, patch, and expected target come unchanged from ChromiumOS Puffin commit `343e23db1b4d81045e91a10244244893f5acd73b`.
+
+The LZ4DIFF protobuf and framing follow the pinned Android update_engine `lz4diff.proto`, `lz4diff_format.h`, and `lz4diff.cc` sources.
+The inner identity patches and the real postfix patch are frozen BSDIFF40 output from the reference BSDIFF algorithm in `bsdiff-android` 0.0.2.
+Fixture generation is separate from the extractor implementation.
+The extractor does not generate expected target bytes.
+
+| Case | Inner type | Destination layout | Postfix |
+| --- | --- | --- | --- |
+| `lz4-bsdiff` | BSDIFF | LZ4, 1024 raw bytes in 768 physical bytes | None |
+| `lz4hc9-bsdiff` | BSDIFF | LZ4HC level 9, 1536 raw bytes in 1152 physical bytes | None |
+| `zero-padding-bsdiff` | BSDIFF | 32-byte raw block and leading-zero-padded LZ4 block | None |
+| `postfix-bsdiff` | BSDIFF | LZ4 reference recompression | BSDIFF40 with SHA-256 guard |
+| `raw-puffdiff` | PUFFDIFF | Uncompressed blocks | None |
+
+The LZ4-derived bytes retain the BSD-2-Clause license in `LICENSE.lz4`.
+The Puffin-derived bytes retain the BSD-3-Clause license in `LICENSE.puffin`.
+Run `sha256sum -c SHA256SUMS` from this directory to verify every frozen file.
diff --git a/tests/fixtures/lz4diff/SHA256SUMS b/tests/fixtures/lz4diff/SHA256SUMS
new file mode 100644
index 0000000..b9b674a
--- /dev/null
+++ b/tests/fixtures/lz4diff/SHA256SUMS
@@ -0,0 +1,15 @@
+4cd1380f674ea78e86276bc9ce39ab88b45bbbccb96c611e18bdd7108c738cfa  lz4-bsdiff/patch.lz4diff
+6ea395fcef53c8e4de2fc708f4c8e1db7de05b53e48a891c77cbebee4e914e65  lz4-bsdiff/source.bin
+6ea395fcef53c8e4de2fc708f4c8e1db7de05b53e48a891c77cbebee4e914e65  lz4-bsdiff/target.bin
+43efe58bdcd3552ffcda9608aa72a9f8189984af9cecd3143d468021e3b54c2d  lz4hc9-bsdiff/patch.lz4diff
+12a28b1f3d4cc5f8b0bfa534f062abae2b9bdbcd886fa2d657cf81e10b2e273e  lz4hc9-bsdiff/source.bin
+12a28b1f3d4cc5f8b0bfa534f062abae2b9bdbcd886fa2d657cf81e10b2e273e  lz4hc9-bsdiff/target.bin
+08fe5ecea8e3f48ec17665d50807516d63b17dcb729baa540566679a261228d4  postfix-bsdiff/patch.lz4diff
+6ea395fcef53c8e4de2fc708f4c8e1db7de05b53e48a891c77cbebee4e914e65  postfix-bsdiff/source.bin
+061f6d1ae1218e7280373e8f0d6791836ef1a6c4c1ffcc8f5beedef56c4f20b7  postfix-bsdiff/target.bin
+4b9ce7db27ac550c6d7fd1e7f18a535c3a4616c8702fe9655a1d10839c681846  raw-puffdiff/patch.lz4diff
+de0527c0d2d27f378cb79aec447172e0efcfff9cc45d0be05c313a87a2069280  raw-puffdiff/source.bin
+649b17ae72a6d503a1176604d876923270cd467ae1d458a54e58575eda98766e  raw-puffdiff/target.bin
+3c5f3a2fa1bbf4dd938eb05dfb76cf53d4a95b70cb06e35faed6c560a7077260  zero-padding-bsdiff/patch.lz4diff
+1e5b41d7f2e7c5d541a65b683be0c357da12241a036509853962e8888e900c87  zero-padding-bsdiff/source.bin
+1e5b41d7f2e7c5d541a65b683be0c357da12241a036509853962e8888e900c87  zero-padding-bsdiff/target.bin
diff --git a/tests/fixtures/lz4diff/lz4-bsdiff/patch.lz4diff b/tests/fixtures/lz4diff/lz4-bsdiff/patch.lz4diff
new file mode 100644
index 0000000000000000000000000000000000000000..d4cbd11d27fd6eaaf7843a68425b247200022573
GIT binary patch
literal 181
zcmeZ?GI8;Ab7Np&U<6_r1}+{hCJsg+Hh~5Xi3T<y6rNKsNU4c|Ay6d<XhA3j1{Mgz
zDJsL#&@oaiIMN_4`WgcR^8uF}0SBPm0tQ1KhAAgbe0?YwsNcO)X^w`6gud=;284!^
uuWP>p&2eBjz`($vz+ljzmFc?1V)rD?LoLnA*XHj4sT41AwFsC1vI+oLMJa6n

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/lz4-bsdiff/source.bin b/tests/fixtures/lz4diff/lz4-bsdiff/source.bin
new file mode 100644
index 0000000000000000000000000000000000000000..c635da170bdc86177413483ad902b18646ae61cf
GIT binary patch
literal 768
zcmew_k(a7#mZ<9!WulvsT9R6no0*qcT#}iro0eHoQd*R%@0*#ET3nK^&LHuA;=0o>
zSe5K!DyMC}@RrMuL6?6H1H=2i)hC`Z$=gJhP2O<!75f|pDSkf&2L4w-neG)wAN`lH
z3@e_n_SAD0K}J2kQik^(OAp=uBWV^~(7WpR6UKN(X+A#&{<Vw@?^_q`zw=YfI3Txc
z`H_eJt}yEJ0#!H7-*fYuuz_z@`;vqAek(D_@B&r00ae$}*?H}=fUZ}1%ffxPe@tgG
z-~p<xnYr!q2VO1rl*W0xZ+v~qB+CO)&BVamukMmqH+#p`Pf^T<+@%a45f#U{>KR)v
Sy<fpBmjDR?hEXuWLI3~)c5lD{

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/lz4-bsdiff/target.bin b/tests/fixtures/lz4diff/lz4-bsdiff/target.bin
new file mode 100644
index 0000000000000000000000000000000000000000..c635da170bdc86177413483ad902b18646ae61cf
GIT binary patch
literal 768
zcmew_k(a7#mZ<9!WulvsT9R6no0*qcT#}iro0eHoQd*R%@0*#ET3nK^&LHuA;=0o>
zSe5K!DyMC}@RrMuL6?6H1H=2i)hC`Z$=gJhP2O<!75f|pDSkf&2L4w-neG)wAN`lH
z3@e_n_SAD0K}J2kQik^(OAp=uBWV^~(7WpR6UKN(X+A#&{<Vw@?^_q`zw=YfI3Txc
z`H_eJt}yEJ0#!H7-*fYuuz_z@`;vqAek(D_@B&r00ae$}*?H}=fUZ}1%ffxPe@tgG
z-~p<xnYr!q2VO1rl*W0xZ+v~qB+CO)&BVamukMmqH+#p`Pf^T<+@%a45f#U{>KR)v
Sy<fpBmjDR?hEXuWLI3~)c5lD{

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/lz4hc9-bsdiff/patch.lz4diff b/tests/fixtures/lz4diff/lz4hc9-bsdiff/patch.lz4diff
new file mode 100644
index 0000000000000000000000000000000000000000..71097745271a53ec43765312fd3cb39aaea4f3ca
GIT binary patch
literal 185
zcmeZ?GI8;Ab7Np&U<6_X1};7>77iu>P9Zjd1|Eq9P9ZeDQ!q%miGd+dH3(=yC<X>L
z2*W8V!_v?(QY|<#;p(gk1_tH>4vz&KfCeit81gVoIdS6aL%~4(?wv|=G&~Hl&e|{_
wG}N_Qm;p67FkE0@;80*NIKwf^*<nxYNs)(6j=y9c+yJQ*FLJdAm;ka00HCNTGynhq

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/lz4hc9-bsdiff/source.bin b/tests/fixtures/lz4diff/lz4hc9-bsdiff/source.bin
new file mode 100644
index 0000000000000000000000000000000000000000..6c24b45279e4b9fbe194b34726148821e3c52d04
GIT binary patch
literal 1152
zcmew_5oMyAl3J2ll$)8CSzMBtteciuQBqozs_&bblUiJopO>m@mZ<Ba&LIAN_l>VY
z`aYR$ix1rWC2r!!pv$k$!0>Lz)ld97o@vbs_TKs~V(7=ff0#k<Kf~5b?|C%ck{jmk
zy8cB_Pxml`{eOl{=ihLuIVaT4+J5CDpSBrTZ2g&+Y|0L?Rnxaze8;Vk3>I5+@)@&&
zZB+S`jptr-s6zCvJocDD)+)SY;=0o>Sd}ut>XsdT@K?$_q_A)GiKk5RsX#F%2Il#J
zdEG0HKKd_H0_FQ<cPu@0|BqxIl<%F<x@iBMpJK&OzDH`){5?0n3Fkxku1WQCc3%4|
t0I~yQo>P3y%x#xH@WRZqkExut`NCT+pm|mS;4ott1*0J_8Uo~m005r}iYEX7

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/lz4hc9-bsdiff/target.bin b/tests/fixtures/lz4diff/lz4hc9-bsdiff/target.bin
new file mode 100644
index 0000000000000000000000000000000000000000..6c24b45279e4b9fbe194b34726148821e3c52d04
GIT binary patch
literal 1152
zcmew_5oMyAl3J2ll$)8CSzMBtteciuQBqozs_&bblUiJopO>m@mZ<Ba&LIAN_l>VY
z`aYR$ix1rWC2r!!pv$k$!0>Lz)ld97o@vbs_TKs~V(7=ff0#k<Kf~5b?|C%ck{jmk
zy8cB_Pxml`{eOl{=ihLuIVaT4+J5CDpSBrTZ2g&+Y|0L?Rnxaze8;Vk3>I5+@)@&&
zZB+S`jptr-s6zCvJocDD)+)SY;=0o>Sd}ut>XsdT@K?$_q_A)GiKk5RsX#F%2Il#J
zdEG0HKKd_H0_FQ<cPu@0|BqxIl<%F<x@iBMpJK&OzDH`){5?0n3Fkxku1WQCc3%4|
t0I~yQo>P3y%x#xH@WRZqkExut`NCT+pm|mS;4ott1*0J_8Uo~m005r}iYEX7

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/postfix-bsdiff/patch.lz4diff b/tests/fixtures/lz4diff/postfix-bsdiff/patch.lz4diff
new file mode 100644
index 0000000000000000000000000000000000000000..065599364df4eb4a3c23548739bfe8e584dca612
GIT binary patch
literal 366
zcmeZ?GI8;Ab7Np&U<Bf;3|u^1OdO0tYyu4&5)EuZM;O7}y^IjPl0x3%sej%FpLlXl
z|2W5&6Ay3KK8Ox}($y(be){!0zlnaST9X)^f<Y#l7#IQ#1Oa0R#lXM}VK_x)SQ<J;
zss%@GwcIWa6h7csA>hEk;Gn=@$ipz@#EGvD1q1cFcPh=%@Q9joySo9QVa4KSu0TT)
zSPw98Ffa%Joy?)Yptx1qaTeFH2^ELlc`WA=5*4XAu>hn+yvWreU;@ZabQfuX1VMlW
zLLn?Lh>N}ka*<08$VChbFkK{}ult$-p`qmK+V4Pf92gFO-D1$7mFc?1V)rD?LoLnA
K*XHj)bqE03vSr%<

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/postfix-bsdiff/source.bin b/tests/fixtures/lz4diff/postfix-bsdiff/source.bin
new file mode 100644
index 0000000000000000000000000000000000000000..c635da170bdc86177413483ad902b18646ae61cf
GIT binary patch
literal 768
zcmew_k(a7#mZ<9!WulvsT9R6no0*qcT#}iro0eHoQd*R%@0*#ET3nK^&LHuA;=0o>
zSe5K!DyMC}@RrMuL6?6H1H=2i)hC`Z$=gJhP2O<!75f|pDSkf&2L4w-neG)wAN`lH
z3@e_n_SAD0K}J2kQik^(OAp=uBWV^~(7WpR6UKN(X+A#&{<Vw@?^_q`zw=YfI3Txc
z`H_eJt}yEJ0#!H7-*fYuuz_z@`;vqAek(D_@B&r00ae$}*?H}=fUZ}1%ffxPe@tgG
z-~p<xnYr!q2VO1rl*W0xZ+v~qB+CO)&BVamukMmqH+#p`Pf^T<+@%a45f#U{>KR)v
Sy<fpBmjDR?hEXuWLI3~)c5lD{

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/postfix-bsdiff/target.bin b/tests/fixtures/lz4diff/postfix-bsdiff/target.bin
new file mode 100644
index 0000000000000000000000000000000000000000..8f0e10814e164cc4e087dc31b44d8e3a5977b40b
GIT binary patch
literal 768
zcmew_k(a7#mZ<9!WulvsT9R6no0*qcTw<K8o0eHoQd*R%@0*#ET3nK^&LHuA;=0o>
zSe5K!DyMC}@RrMuL6?6H1H=2i)hC`Z$=gJhP2O<!75f|pDSkf&2L4w-neG)wAN`lH
z3@e_n_SAD0K}J2kQik^(OAp=uBWV^~(7WpR6UKN(X+A#&{<Vw@?^_q`zw=YfI3Txc
z`H_eJt}yEJ0#!H7-*fYuuz_z@`;vqAek(D_@B&r00ae$}*?H}=fUZ}1%ffxPe@tgG
z-~p<xnYr!q2VO1rl*W0xZ+v~qB+CO)&BVamukMmqH+#p`Pf^T<+@%a45f#U{>KR)v
Sy<fpBmjDR?hEXuWLI40|L2rrx

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/raw-puffdiff/patch.lz4diff b/tests/fixtures/lz4diff/raw-puffdiff/patch.lz4diff
new file mode 100644
index 0000000000000000000000000000000000000000..623ee4aa0f6834ffd36fff1c6c08b66a5c45d286
GIT binary patch
literal 304
zcmeZ?GI8;Ab7Np&U<6_@1}+XR1|b#!K?y-22un;tOoA~W)Xfkm9mv5bq|U{{As}D`
zBm)GvfMkMzkPt{D0!UT}Xb7=#tY8$dkdT*B;bH<S^AHH&V&#~@2vo-eR#gBbSvgLC
zR4F<IySN!KGBR2KO$PxJ2*scXrJbTOEDaqa)q*20D(tRfU|>#gsNmyZa9~hiFl6&_
znAGpKe8q#$*A#`m>~S`d7cX+P2$%p;iO}~^A)c3kfyq(Si9-RXkAVrKSIJgcppAK2
nh@e<JL=Q+6LJ#|u(|HV_5MczWRg`dRdgrm6ONimu%-jP2Pq#Ud

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/raw-puffdiff/source.bin b/tests/fixtures/lz4diff/raw-puffdiff/source.bin
new file mode 100644
index 0000000000000000000000000000000000000000..3bfad73a72fd1e3307444a8d7a66d2a7c0222dc9
GIT binary patch
literal 17
YcmWesN=`{iOJrp*W@bocVQ>ir03kmEUjP6A

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/raw-puffdiff/target.bin b/tests/fixtures/lz4diff/raw-puffdiff/target.bin
new file mode 100644
index 0000000000000000000000000000000000000000..a5ae9f565d494da1912b5ed3119fc6b8690e6083
GIT binary patch
literal 22
dcmYdJNlHs(WiU=-WM%mEpOJ}~g*BOl0RTip1q1*9

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/zero-padding-bsdiff/patch.lz4diff b/tests/fixtures/lz4diff/zero-padding-bsdiff/patch.lz4diff
new file mode 100644
index 0000000000000000000000000000000000000000..07a7a0e50a8e0a44407ef1b4296c30c8f11db778
GIT binary patch
literal 202
zcmeZ?GI8;Ab7Np&U<6_V1}-r!CJsg+76Anb1tAU&1%U=Oi32PWj6yiXoq|EyO$_vb
zx<Nn}LNO>XLl{m`8J32Qk!rz_pAHtqGcd4SaL5pGU~phiU{IXQqS)ZvIW=}q>`9S_
zPR^%UPu3umA9wvI26WT|h66x@8aNaf6jtRr&e+v_^v*;-5f#IWHLeXH#o|S-76B7L
Gb^!oyFf4Zf

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/zero-padding-bsdiff/source.bin b/tests/fixtures/lz4diff/zero-padding-bsdiff/source.bin
new file mode 100644
index 0000000000000000000000000000000000000000..8185bd833dcc04217a9fbcaba60b9fb963e79db8
GIT binary patch
literal 608
zcmXTQ&CJUzF3C*RP0Oq(DJ@FX_sz^nEiTE=OVu??)b(K)1=I_HuM$xvx+$q8sYL`r
zU7g|mQzm(v$g;^B&c0$-ag0-EVB_~=5aCy6V0i!Nzl>#A@r1Rfp0g<0MbBZ70?IJ(
z9|p?Y|08J@T+qAf_!CAs>xfqj>_8b|ehWs1_ji7Z83*KcEkE+`pR`42Jfk#!DTC1a
zo8N>De6!k@9K82i!Zc_tBL`5u5ZI1up9OTi(pwhpyZuAd$X|&`2B==}{pAn5TJ9;0
u^LF3(Dx~jIz{CkuFUa4<$nf;STP}5%#Jbr#u72Xz@!ZG6>BkTNPD=pD31yi8

literal 0
HcmV?d00001

diff --git a/tests/fixtures/lz4diff/zero-padding-bsdiff/target.bin b/tests/fixtures/lz4diff/zero-padding-bsdiff/target.bin
new file mode 100644
index 0000000000000000000000000000000000000000..8185bd833dcc04217a9fbcaba60b9fb963e79db8
GIT binary patch
literal 608
zcmXTQ&CJUzF3C*RP0Oq(DJ@FX_sz^nEiTE=OVu??)b(K)1=I_HuM$xvx+$q8sYL`r
zU7g|mQzm(v$g;^B&c0$-ag0-EVB_~=5aCy6V0i!Nzl>#A@r1Rfp0g<0MbBZ70?IJ(
z9|p?Y|08J@T+qAf_!CAs>xfqj>_8b|ehWs1_ji7Z83*KcEkE+`pR`42Jfk#!DTC1a
zo8N>De6!k@9K82i!Zc_tBL`5u5ZI1up9OTi(pwhpyZuAd$X|&`2B==}{pAn5TJ9;0
u^LF3(Dx~jIz{CkuFUa4<$nf;STP}5%#Jbr#u72Xz@!ZG6>BkTNPD=pD31yi8

literal 0
HcmV?d00001


From 9ae10c54e5e58ac699488213a9ea69500ebbfc5f Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Sat, 12 Sep 2026 09:12:13 +0530
Subject: [PATCH 13/42] verity: Generate partition FEC data

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 README.md                            |   1 +
 src/lib.rs                           |   2 +-
 src/verity.rs                        | 259 ++++++++++++++++++++++++++-
 tests/delta_extraction.rs            | 170 +++++++++++++++---
 tests/fixtures/fec/LICENSE           | 202 +++++++++++++++++++++
 tests/fixtures/fec/README.md         |  15 ++
 tests/fixtures/fec/SHA256SUMS        |   2 +
 tests/fixtures/fec/fec-300-block.bin | Bin 0 -> 16384 bytes
 tests/fixtures/fec/fec-one-block.bin |   1 +
 9 files changed, 624 insertions(+), 28 deletions(-)
 create mode 100644 tests/fixtures/fec/LICENSE
 create mode 100644 tests/fixtures/fec/README.md
 create mode 100644 tests/fixtures/fec/SHA256SUMS
 create mode 100644 tests/fixtures/fec/fec-300-block.bin
 create mode 100644 tests/fixtures/fec/fec-one-block.bin

diff --git a/README.md b/README.md
index 03dea2a..7063bff 100644
--- a/README.md
+++ b/README.md
@@ -109,6 +109,7 @@ otadump.extract(
 
 The optional keyword arguments are `num_threads`, `overwrite`, `partitions`, `verify`, and `source_dir`.
 Set `source_dir` to a directory containing matching base partition images for supported delta operations.
+Extraction generates declared dm-verity hash-tree and FEC extents before verifying each partition.
 Extraction releases the Python GIL.
 
 ## Contributors
diff --git a/src/lib.rs b/src/lib.rs
index abcd5e6..f2afd14 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -308,7 +308,7 @@ impl<'a> ExtractOptions<'a> {
                             error
                         } else {
                             error.context(format!(
-                                "Failed to generate hash tree for {:?}",
+                                "Failed to generate verity data for {:?}",
                                 update.partition_name
                             ))
                         }
diff --git a/src/verity.rs b/src/verity.rs
index e917adf..6708f5e 100644
--- a/src/verity.rs
+++ b/src/verity.rs
@@ -1,29 +1,59 @@
 use std::ops::Range;
 
-use anyhow::{Context as _, Result, bail, ensure};
+use anyhow::{Context as _, Result, ensure};
 use ring::digest;
 
 use crate::CancellationToken;
 use crate::chromeos_update_engine::{Extent, PartitionUpdate};
 
 const SHA256_SIZE: usize = 32;
+const FEC_BLOCK_SIZE: usize = 4096;
+const FEC_SYMBOLS: usize = 255;
 
 pub(crate) struct VerityConfig {
+    hash_tree: Option<HashTreeConfig>,
+    fec: Option<FecConfig>,
+}
+
+struct HashTreeConfig {
     data: Range<usize>,
     tree: Range<usize>,
     salt: Vec<u8>,
 }
 
+struct FecConfig {
+    data: Range<usize>,
+    storage: Range<usize>,
+    roots: usize,
+    rounds: usize,
+}
+
 pub(crate) fn validate(
     update: &PartitionUpdate,
     block_size: usize,
     partition_len: usize,
     operation_destinations: &[(Range<usize>, usize)],
 ) -> Result<Option<VerityConfig>> {
-    if extent_num_blocks(update.fec_extent.as_ref(), "FEC")?.unwrap_or(0) > 0 {
-        bail!("FEC generation is not supported for partition {:?}", update.partition_name);
+    let hash_tree = validate_hash_tree(update, block_size, partition_len, operation_destinations)?;
+    let fec = validate_fec(
+        update,
+        block_size,
+        partition_len,
+        operation_destinations,
+        hash_tree.as_ref(),
+    )?;
+    if hash_tree.is_none() && fec.is_none() {
+        return Ok(None);
     }
+    Ok(Some(VerityConfig { hash_tree, fec }))
+}
 
+fn validate_hash_tree(
+    update: &PartitionUpdate,
+    block_size: usize,
+    partition_len: usize,
+    operation_destinations: &[(Range<usize>, usize)],
+) -> Result<Option<HashTreeConfig>> {
     let data_blocks =
         extent_num_blocks(update.hash_tree_data_extent.as_ref(), "Hash tree data")?.unwrap_or(0);
     let tree_blocks =
@@ -76,7 +106,7 @@ pub(crate) fn validate(
         tree.len()
     );
 
-    Ok(Some(VerityConfig { data, tree, salt: update.hash_tree_salt.clone().unwrap_or_default() }))
+    Ok(Some(HashTreeConfig { data, tree, salt: update.hash_tree_salt.clone().unwrap_or_default() }))
 }
 
 pub(crate) fn generate(
@@ -84,6 +114,21 @@ pub(crate) fn generate(
     config: &VerityConfig,
     block_size: usize,
     cancellation_token: &CancellationToken,
+) -> Result<()> {
+    if let Some(hash_tree) = config.hash_tree.as_ref() {
+        generate_hash_tree(partition, hash_tree, block_size, cancellation_token)?;
+    }
+    if let Some(fec) = config.fec.as_ref() {
+        generate_fec(partition, fec, block_size, cancellation_token)?;
+    }
+    Ok(())
+}
+
+fn generate_hash_tree(
+    partition: &mut [u8],
+    config: &HashTreeConfig,
+    block_size: usize,
+    cancellation_token: &CancellationToken,
 ) -> Result<()> {
     cancellation_token.check()?;
     let hashes_per_block = block_size / SHA256_SIZE;
@@ -126,6 +171,206 @@ pub(crate) fn generate(
     cancellation_token.check()
 }
 
+fn validate_fec(
+    update: &PartitionUpdate,
+    block_size: usize,
+    partition_len: usize,
+    operation_destinations: &[(Range<usize>, usize)],
+    hash_tree: Option<&HashTreeConfig>,
+) -> Result<Option<FecConfig>> {
+    let data_blocks = extent_num_blocks(update.fec_data_extent.as_ref(), "FEC data")?.unwrap_or(0);
+    let storage_blocks = extent_num_blocks(update.fec_extent.as_ref(), "FEC")?.unwrap_or(0);
+    ensure!(
+        (data_blocks == 0) == (storage_blocks == 0),
+        "FEC data and storage extents must both be nonempty"
+    );
+    if storage_blocks == 0 {
+        return Ok(None);
+    }
+
+    ensure!(block_size == FEC_BLOCK_SIZE, "FEC requires 4096-byte blocks");
+    let roots =
+        usize::try_from(update.fec_roots.unwrap_or(2)).context("FEC roots are too large")?;
+    ensure!((1..FEC_SYMBOLS).contains(&roots), "FEC roots must be between 1 and 254");
+    let data = extent_range(
+        update.fec_data_extent.as_ref().context("FEC data extent is missing")?,
+        block_size,
+        partition_len,
+        "FEC data",
+    )?;
+    let storage = extent_range(
+        update.fec_extent.as_ref().context("FEC storage extent is missing")?,
+        block_size,
+        partition_len,
+        "FEC storage",
+    )?;
+    ensure!(storage.start >= data.end, "FEC storage extent must follow the protected data extent");
+    ensure!(
+        operation_destinations
+            .iter()
+            .all(|(destination, _)| !ranges_overlap(&storage, destination)),
+        "FEC storage extent overlaps destination extents"
+    );
+    if let Some(hash_tree) = hash_tree {
+        ensure!(
+            !ranges_overlap(&storage, &hash_tree.tree),
+            "FEC storage extent overlaps hash tree extent"
+        );
+        ensure!(
+            !ranges_overlap(&storage, &hash_tree.data),
+            "FEC storage extent overlaps hash tree data extent"
+        );
+    }
+
+    let rs_n = FEC_SYMBOLS - roots;
+    let rounds = div_ceil(data_blocks, rs_n)?;
+    let required_blocks = rounds.checked_mul(roots).context("FEC size overflow")?;
+    let required_size = required_blocks.checked_mul(block_size).context("FEC size overflow")?;
+    ensure!(
+        storage.len() == required_size,
+        "FEC size mismatch: expected {required_size} bytes, got {}",
+        storage.len()
+    );
+
+    Ok(Some(FecConfig { data, storage, roots, rounds }))
+}
+
+fn generate_fec(
+    partition: &mut [u8],
+    config: &FecConfig,
+    block_size: usize,
+    cancellation_token: &CancellationToken,
+) -> Result<()> {
+    cancellation_token.check()?;
+    let rs = ReedSolomon::new(config.roots)?;
+    let rs_n = FEC_SYMBOLS - config.roots;
+    let matrix_len = block_size.checked_mul(rs_n).context("FEC matrix size overflow")?;
+    let parity_len = block_size.checked_mul(config.roots).context("FEC parity size overflow")?;
+    let mut matrix = zeroed_buffer(matrix_len, "FEC matrix")?;
+    let mut parity = zeroed_buffer(parity_len, "FEC parity")?;
+    let data_blocks = config.data.len() / block_size;
+
+    for round in 0..config.rounds {
+        cancellation_token.check()?;
+        matrix.fill(0);
+        for symbol in 0..rs_n {
+            if symbol % 32 == 0 {
+                cancellation_token.check()?;
+            }
+            let block_index = symbol
+                .checked_mul(config.rounds)
+                .and_then(|value| value.checked_add(round))
+                .context("FEC interleave offset overflow")?;
+            if block_index >= data_blocks {
+                continue;
+            }
+            let source_start = config
+                .data
+                .start
+                .checked_add(
+                    block_index.checked_mul(block_size).context("FEC data offset overflow")?,
+                )
+                .context("FEC data offset overflow")?;
+            let source_end =
+                source_start.checked_add(block_size).context("FEC data end overflow")?;
+            let source = &partition[source_start..source_end];
+            for (byte_index, byte) in source.iter().copied().enumerate() {
+                matrix[byte_index * rs_n + symbol] = byte;
+            }
+        }
+
+        parity.fill(0);
+        for byte_index in 0..block_size {
+            if byte_index % 256 == 0 {
+                cancellation_token.check()?;
+            }
+            let data_start = byte_index * rs_n;
+            let parity_start = byte_index * config.roots;
+            rs.encode(
+                &matrix[data_start..data_start + rs_n],
+                &mut parity[parity_start..parity_start + config.roots],
+            );
+        }
+
+        cancellation_token.check()?;
+        let destination_start = config
+            .storage
+            .start
+            .checked_add(round.checked_mul(parity_len).context("FEC write offset overflow")?)
+            .context("FEC write offset overflow")?;
+        let destination_end =
+            destination_start.checked_add(parity_len).context("FEC write end overflow")?;
+        partition[destination_start..destination_end].copy_from_slice(&parity);
+    }
+    cancellation_token.check()
+}
+
+struct ReedSolomon {
+    alpha_to: [u8; FEC_SYMBOLS + 1],
+    index_of: [u8; FEC_SYMBOLS + 1],
+    generator: Vec<u8>,
+    roots: usize,
+}
+
+impl ReedSolomon {
+    fn new(roots: usize) -> Result<Self> {
+        let mut alpha_to = [0u8; FEC_SYMBOLS + 1];
+        let mut index_of = [0u8; FEC_SYMBOLS + 1];
+        index_of[0] = FEC_SYMBOLS as u8;
+        let mut symbol = 1u16;
+        for (exponent, alpha) in alpha_to.iter_mut().take(FEC_SYMBOLS).enumerate() {
+            index_of[usize::from(symbol)] = exponent as u8;
+            *alpha = symbol as u8;
+            symbol <<= 1;
+            if symbol & 0x100 != 0 {
+                symbol ^= 0x11d;
+            }
+            symbol &= 0xff;
+        }
+        ensure!(symbol == 1, "FEC field polynomial is not primitive");
+
+        let mut generator = zeroed_buffer(roots + 1, "FEC generator polynomial")?;
+        generator[0] = 1;
+        for root in 0..roots {
+            generator[root + 1] = 1;
+            for coefficient in (1..=root).rev() {
+                generator[coefficient] = if generator[coefficient] == 0 {
+                    generator[coefficient - 1]
+                } else {
+                    let exponent = usize::from(index_of[usize::from(generator[coefficient])]);
+                    generator[coefficient - 1] ^ alpha_to[(exponent + root) % FEC_SYMBOLS]
+                };
+            }
+            let exponent = usize::from(index_of[usize::from(generator[0])]);
+            generator[0] = alpha_to[(exponent + root) % FEC_SYMBOLS];
+        }
+        for coefficient in &mut generator {
+            *coefficient = index_of[usize::from(*coefficient)];
+        }
+        Ok(Self { alpha_to, index_of, generator, roots })
+    }
+
+    fn encode(&self, data: &[u8], parity: &mut [u8]) {
+        parity.fill(0);
+        for byte in data {
+            let feedback = usize::from(self.index_of[usize::from(*byte ^ parity[0])]);
+            if feedback != FEC_SYMBOLS {
+                for (index, parity_byte) in parity.iter_mut().enumerate().take(self.roots).skip(1) {
+                    let generator = usize::from(self.generator[self.roots - index]);
+                    *parity_byte ^= self.alpha_to[(feedback + generator) % FEC_SYMBOLS];
+                }
+            }
+            parity.copy_within(1..self.roots, 0);
+            parity[self.roots - 1] = if feedback == FEC_SYMBOLS {
+                0
+            } else {
+                let generator = usize::from(self.generator[0]);
+                self.alpha_to[(feedback + generator) % FEC_SYMBOLS]
+            };
+        }
+    }
+}
+
 fn extent_num_blocks(extent: Option<&Extent>, label: &str) -> Result<Option<usize>> {
     extent
         .map(|extent| {
@@ -169,8 +414,12 @@ fn div_ceil(value: usize, divisor: usize) -> Result<usize> {
 
 fn zeroed_level(blocks: usize, block_size: usize) -> Result<Vec<u8>> {
     let len = blocks.checked_mul(block_size).context("Hash tree level size overflow")?;
+    zeroed_buffer(len, "hash tree")
+}
+
+fn zeroed_buffer(len: usize, label: &str) -> Result<Vec<u8>> {
     let mut level = Vec::new();
-    level.try_reserve_exact(len).context("Unable to allocate hash tree")?;
+    level.try_reserve_exact(len).with_context(|| format!("Unable to allocate {label}"))?;
     level.resize(len, 0);
     Ok(level)
 }
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index 7ed104a..1e435a8 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -1336,37 +1336,163 @@ fn malformed_verity_layouts_fail_without_leaving_staging_files() {
 }
 
 #[test]
-fn fec_metadata_fails_explicitly_without_publishing_an_image() {
-    let temporary = TempDir::new().unwrap();
-    let output_dir = temporary.path().join("output");
-    let data = vec![0x5a; 128];
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(128),
-        minor_version: Some(6),
-        partitions: vec![PartitionUpdate {
+fn fec_extents_match_android_reference_vectors() {
+    for (blocks, fixture, roots) in
+        [(1usize, "fec-one-block.bin", None), (300usize, "fec-300-block.bin", Some(2))]
+    {
+        let temporary = TempDir::new().unwrap();
+        let output_dir = temporary.path().join("output");
+        let data = if blocks == 1 {
+            vec![1; 4096]
+        } else {
+            (0..blocks * 4096)
+                .map(|index| ((index % 4096) * 37 + (index / 4096) * 53 + 13) as u8)
+                .collect()
+        };
+        let fec = fs::read(Path::new("tests/fixtures/fec").join(fixture)).unwrap();
+        let mut target = data.clone();
+        target.extend_from_slice(&fec);
+        let manifest = DeltaArchiveManifest {
+            block_size: Some(4096),
+            minor_version: Some(6),
+            partitions: vec![PartitionUpdate {
+                partition_name: "vendor".into(),
+                new_partition_info: Some(partition_info(&target)),
+                operations: vec![InstallOperation {
+                    operation_type: 0,
+                    data_offset: Some(0),
+                    data_length: Some(data.len() as u64),
+                    dst_extents: vec![extent(0, blocks as u64)],
+                    ..Default::default()
+                }],
+                fec_data_extent: Some(extent(0, blocks as u64)),
+                fec_extent: Some(extent(blocks as u64, (fec.len() / 4096) as u64)),
+                fec_roots: roots,
+                ..Default::default()
+            }],
+        };
+        let payload = temporary.path().join("payload.bin");
+        write_payload(&payload, manifest, &data);
+
+        ExtractOptions::new().extract(&payload, &output_dir).unwrap();
+
+        assert_eq!(fs::read(output_dir.join("vendor.img")).unwrap(), target);
+        assert_eq!(fs::read_dir(&output_dir).unwrap().count(), 1);
+    }
+}
+
+#[test]
+fn malformed_fec_metadata_fails_without_publishing_an_image() {
+    for (
+        data_extent,
+        storage_extent,
+        roots,
+        partition_blocks,
+        operation_blocks,
+        hash_tree,
+        error,
+    ) in [
+        (Some(extent(0, 1)), None, Some(2), 3, 1, false, "FEC data and storage"),
+        (Some(extent(0, 1)), Some(extent(1, 2)), Some(0), 3, 1, false, "FEC roots"),
+        (Some(extent(0, 1)), Some(extent(1, 2)), Some(255), 3, 1, false, "FEC roots"),
+        (Some(extent(0, 1)), Some(extent(1, 1)), Some(2), 2, 1, false, "FEC size mismatch"),
+        (
+            Some(extent(0, 1)),
+            Some(extent(0, 2)),
+            Some(2),
+            2,
+            1,
+            false,
+            "FEC storage extent must follow",
+        ),
+        (
+            Some(extent(2, 1)),
+            Some(extent(0, 2)),
+            Some(2),
+            3,
+            1,
+            false,
+            "FEC storage extent must follow",
+        ),
+        (
+            Some(extent(0, 1)),
+            Some(extent(2, 2)),
+            Some(2),
+            3,
+            1,
+            false,
+            "FEC storage extent exceeds partition size",
+        ),
+        (
+            Some(extent(0, 1)),
+            Some(extent(1, 2)),
+            Some(2),
+            3,
+            3,
+            false,
+            "FEC storage extent overlaps destination extents",
+        ),
+        (
+            Some(extent(0, 1)),
+            Some(extent(1, 2)),
+            Some(2),
+            3,
+            1,
+            true,
+            "FEC storage extent overlaps hash tree extent",
+        ),
+        (
+            Some(extent(0, 1)),
+            Some(extent(1, 2)),
+            Some(2),
+            4,
+            1,
+            true,
+            "FEC storage extent overlaps hash tree data extent",
+        ),
+    ] {
+        let temporary = TempDir::new().unwrap();
+        let output_dir = temporary.path().join("output");
+        let data = vec![0x5a; operation_blocks * 4096];
+        let mut update = PartitionUpdate {
             partition_name: "vendor".into(),
-            new_partition_info: Some(partition_info(&vec![0; 256])),
+            new_partition_info: Some(partition_info(&vec![0; partition_blocks * 4096])),
             operations: vec![InstallOperation {
                 operation_type: 0,
                 data_offset: Some(0),
-                data_length: Some(128),
-                dst_extents: vec![extent(0, 1)],
+                data_length: Some(data.len() as u64),
+                dst_extents: vec![extent(0, operation_blocks as u64)],
                 ..Default::default()
             }],
-            fec_data_extent: Some(extent(0, 1)),
-            fec_extent: Some(extent(1, 1)),
-            fec_roots: Some(2),
+            fec_data_extent: data_extent,
+            fec_extent: storage_extent,
+            fec_roots: roots,
             ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, &data);
+        };
+        if hash_tree {
+            if partition_blocks == 4 {
+                update.hash_tree_data_extent = Some(extent(0, 3));
+                update.hash_tree_extent = Some(extent(3, 1));
+            } else {
+                update.hash_tree_data_extent = Some(extent(0, 1));
+                update.hash_tree_extent = Some(extent(1, 1));
+            }
+            update.hash_tree_algorithm = Some("sha256".into());
+        }
+        let manifest = DeltaArchiveManifest {
+            block_size: Some(4096),
+            minor_version: Some(6),
+            partitions: vec![update],
+        };
+        let payload = temporary.path().join("payload.bin");
+        write_payload(&payload, manifest, &data);
 
-    let error = ExtractOptions::new().extract(&payload, &output_dir).unwrap_err().to_string();
+        let actual = ExtractOptions::new().extract(&payload, &output_dir).unwrap_err().to_string();
 
-    assert!(error.contains("FEC generation is not supported"), "unexpected error: {error}");
-    assert!(!output_dir.join("vendor.img").exists());
-    assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
+        assert!(actual.contains(error), "unexpected error: {actual}");
+        assert!(!output_dir.join("vendor.img").exists());
+        assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
+    }
 }
 
 #[test]
diff --git a/tests/fixtures/fec/LICENSE b/tests/fixtures/fec/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/tests/fixtures/fec/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/tests/fixtures/fec/README.md b/tests/fixtures/fec/README.md
new file mode 100644
index 0000000..6eb73a2
--- /dev/null
+++ b/tests/fixtures/fec/README.md
@@ -0,0 +1,15 @@
+# dm-verity FEC fixtures
+
+These parity extents verify Android 17 dm-verity FEC generation.
+They use the Apache-2.0 license in `LICENSE`.
+
+`fec-one-block.bin` is the `FECTest` vector from AOSP `system/update_engine` commit `4591637f51644f5429f9e2fe589ab22b92f61842`.
+Its input is one 4,096-byte block filled with `0x01`, with two FEC roots.
+The output alternates `0x8e, 0x8f` for 8,192 bytes.
+
+`fec-300-block.bin` is a multi-round reference vector generated with AOSP `external/fec` commit `90857deb7973c0ca24c79b9c1809fc9667f32c4f`.
+Input byte `i` in block `b` is `(i * 37 + b * 53 + 13) mod 256`, so each block and interleaved round differ.
+The reference generator calls `init_rs_char(8, 0x11d, 0, 1, 2, 0)` and `encode_rs_char` with the interleaving from Android 17 `VerityWriterAndroid::EncodeFEC`.
+Only the generated parity bytes are included; no LGPL source is distributed.
+
+Run `sha256sum -c SHA256SUMS` from this directory.
diff --git a/tests/fixtures/fec/SHA256SUMS b/tests/fixtures/fec/SHA256SUMS
new file mode 100644
index 0000000..06ccfde
--- /dev/null
+++ b/tests/fixtures/fec/SHA256SUMS
@@ -0,0 +1,2 @@
+ee94e02ccf9b3e11fad2939dcf1e38cd1439b86436c457bf3dc42256811f1681  fec-one-block.bin
+75ca5f457bae225fcb8191f4ef8746743019c1eb4e330d1321f56b956441009a  fec-300-block.bin
diff --git a/tests/fixtures/fec/fec-300-block.bin b/tests/fixtures/fec/fec-300-block.bin
new file mode 100644
index 0000000000000000000000000000000000000000..b7fbe454aea0022a3a893b3b678a976ede71b782
GIT binary patch
literal 16384
zcmeI3jV}~n9LKw{s~tD5hoW@RC3liB&6t&!%4=~)C~v)ZiM+Ih8#`Te$(>|OGiKe`
zWycN2p(ym?CGyf1ZtRqo%4=~)DD-#KzJJ5B=Xrj=@Ava*_6d5$%&TyCyHjz{+$Epl
z=1V(0oY_I*pSd73zsFXx21?p@36JL!*Cfi2KkNO}1(wvPsa;0eGm<9iAbJZ+`Bwgd
zwM4x+Pdhu^X?BxSVsBSfJdNAO8QM6M_du;g=a<^c#z)pNV|U(XLVARFbma%ZZ(Pm{
zt8*~j_xhx#=1nrQJ2Wufx<I8{ZDUGNpGp~H+lm%%o6z&376S$){Q06fPgglBcQE$N
zW<Sr&U6JJKVRdXIt^ShWto{kJ`>nIgUg7u#G1V_-btOIY_l`DgvFfU6ea(CF-so*%
zcfO6NOrs!xU+JR1EHAXBd~B<C?DFocCDVER+Vi{nRhH`I*MikwWX)Pgr{}oeQpTbs
zjIZB`Sw|HtWvsJNkm!_8k3WgEec3OL=dGl)>lo=uo+VEbqJ;}YCr0iX-M^>Ncd4*Y
z=BCgo?MaB#>f_Sl<*DJ%Ee}^ZH(jhepm#h+w{41gPBhU?P6|9PTF>C9HVw;LYHvJQ
zs{SBWMQp9~<=8W2n#C>B3ishmMG?X4Q>(zT(`z+`#PG2-T$<r1tzrhQhs9B|r`V%2
z%ei-xCk=kmzcf6|K4RjcN+4#03y0PR0|F<ut^_x8y|mu77--xQKkW!1MpzUR9Bb@X
z8EUf)9vr(O=^bN(vdD#~ePRJMt{LZ#^T++i{m1){_aFa1{(sDWnEx>UWB$kfhy4%x
zKlXp*KgfTO{~`ZF{)_w<`9Jc1^grl-(Ep+TL;w3<^uK7AK^K5709^vQ1auMTBG6@^
z%Rm=`E(Bc)x)gLV=wi_2pvz$wz%GDY0=oou5$qz^Ww6U&7s4)tT?)Gtb}{VYf8Q?u
E3pP8s(f|Me

literal 0
HcmV?d00001

diff --git a/tests/fixtures/fec/fec-one-block.bin b/tests/fixtures/fec/fec-one-block.bin
new file mode 100644
index 0000000..59b361a
--- /dev/null
+++ b/tests/fixtures/fec/fec-one-block.bin
@@ -0,0 +1 @@
+Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�
\ No newline at end of file

From 849819ab1debafc26813ac299bd9f31b427f7b0b Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Sat, 12 Sep 2026 09:21:28 +0530
Subject: [PATCH 14/42] release: Verify native package artifacts

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 .github/workflows/release.yaml | 14 +++++-
 README.md                      |  8 ++++
 pyproject.toml                 | 11 +++++
 tests/python_smoke.py          | 86 +++++++++++++++++++++++++++++++++-
 4 files changed, 116 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index dad4e62..ad07844 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -128,7 +128,12 @@ jobs:
         if: runner.os != 'Windows'
         run: >
           tar -cv
-          LICENSE README.md src/puffin/LICENSE
+          LICENSE README.md src/puffin/LICENSE native/lz4/LICENSE
+          native/zucchini/vendor/zucchini/LICENSE
+          native/zucchini/vendor/libchrome/NOTICE
+          native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE
+          native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE
+          native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
           -C target/${{ matrix.target }}/release/ otadump
           | gzip --best
           > 'otadump-${{ steps.get_version.outputs.value }}-${{ matrix.target }}.tar.gz'
@@ -136,7 +141,12 @@ jobs:
         if: runner.os == 'Windows'
         run: >
           7z a 'otadump-${{ steps.get_version.outputs.value }}-${{ matrix.target }}.zip'
-          LICENSE README.md src/puffin/LICENSE
+          LICENSE README.md src/puffin/LICENSE native/lz4/LICENSE
+          native/zucchini/vendor/zucchini/LICENSE
+          native/zucchini/vendor/libchrome/NOTICE
+          native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE
+          native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE
+          native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
           ./target/${{ matrix.target }}/release/otadump.exe
       - name: Upload artifact
         uses: actions/upload-artifact@v4.6.0
diff --git a/README.md b/README.md
index 7063bff..ca99adb 100644
--- a/README.md
+++ b/README.md
@@ -112,6 +112,14 @@ Set `source_dir` to a directory containing matching base partition images for su
 Extraction generates declared dm-verity hash-tree and FEC extents before verifying each partition.
 Extraction releases the Python GIL.
 
+### Local release packages
+
+Build the Linux x86-64 GNU CLI with `cargo build --release --locked`.
+Build the ABI3 Python wheel with `uv build --wheel`.
+The wheel supports Python 3.9 and later and uses the build host's glibc baseline.
+Build release packages on the oldest Linux environment that you support.
+Release archives and wheels include the notices for vendored Puffin, LZ4, Zucchini, libchrome, ICU, and NSPR code.
+
 ## Contributors
 
 - [Kartik Sharma][crazystylus]
diff --git a/pyproject.toml b/pyproject.toml
index 717b81c..6749678 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -9,6 +9,16 @@ description = "Extract partitions from Android OTA files"
 readme = "README.md"
 requires-python = ">=3.9"
 license = "MIT"
+license-files = [
+    "LICENSE",
+    "src/puffin/LICENSE",
+    "native/lz4/LICENSE",
+    "native/zucchini/vendor/zucchini/LICENSE",
+    "native/zucchini/vendor/libchrome/NOTICE",
+    "native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE",
+    "native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE",
+    "native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt",
+]
 authors = [
     { name = "Kartik Sharma", email = "kartik.sharma522@gmail.com" },
     { name = "Ajeet D'Souza", email = "98ajeet@gmail.com" },
@@ -20,3 +30,4 @@ classifiers = [
 
 [tool.maturin]
 features = ["python"]
+locked = true
diff --git a/tests/python_smoke.py b/tests/python_smoke.py
index 4997436..7e23501 100644
--- a/tests/python_smoke.py
+++ b/tests/python_smoke.py
@@ -1,10 +1,64 @@
+from hashlib import sha256
 from inspect import signature
 from pathlib import Path
 from tempfile import TemporaryDirectory
+from typing import Optional
 
 import otadump
 
 
+def _varint(value: int) -> bytes:
+    encoded = bytearray()
+    while value >= 0x80:
+        encoded.append((value & 0x7F) | 0x80)
+        value >>= 7
+    encoded.append(value)
+    return bytes(encoded)
+
+
+def _integer(field: int, value: int) -> bytes:
+    return _varint(field << 3) + _varint(value)
+
+
+def _bytes(field: int, value: bytes) -> bytes:
+    return _varint((field << 3) | 2) + _varint(len(value)) + value
+
+
+def _extent(length: int) -> bytes:
+    return _integer(1, 0) + _integer(2, length)
+
+
+def _partition_info(data: bytes) -> bytes:
+    return _integer(1, len(data)) + _bytes(2, sha256(data).digest())
+
+
+def _payload(target: bytes, source: Optional[bytes] = None) -> bytes:
+    operation_type = 0 if source is None else 4
+    operation = _integer(1, operation_type)
+    if source is None:
+        operation += _integer(2, 0) + _integer(3, len(target))
+        operation += _bytes(8, sha256(target).digest())
+    else:
+        operation += _bytes(4, _extent(len(source))) + _integer(5, len(source))
+        operation += _bytes(9, sha256(source).digest())
+    operation += _bytes(6, _extent(len(target))) + _integer(7, len(target))
+
+    partition = _bytes(1, b"system")
+    if source is not None:
+        partition += _bytes(6, _partition_info(source))
+    partition += _bytes(7, _partition_info(target)) + _bytes(8, operation)
+    manifest = _integer(3, 1) + _bytes(13, partition)
+    operation_data = target if source is None else b""
+    return (
+        b"CrAU"
+        + (2).to_bytes(8, "big")
+        + len(manifest).to_bytes(8, "big")
+        + bytes(4)
+        + manifest
+        + operation_data
+    )
+
+
 def main() -> None:
     assert issubclass(otadump.OtaDumpError, Exception)
     extract_signature = str(signature(otadump.extract))
@@ -13,6 +67,36 @@ def main() -> None:
 
     with TemporaryDirectory() as temporary_directory:
         temporary_path = Path(temporary_directory)
+        full_target = b"full partition image"
+        full_payload = temporary_path / "full.bin"
+        full_payload.write_bytes(_payload(full_target))
+        full_output = temporary_path / "full-output"
+        otadump.extract(full_payload, full_output)
+        assert (full_output / "system.img").read_bytes() == full_target
+
+        source = b"source partition image"
+        source_dir = temporary_path / "source"
+        source_dir.mkdir()
+        source_image = source_dir / "system.img"
+        source_image.write_bytes(source)
+        delta_payload = temporary_path / "delta.bin"
+        delta_payload.write_bytes(_payload(source, source))
+        delta_output = temporary_path / "delta-output"
+        otadump.extract(delta_payload, delta_output, source_dir=source_dir)
+        assert (delta_output / "system.img").read_bytes() == source
+        assert source_image.read_bytes() == source
+
+        try:
+            otadump.extract(
+                delta_payload,
+                temporary_path / "missing-source-output",
+                source_dir=temporary_path / "missing-source",
+            )
+        except otadump.OtaDumpError as error:
+            assert "Unable to open source partition image" in str(error)
+        else:
+            raise AssertionError("missing source image unexpectedly succeeded")
+
         payload_file = temporary_path / "invalid.bin"
         payload_file.write_bytes(b"invalid")
 
@@ -29,7 +113,7 @@ def main() -> None:
         cancelled_output = temporary_path / "cancelled-output"
         try:
             otadump.extract(
-                payload_file,
+                full_payload,
                 cancelled_output,
                 cancellation_token=cancellation_token,
             )

From 45b23da7c43afafc4e18977302361c5a15e61009 Mon Sep 17 00:00:00 2001
From: Omkar Chandorkar <gotenksIN@aospa.co>
Date: Sat, 12 Sep 2026 10:36:36 +0530
Subject: [PATCH 15/42] bsdiff: Preserve Android source semantics

Signed-off-by: Omkar Chandorkar <gotenksIN@aospa.co>
---
 src/lib.rs                | 127 ++++++++++++++++++++++++++++++++++----
 src/lz4.rs                |  53 ++++++++++------
 src/lz4diff.rs            |  32 +++-------
 src/puffin/patch.rs       |  24 ++++---
 tests/delta_extraction.rs |  75 ++++++++++++++++++++++
 5 files changed, 243 insertions(+), 68 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index f2afd14..6c2230f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -25,7 +25,7 @@ use std::{error, result, slice, thread};
 
 use anyhow::{Context as _, Error, Result, bail, ensure};
 use brotli::Decompressor as BrotliDecoder;
-use bsdiff_android::patch_bsdf2;
+use bsdiff_android::parse_bsdf2_header;
 use bzip2::read::BzDecoder;
 use chromeos_update_engine::install_operation::Type;
 use chromeos_update_engine::{DeltaArchiveManifest, InstallOperation, PartitionUpdate};
@@ -956,18 +956,14 @@ impl Task<'_> {
         let expected_output_len = dst_extents.iter().try_fold(0usize, |len, extent| {
             len.checked_add(extent.len()).context("Combined destination length overflow")
         })?;
-        validate_bsdiff_output_len(patch, expected_output_len)
-            .map_err(|error| anyhow::anyhow!("{operation} patch is invalid: {error}"))?;
-        self.cancellation_token.check()?;
-        puffin::validate_bsdiff_resources(patch, expected_output_len, self.cancellation_token)
-            .map_err(|error| anyhow::anyhow!("{operation} patch is invalid: {error}"))?;
-        self.cancellation_token.check()?;
-        let mut output = Vec::new();
-        output
-            .try_reserve_exact(expected_output_len)
-            .context("Unable to allocate patched output buffer")?;
-        patch_bsdf2(&source, patch, &mut output)
-            .map_err(|error| anyhow::anyhow!("{operation} patch is invalid: {error}"))?;
+        let output = apply_bsdiff(&source, patch, expected_output_len, self.cancellation_token)
+            .map_err(|error| {
+                if is_cancellation(error.as_ref()) {
+                    error
+                } else {
+                    anyhow::anyhow!("{operation} patch is invalid: {error}")
+                }
+            })?;
         self.cancellation_token.check()?;
         self.write_exact(&output, dst_extents)
     }
@@ -1255,6 +1251,111 @@ fn validate_bsdiff_output_len(patch: &[u8], expected: usize) -> Result<()> {
     Ok(())
 }
 
+#[inline]
+fn offtin(buf: [u8; 8]) -> i64 {
+    let y = i64::from_le_bytes(buf);
+    if 0 == y & (1 << 63) { y } else { -(y & !(1 << 63)) }
+}
+
+pub(crate) fn apply_bsdiff(
+    source: &[u8],
+    patch: &[u8],
+    expected_output_len: usize,
+    cancellation_token: &CancellationToken,
+) -> Result<Vec<u8>> {
+    validate_bsdiff_output_len(patch, expected_output_len)?;
+    cancellation_token.check()?;
+    puffin::validate_bsdiff_resources(patch, expected_output_len, cancellation_token)?;
+    cancellation_token.check()?;
+
+    let (new_size, control_data, diff_data, extra_data) =
+        parse_bsdf2_header(patch).map_err(|error| anyhow::anyhow!("{error}"))?;
+    let new_size = usize::try_from(new_size).context("Patch new_size is negative or overflows")?;
+    ensure!(
+        new_size == expected_output_len,
+        "Patch output length mismatch: expected {expected_output_len}, got {new_size}"
+    );
+
+    let mut output = Vec::new();
+    output
+        .try_reserve_exact(expected_output_len)
+        .context("Unable to allocate patched output buffer")?;
+
+    ensure!(control_data.len() % 24 == 0, "Invalid control data length (not a multiple of 24)");
+    let mut oldpos: i64 = 0;
+    let mut diff_pos: usize = 0;
+    let mut extra_pos: usize = 0;
+
+    for chunk in control_data.chunks_exact(24) {
+        cancellation_token.check()?;
+        let add_len = offtin(chunk[0..8].try_into().unwrap());
+        let copy_len = offtin(chunk[8..16].try_into().unwrap());
+        let seek_amount = offtin(chunk[16..24].try_into().unwrap());
+
+        ensure!(
+            add_len >= 0 && copy_len >= 0,
+            "Negative length in control tuple: add={add_len}, copy={copy_len}"
+        );
+        let add_len = usize::try_from(add_len).context("Control tuple add_len overflow")?;
+        let copy_len = usize::try_from(copy_len).context("Control tuple copy_len overflow")?;
+
+        let pending_len = add_len.checked_add(copy_len).context("Control tuple length overflow")?;
+        let target_len =
+            output.len().checked_add(pending_len).context("Patched output length overflow")?;
+        ensure!(
+            target_len <= expected_output_len,
+            "Control tuple would exceed expected output size"
+        );
+
+        if add_len > 0 {
+            let diff_end = diff_pos.checked_add(add_len).context("Diff stream offset overflow")?;
+            let diff_chunk = diff_data.get(diff_pos..diff_end).context("Diff stream exhausted")?;
+            for (i, &diff_byte) in diff_chunk.iter().enumerate() {
+                let offset = i64::try_from(i).context("Diff offset overflow")?;
+                let src_pos = oldpos.checked_add(offset).context("Source position overflow")?;
+                let old_byte = match usize::try_from(src_pos) {
+                    Ok(pos) if pos < source.len() => source[pos],
+                    _ => 0u8,
+                };
+                output.push(old_byte.wrapping_add(diff_byte));
+            }
+            let add_i64 = i64::try_from(add_len).context("Source position overflow")?;
+            oldpos = oldpos.checked_add(add_i64).context("Source position overflow")?;
+            diff_pos = diff_end;
+        }
+
+        if copy_len > 0 {
+            let extra_end =
+                extra_pos.checked_add(copy_len).context("Extra stream offset overflow")?;
+            let extra_chunk =
+                extra_data.get(extra_pos..extra_end).context("Extra stream exhausted")?;
+            output.extend_from_slice(extra_chunk);
+            extra_pos = extra_end;
+        }
+
+        oldpos = oldpos.checked_add(seek_amount).context("Source position overflow")?;
+    }
+
+    cancellation_token.check()?;
+    ensure!(
+        output.len() == expected_output_len,
+        "Patched output size mismatch: expected {expected_output_len}, got {}",
+        output.len()
+    );
+    ensure!(
+        diff_pos == diff_data.len(),
+        "Diff stream not fully consumed: used {diff_pos}/{}",
+        diff_data.len()
+    );
+    ensure!(
+        extra_pos == extra_data.len(),
+        "Extra stream not fully consumed: used {extra_pos}/{}",
+        extra_data.len()
+    );
+
+    Ok(output)
+}
+
 pub trait ProgressReporter: Sync {
     /// Reports the progress of the extraction process. The progress is provided
     /// as a value between 0 and 1.
diff --git a/src/lz4.rs b/src/lz4.rs
index 6655ba3..785ea0c 100644
--- a/src/lz4.rs
+++ b/src/lz4.rs
@@ -64,7 +64,7 @@ pub fn decompress_safe_partial(input: &[u8], output_size: usize) -> Result<Vec<u
 /// The returned buffer always has `output_size` bytes. Short compressed output
 /// receives leading zeros when `zero_padding` is true and trailing zeros otherwise.
 pub fn compress_dest_size(input: &[u8], output_size: usize, zero_padding: bool) -> Result<Vec<u8>> {
-    compress(input, input.len(), output_size, zero_padding, None)
+    compress(input, Some(input.len()), output_size, zero_padding, None)
 }
 
 /// Compresses one complete block with the metadata-selected LZ4HC level.
@@ -79,12 +79,12 @@ pub fn compress_hc_dest_size(
             "LZ4HC compression level must be in {HC_LEVEL_MIN}..={HC_LEVEL_MAX}"
         )));
     }
-    compress(input, input.len(), output_size, zero_padding, Some(compression_level))
+    compress(input, Some(input.len()), output_size, zero_padding, Some(compression_level))
 }
 
 pub(crate) fn compress_dest_size_partial(
     input: &[u8],
-    source_size: usize,
+    raw_block_size: usize,
     output_size: usize,
     compression_level: Option<i32>,
     zero_padding: bool,
@@ -96,35 +96,53 @@ pub(crate) fn compress_dest_size_partial(
             "LZ4HC compression level must be in {HC_LEVEL_MIN}..={HC_LEVEL_MAX}"
         )));
     }
-    compress(input, source_size, output_size, zero_padding, compression_level)
+    if raw_block_size == 0 || raw_block_size > input.len() {
+        return Err(invalid_argument("LZ4 source consumption size is invalid"));
+    }
+    if output_size >= raw_block_size {
+        return Err(invalid_argument("stored LZ4 block must be smaller than its raw block"));
+    }
+    compress(input, None, output_size, zero_padding, compression_level)
 }
 
 fn compress(
     input: &[u8],
-    source_size: usize,
+    expected_source_size: Option<usize>,
     output_size: usize,
     zero_padding: bool,
     compression_level: Option<i32>,
 ) -> Result<Vec<u8>> {
     ensure_supported()?;
     validate_sizes(input.len(), output_size)?;
-    if source_size == 0 || source_size > input.len() {
-        return Err(invalid_argument("LZ4 source consumption size is invalid"));
-    }
-    if output_size >= source_size {
+    if let Some(expected) = expected_source_size {
+        if expected == 0 || expected > input.len() {
+            return Err(invalid_argument("LZ4 source consumption size is invalid"));
+        }
+        if output_size >= expected {
+            return Err(invalid_argument("stored LZ4 block must be smaller than its raw block"));
+        }
+    } else if output_size >= input.len() {
         return Err(invalid_argument("stored LZ4 block must be smaller than its raw block"));
     }
     let mut output = allocate_output(output_size, "compression")?;
     let result = compress_native(input, &mut output, compression_level)?;
-    if result.source_size != source_size {
+    if result.source_size == 0 || result.source_size > input.len() {
         return Err(Error {
-            status: Status::CompressionDivergence,
-            message: format!(
-                "LZ4 compression consumed {} of {} source bytes",
-                result.source_size, source_size
-            ),
+            status: Status::CompressionFailed,
+            message: "LZ4 compression consumed invalid source bytes".into(),
         });
     }
+    if let Some(expected) = expected_source_size {
+        if result.source_size != expected {
+            return Err(Error {
+                status: Status::CompressionDivergence,
+                message: format!(
+                    "LZ4 compression consumed {} of {} source bytes",
+                    result.source_size, expected
+                ),
+            });
+        }
+    }
     if result.output_size == 0 || result.output_size > output_size {
         return Err(Error {
             status: Status::CompressionDivergence,
@@ -499,9 +517,4 @@ mod tests {
                 || error.status() == Status::CompressionFailed
         );
     }
-
-    #[test]
-    fn unsupported_target_status() {
-        assert_eq!(unsupported_target().status(), Status::UnsupportedTarget);
-    }
 }
diff --git a/src/lz4diff.rs b/src/lz4diff.rs
index 35eceee..54caea0 100644
--- a/src/lz4diff.rs
+++ b/src/lz4diff.rs
@@ -2,11 +2,12 @@
 // SPDX-License-Identifier: MIT
 
 use anyhow::{Context as _, Result, bail, ensure};
-use bsdiff_android::patch_bsdf2;
 use prost::Message as _;
 use ring::digest;
 
-use crate::{CancellationToken, lz4, puffin, validate_bsdiff_output_len, zucchini};
+use crate::{
+    CancellationToken, is_cancellation, lz4, puffin, validate_bsdiff_output_len, zucchini,
+};
 
 const MAGIC: &[u8; 7] = b"LZ4DIFF";
 const FRAMING_SIZE: usize = 16;
@@ -580,26 +581,13 @@ fn apply_bsdiff(
     label: &str,
     cancellation_token: &CancellationToken,
 ) -> Result<Vec<u8>> {
-    validate_bsdiff_output_len(patch, output_size)
-        .with_context(|| format!("LZ4DIFF {label} patch is invalid"))?;
-    cancellation_token.check()?;
-    puffin::validate_bsdiff_resources(patch, output_size, cancellation_token).map_err(|error| {
-        preserve_puffin_error(error, &format!("LZ4DIFF {label} patch is invalid"))
-    })?;
-    cancellation_token.check()?;
-    let mut output = Vec::new();
-    output
-        .try_reserve_exact(output_size)
-        .with_context(|| format!("unable to allocate LZ4DIFF {label} output"))?;
-    patch_bsdf2(source, patch, &mut output)
-        .with_context(|| format!("LZ4DIFF {label} patch is invalid"))?;
-    cancellation_token.check()?;
-    ensure!(
-        output.len() == output_size,
-        "LZ4DIFF {label} output size mismatch: expected {output_size}, got {}",
-        output.len()
-    );
-    Ok(output)
+    crate::apply_bsdiff(source, patch, output_size, cancellation_token).map_err(|error| {
+        if is_cancellation(error.as_ref()) {
+            error
+        } else {
+            anyhow::anyhow!("LZ4DIFF {label} patch is invalid: {error}")
+        }
+    })
 }
 
 fn preserve_puffin_error(error: puffin::Error, context: &str) -> anyhow::Error {
diff --git a/src/puffin/patch.rs b/src/puffin/patch.rs
index fdc4c2a..ef51767 100644
--- a/src/puffin/patch.rs
+++ b/src/puffin/patch.rs
@@ -11,8 +11,7 @@ use bzip2::read::BzDecoder;
 
 use crate::puffin::{BitExtent, ByteExtent, Error, Result, check_cancelled, stream};
 use crate::{
-    CancellationToken, ExtractionCancelled, decode_zucchini_patch, is_cancellation,
-    validate_bsdiff_output_len, zucchini,
+    CancellationToken, ExtractionCancelled, decode_zucchini_patch, is_cancellation, zucchini,
 };
 
 const MAGIC: &[u8; 4] = b"PUF1";
@@ -498,20 +497,19 @@ pub fn apply(
 
     check_cancelled(cancellation_token)?;
     let puffed_destination = if header.patch_type == PATCH_TYPE_BSDIFF {
-        validate_bsdiff_output_len(raw_patch, header.destination.puff_length)
-            .map_err(|error| Error::Bsdiff(error.to_string()))?;
-        validate_inner_bsdiff_resources(
+        crate::apply_bsdiff(
+            &puffed_source,
             raw_patch,
             header.destination.puff_length,
             cancellation_token,
-        )?;
-        let mut destination = Vec::new();
-        destination
-            .try_reserve_exact(header.destination.puff_length)
-            .map_err(|error| Error::Allocation(format!("puffed destination: {error}")))?;
-        bsdiff_android::patch_bsdf2(&puffed_source, raw_patch, &mut destination)
-            .map_err(|error| Error::Bsdiff(error.to_string()))?;
-        destination
+        )
+        .map_err(|error| {
+            if is_cancellation(error.as_ref()) {
+                Error::Cancelled(ExtractionCancelled)
+            } else {
+                Error::Bsdiff(error.to_string())
+            }
+        })?
     } else {
         let zucchini_patch =
             decode_zucchini_patch(raw_patch, cancellation_token).map_err(|error| {
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index 1e435a8..45e1166 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -856,6 +856,81 @@ fn brotli_bsdiff_reconstructs_bsdf2_without_modifying_source() {
     assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
 }
 
+#[test]
+fn uncompressed_bsdf2_negative_seek_adds_diff_byte() {
+    let mut patch = Vec::new();
+    // BSDF2 magic + uncompressed flags (0 for control, diff, extra)
+    patch.extend_from_slice(b"BSDF2\x00\x00\x00");
+    patch.extend_from_slice(&72u64.to_le_bytes()); // control stream len: 3 tuples * 24
+    patch.extend_from_slice(&3u64.to_le_bytes()); // diff stream len: 3
+    patch.extend_from_slice(&3u64.to_le_bytes()); // new_size: 3
+
+    // Tuple 1: add=1, copy=0, seek=-2 (in-bounds source addition at oldpos=0; seek to -1)
+    patch.extend_from_slice(&1u64.to_le_bytes());
+    patch.extend_from_slice(&0u64.to_le_bytes());
+    let seek_neg2: u64 = 2 | (1 << 63); // offtin sign-magnitude -2
+    patch.extend_from_slice(&seek_neg2.to_le_bytes());
+
+    // Tuple 2: add=1, copy=0, seek=10 (negative oldpos=-1 treated as zero; seek to 10)
+    patch.extend_from_slice(&1u64.to_le_bytes());
+    patch.extend_from_slice(&0u64.to_le_bytes());
+    patch.extend_from_slice(&10u64.to_le_bytes());
+
+    // Tuple 3: add=1, copy=0, seek=0 (out-of-range oldpos=10 treated as zero)
+    patch.extend_from_slice(&1u64.to_le_bytes());
+    patch.extend_from_slice(&0u64.to_le_bytes());
+    patch.extend_from_slice(&0u64.to_le_bytes());
+
+    // Diff stream: 3 bytes
+    let diff_byte1: u8 = 0x01;
+    let diff_byte2: u8 = 0x42;
+    let diff_byte3: u8 = 0x24;
+    patch.push(diff_byte1);
+    patch.push(diff_byte2);
+    patch.push(diff_byte3);
+
+    let temporary = TempDir::new().unwrap();
+    let source_dir = temporary.path().join("source");
+    let output_dir = temporary.path().join("output");
+    fs::create_dir(&source_dir).unwrap();
+    let source = b"Z";
+    fs::write(source_dir.join("system.img"), source).unwrap();
+
+    let expected = [b'Z'.wrapping_add(diff_byte1), diff_byte2, diff_byte3];
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(1),
+        minor_version: Some(4),
+        partitions: vec![PartitionUpdate {
+            partition_name: "system".into(),
+            old_partition_info: Some(partition_info(source)),
+            new_partition_info: Some(partition_info(&expected)),
+            operations: vec![InstallOperation {
+                operation_type: 5, // SOURCE_BSDIFF
+                data_offset: Some(0),
+                data_length: Some(patch.len() as u64),
+                src_extents: vec![extent(0, source.len() as u64)],
+                src_length: Some(source.len() as u64),
+                dst_extents: vec![extent(0, expected.len() as u64)],
+                dst_length: Some(expected.len() as u64),
+                data_sha256_hash: Some(sha256(&patch)),
+                src_sha256_hash: Some(sha256(source)),
+            }],
+            ..Default::default()
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, &patch);
+
+    ExtractOptions::new()
+        .source_dir(&source_dir)
+        .num_threads(1)
+        .extract(&payload, &output_dir)
+        .unwrap();
+
+    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), expected);
+    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
+}
+
 #[test]
 fn malformed_bsdiff_headers_fail_cleanly_and_remove_staging() {
     for (operation_type, patch, expected_error) in [

From a736d51f8518b101ca9b4a86a734abcd29533148 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 17:32:56 +0530
Subject: [PATCH 16/42] zucchini: pure-Rust apply engine with NoOp + ELF
 support

Add an independent, C++/libchrome-free port of the Zucchini apply path.

- Ensemble patch parsing (varints, streams, validation) matching patch_reader.cc
- OffsetMapper, TargetPool, equivalence/extra-data/raw-delta application
- ELF x86/x86-64/AArch32/AArch64 disassembler: ELF parsing, address
  translation, abs32/rel32 relocation and ARM instruction codecs
- Byte-exact on the noop, elf-x86, elf, elf-arm32 and elf-arm64 fixtures

DEX remains a documented follow-up.
---
 src/lib.rs                  |    1 +
 src/zucchini_pure/arm.rs    |  505 +++++++++++++++
 src/zucchini_pure/bytes.rs  |   96 +++
 src/zucchini_pure/crc32.rs  |   34 +
 src/zucchini_pure/dex.rs    |   31 +
 src/zucchini_pure/elf.rs    | 1225 +++++++++++++++++++++++++++++++++++
 src/zucchini_pure/engine.rs |  426 ++++++++++++
 src/zucchini_pure/mod.rs    |  173 +++++
 src/zucchini_pure/patch.rs  |  474 ++++++++++++++
 9 files changed, 2965 insertions(+)
 create mode 100644 src/zucchini_pure/arm.rs
 create mode 100644 src/zucchini_pure/bytes.rs
 create mode 100644 src/zucchini_pure/crc32.rs
 create mode 100644 src/zucchini_pure/dex.rs
 create mode 100644 src/zucchini_pure/elf.rs
 create mode 100644 src/zucchini_pure/engine.rs
 create mode 100644 src/zucchini_pure/mod.rs
 create mode 100644 src/zucchini_pure/patch.rs

diff --git a/src/lib.rs b/src/lib.rs
index 6c2230f..4e28bed 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -11,6 +11,7 @@ mod puffin;
 mod python;
 mod verity;
 pub mod zucchini;
+pub mod zucchini_pure;
 
 use std::cmp::Reverse;
 use std::collections::HashSet;
diff --git a/src/zucchini_pure/arm.rs b/src/zucchini_pure/arm.rs
new file mode 100644
index 0000000..60023c7
--- /dev/null
+++ b/src/zucchini_pure/arm.rs
@@ -0,0 +1,505 @@
+//! Ports of `arm_utils.cc`: AArch32 (ARM/THUMB2) and AArch64 rel32 codecs.
+
+use super::bytes::sign_extend_u32;
+use super::bytes::{get_signed_bits_u32, get_unsigned_bits_u32, signed_fit};
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ArmAlign {
+    Fail = 0,
+    Align2 = 2,
+    Align4 = 4,
+}
+
+#[inline]
+fn bit(value: u32, pos: u32) -> u32 {
+    (value >> pos) & 1
+}
+
+#[inline]
+fn unsigned_bits(value: u32, lo: u32, hi: u32) -> u32 {
+    get_unsigned_bits_u32(value, lo, hi)
+}
+
+#[inline]
+fn signed_bits(value: u32, lo: u32, hi: u32) -> i32 {
+    get_signed_bits_u32(value, lo, hi)
+}
+
+#[inline]
+fn signed_bits_u16(value: u16, lo: u32, hi: u32) -> i32 {
+    // `GetSignedBits` on a 16-bit value.
+    let num_bits = 16i32;
+    let shift = num_bits - 1 - hi as i32;
+    ((i32::from(value) << shift) << 0) >> (shift + lo as i32)
+}
+
+#[inline]
+fn is_misaligned(rva: u32, align: ArmAlign) -> bool {
+    (rva & (align as u32 - 1)) != 0
+}
+
+pub fn fetch_arm_code32(image: &[u8], offset: u32) -> u32 {
+    super::bytes::read_u32(image, offset as usize).unwrap_or(0)
+}
+
+pub fn fetch_thumb2_code16(image: &[u8], offset: u32) -> u16 {
+    super::bytes::read_u16(image, offset as usize).unwrap_or(0)
+}
+
+pub fn fetch_thumb2_code32(image: &[u8], offset: u32) -> u32 {
+    let hi = super::bytes::read_u16(image, offset as usize).unwrap_or(0) as u32;
+    let lo = super::bytes::read_u16(image, offset as usize + 2).unwrap_or(0) as u32;
+    (hi << 16) | lo
+}
+
+pub fn store_arm_code32(image: &mut [u8], offset: u32, code: u32) {
+    let _ = super::bytes::write_u32(image, offset as usize, code);
+}
+
+pub fn store_thumb2_code16(image: &mut [u8], offset: u32, code: u16) {
+    let _ = super::bytes::write_u16(image, offset as usize, code);
+}
+
+pub fn store_thumb2_code32(image: &mut [u8], offset: u32, code: u32) {
+    let _ = super::bytes::write_u16(image, offset as usize, (code >> 16) as u16);
+    let _ = super::bytes::write_u16(image, offset as usize + 2, (code & 0xFFFF) as u16);
+}
+
+pub fn get_thumb2_instruction_size(code16: u16) -> u32 {
+    if (code16 & 0xF000) == 0xF000 || (code16 & 0xF800) == 0xE800 {
+        4
+    } else {
+        2
+    }
+}
+
+/// Mirrors `AArch32Rel32Translator::DecodeA24`.
+pub fn decode_a24(code32: u32) -> (ArmAlign, i32) {
+    let bits = unsigned_bits(code32, 24, 27);
+    if bits == 0xA || bits == 0xB {
+        let mut disp = signed_bits(code32, 0, 23) << 2;
+        let cond = unsigned_bits(code32, 28, 31);
+        if cond == 0xF {
+            let h = bit(code32, 24);
+            disp |= (h << 1) as i32;
+            return (ArmAlign::Align2, disp);
+        }
+        return (ArmAlign::Align4, disp);
+    }
+    (ArmAlign::Fail, 0)
+}
+
+/// Mirrors `AArch32Rel32Translator::EncodeA24`.
+pub fn encode_a24(disp: i32, code32: &mut u32) -> bool {
+    let mut t = *code32;
+    let bits = unsigned_bits(t, 24, 27);
+    if bits == 0xA || bits == 0xB {
+        if !signed_fit(disp, 26) {
+            return false;
+        }
+        let cond = unsigned_bits(t, 28, 31);
+        if cond == 0xF {
+            if disp % 2 != 0 {
+                return false;
+            }
+            let h = bit(disp as u32, 1);
+            t = (t & 0xFEFF_FFFF) | (h << 24);
+        } else if disp % 4 != 0 {
+            return false;
+        }
+        t = (t & 0xFF00_0000) | (((disp >> 2) as u32) & 0x00FF_FFFF);
+        *code32 = t;
+        return true;
+    }
+    false
+}
+
+fn get_arm_target_rva_from_disp(instr_rva: u32, disp: i32, align: ArmAlign) -> u32 {
+    let ret = instr_rva.wrapping_add(8).wrapping_add(disp as u32);
+    ret - (ret & (align as u32 - 1))
+}
+
+fn get_thumb2_target_rva_from_disp(instr_rva: u32, disp: i32, align: ArmAlign) -> u32 {
+    let ret = instr_rva.wrapping_add(4).wrapping_add(disp as u32);
+    ret - (ret & (align as u32 - 1))
+}
+
+fn get_arm_disp_from_target_rva(instr_rva: u32, target_rva: u32, align: ArmAlign) -> i32 {
+    let ret = target_rva as i32 - instr_rva.wrapping_add(8) as i32;
+    ret + ((-ret) & (align as i32 - 1))
+}
+
+fn get_thumb2_disp_from_target_rva(instr_rva: u32, target_rva: u32, align: ArmAlign) -> i32 {
+    let ret = target_rva as i32 - instr_rva.wrapping_add(4) as i32;
+    ret + ((-ret) & (align as i32 - 1))
+}
+
+pub fn read_a24(instr_rva: u32, code32: u32) -> Option<u32> {
+    if is_misaligned(instr_rva, ArmAlign::Align4) {
+        return None;
+    }
+    let (align, disp) = decode_a24(code32);
+    if align == ArmAlign::Fail {
+        return None;
+    }
+    Some(get_arm_target_rva_from_disp(instr_rva, disp, align))
+}
+
+pub fn write_a24(instr_rva: u32, target_rva: u32, code32: &mut u32) -> bool {
+    if is_misaligned(instr_rva, ArmAlign::Align4) {
+        return false;
+    }
+    let (align, _) = decode_a24(*code32);
+    if align == ArmAlign::Fail || is_misaligned(target_rva, align) {
+        return false;
+    }
+    let disp = get_arm_disp_from_target_rva(instr_rva, target_rva, align);
+    encode_a24(disp, code32)
+}
+
+pub fn decode_t8(code16: u16) -> (ArmAlign, i32) {
+    if (code16 & 0xF000) == 0xD000 && (code16 & 0x0F00) != 0x0F00 {
+        return (ArmAlign::Align2, signed_bits_u16(code16, 0, 7) << 1);
+    }
+    (ArmAlign::Fail, 0)
+}
+
+pub fn encode_t8(disp: i32, code16: &mut u16) -> bool {
+    let mut t = *code16;
+    if (t & 0xF000) == 0xD000 && (t & 0x0F00) != 0x0F00 {
+        if disp % 2 != 0 || !signed_fit(disp, 9) {
+            return false;
+        }
+        t = (t & 0xFF00) | (((disp >> 1) as u16) & 0x00FF);
+        *code16 = t;
+        return true;
+    }
+    false
+}
+
+pub fn read_t8(instr_rva: u32, code16: u16) -> Option<u32> {
+    if is_misaligned(instr_rva, ArmAlign::Align2) {
+        return None;
+    }
+    let (align, disp) = decode_t8(code16);
+    if align == ArmAlign::Fail {
+        return None;
+    }
+    Some(get_thumb2_target_rva_from_disp(instr_rva, disp, align))
+}
+
+pub fn write_t8(instr_rva: u32, target_rva: u32, code16: &mut u16) -> bool {
+    if is_misaligned(instr_rva, ArmAlign::Align2) || is_misaligned(target_rva, ArmAlign::Align2) {
+        return false;
+    }
+    let disp = get_thumb2_disp_from_target_rva(instr_rva, target_rva, ArmAlign::Align2);
+    encode_t8(disp, code16)
+}
+
+pub fn decode_t11(code16: u16) -> (ArmAlign, i32) {
+    if (code16 & 0xF800) == 0xE000 {
+        return (ArmAlign::Align2, signed_bits_u16(code16, 0, 10) << 1);
+    }
+    (ArmAlign::Fail, 0)
+}
+
+pub fn encode_t11(disp: i32, code16: &mut u16) -> bool {
+    let mut t = *code16;
+    if (t & 0xF800) == 0xE000 {
+        if disp % 2 != 0 || !signed_fit(disp, 12) {
+            return false;
+        }
+        t = (t & 0xF800) | (((disp >> 1) as u16) & 0x07FF);
+        *code16 = t;
+        return true;
+    }
+    false
+}
+
+pub fn read_t11(instr_rva: u32, code16: u16) -> Option<u32> {
+    if is_misaligned(instr_rva, ArmAlign::Align2) {
+        return None;
+    }
+    let (align, disp) = decode_t11(code16);
+    if align == ArmAlign::Fail {
+        return None;
+    }
+    Some(get_thumb2_target_rva_from_disp(instr_rva, disp, align))
+}
+
+pub fn write_t11(instr_rva: u32, target_rva: u32, code16: &mut u16) -> bool {
+    if is_misaligned(instr_rva, ArmAlign::Align2) || is_misaligned(target_rva, ArmAlign::Align2) {
+        return false;
+    }
+    let disp = get_thumb2_disp_from_target_rva(instr_rva, target_rva, ArmAlign::Align2);
+    encode_t11(disp, code16)
+}
+
+pub fn decode_t20(code32: u32) -> (ArmAlign, i32) {
+    if (code32 & 0xF800_D000) == 0xF000_8000 && (code32 & 0x03C0_0000) != 0x03C0_0000 {
+        let imm11 = unsigned_bits(code32, 0, 10);
+        let j2 = bit(code32, 11);
+        let j1 = bit(code32, 13);
+        let imm6 = unsigned_bits(code32, 16, 21);
+        let s = bit(code32, 26);
+        let mut t = (imm6 << 12) | (imm11 << 1);
+        t |= (s << 20) | (j2 << 19) | (j1 << 18);
+        return (ArmAlign::Align2, sign_extend_u32(t, 20));
+    }
+    (ArmAlign::Fail, 0)
+}
+
+pub fn encode_t20(disp: i32, code32: &mut u32) -> bool {
+    let mut t = *code32;
+    if (t & 0xF800_D000) == 0xF000_8000 && (t & 0x03C0_0000) != 0x03C0_0000 {
+        if disp % 2 != 0 || !signed_fit(disp, 21) {
+            return false;
+        }
+        let s = bit(disp as u32, 20);
+        let j2 = bit(disp as u32, 19);
+        let j1 = bit(disp as u32, 18);
+        let imm6 = unsigned_bits(disp as u32, 12, 17);
+        let imm11 = unsigned_bits(disp as u32, 1, 11);
+        t &= 0xFBC0_D000;
+        t |= (s << 26) | (imm6 << 16) | (j1 << 13) | (j2 << 11) | imm11;
+        *code32 = t;
+        return true;
+    }
+    false
+}
+
+pub fn read_t20(instr_rva: u32, code32: u32) -> Option<u32> {
+    if is_misaligned(instr_rva, ArmAlign::Align2) {
+        return None;
+    }
+    let (align, disp) = decode_t20(code32);
+    if align == ArmAlign::Fail {
+        return None;
+    }
+    Some(get_thumb2_target_rva_from_disp(instr_rva, disp, align))
+}
+
+pub fn write_t20(instr_rva: u32, target_rva: u32, code32: &mut u32) -> bool {
+    if is_misaligned(instr_rva, ArmAlign::Align2) || is_misaligned(target_rva, ArmAlign::Align2) {
+        return false;
+    }
+    let disp = get_thumb2_disp_from_target_rva(instr_rva, target_rva, ArmAlign::Align2);
+    encode_t20(disp, code32)
+}
+
+pub fn decode_t24(code32: u32) -> (ArmAlign, i32) {
+    let bits = code32 & 0xF800_D000;
+    if bits == 0xF000_9000 || bits == 0xF000_D000 || bits == 0xF000_C000 {
+        let imm11 = unsigned_bits(code32, 0, 10);
+        let j2 = bit(code32, 11);
+        let j1 = bit(code32, 13);
+        let imm10 = unsigned_bits(code32, 16, 25);
+        let s = bit(code32, 26);
+        let mut t = (imm10 << 12) | (imm11 << 1);
+        t |= (s << 24) | ((j1 ^ s ^ 1) << 23) | ((j2 ^ s ^ 1) << 22);
+        let disp = sign_extend_u32(t, 24);
+        let mut align = ArmAlign::Align2;
+        if bits == 0xF000_C000 {
+            if bit(code32, 0) != 0 {
+                return (ArmAlign::Fail, 0);
+            }
+            align = ArmAlign::Align4;
+        }
+        return (align, disp);
+    }
+    (ArmAlign::Fail, 0)
+}
+
+pub fn encode_t24(disp: i32, code32: &mut u32) -> bool {
+    let mut t = *code32;
+    let bits = t & 0xF800_D000;
+    if bits == 0xF000_9000 || bits == 0xF000_D000 || bits == 0xF000_C000 {
+        if disp % 2 != 0 {
+            return false;
+        }
+        if bits == 0xF000_C000 && bit(disp as u32, 1) != 0 {
+            return false;
+        }
+        if !signed_fit(disp, 25) {
+            return false;
+        }
+        let imm11 = unsigned_bits(disp as u32, 1, 11);
+        let imm10 = unsigned_bits(disp as u32, 12, 21);
+        let i2 = bit(disp as u32, 22);
+        let i1 = bit(disp as u32, 23);
+        let s = bit(disp as u32, 24);
+        t &= 0xF800_D000;
+        t |= (s << 26)
+            | (imm10 << 16)
+            | ((i1 ^ s ^ 1) << 13)
+            | ((i2 ^ s ^ 1) << 11)
+            | imm11;
+        *code32 = t;
+        return true;
+    }
+    false
+}
+
+pub fn read_t24(instr_rva: u32, code32: u32) -> Option<u32> {
+    if is_misaligned(instr_rva, ArmAlign::Align2) {
+        return None;
+    }
+    let (align, disp) = decode_t24(code32);
+    if align == ArmAlign::Fail {
+        return None;
+    }
+    Some(get_thumb2_target_rva_from_disp(instr_rva, disp, align))
+}
+
+pub fn write_t24(instr_rva: u32, target_rva: u32, code32: &mut u32) -> bool {
+    if is_misaligned(instr_rva, ArmAlign::Align2) {
+        return false;
+    }
+    let (align, _) = decode_t24(*code32);
+    if align == ArmAlign::Fail || is_misaligned(target_rva, align) {
+        return false;
+    }
+    let disp = get_thumb2_disp_from_target_rva(instr_rva, target_rva, align);
+    encode_t24(disp, code32)
+}
+
+// `AArch64Rel32Translator`.
+
+fn get_target_rva_from_disp(instr_rva: u32, disp: i32) -> u32 {
+    instr_rva.wrapping_add(disp as u32)
+}
+
+fn get_disp_from_target_rva(instr_rva: u32, target_rva: u32) -> i32 {
+    target_rva.wrapping_sub(instr_rva) as i32
+}
+
+pub fn decode_immd14(code32: u32) -> (ArmAlign, i32) {
+    let bits = code32 & 0x7F00_0000;
+    if bits == 0x3600_0000 || bits == 0x3700_0000 {
+        return (ArmAlign::Align4, signed_bits(code32, 5, 18) << 2);
+    }
+    (ArmAlign::Fail, 0)
+}
+
+pub fn encode_immd14(disp: i32, code32: &mut u32) -> bool {
+    let mut t = *code32;
+    let bits = t & 0x7F00_0000;
+    if bits == 0x3600_0000 || bits == 0x3700_0000 {
+        if disp % 4 != 0 || !signed_fit(disp, 16) {
+            return false;
+        }
+        let imm14 = unsigned_bits(disp as u32, 2, 15);
+        t &= 0xFFF8_001F;
+        t |= imm14 << 5;
+        *code32 = t;
+        return true;
+    }
+    false
+}
+
+pub fn read_immd14(instr_rva: u32, code32: u32) -> Option<u32> {
+    if is_misaligned(instr_rva, ArmAlign::Align4) {
+        return None;
+    }
+    let (align, disp) = decode_immd14(code32);
+    if align == ArmAlign::Fail {
+        return None;
+    }
+    Some(get_target_rva_from_disp(instr_rva, disp))
+}
+
+pub fn write_immd14(instr_rva: u32, target_rva: u32, code32: &mut u32) -> bool {
+    if is_misaligned(instr_rva, ArmAlign::Align4) || is_misaligned(target_rva, ArmAlign::Align4) {
+        return false;
+    }
+    let disp = get_disp_from_target_rva(instr_rva, target_rva);
+    encode_immd14(disp, code32)
+}
+
+pub fn decode_immd19(code32: u32) -> (ArmAlign, i32) {
+    let bits1 = code32 & 0xFF00_0010;
+    let bits2 = code32 & 0x7F00_0000;
+    if bits1 == 0x5400_0000 || bits2 == 0x3400_0000 || bits2 == 0x3500_0000 {
+        return (ArmAlign::Align4, signed_bits(code32, 5, 23) << 2);
+    }
+    (ArmAlign::Fail, 0)
+}
+
+pub fn encode_immd19(disp: i32, code32: &mut u32) -> bool {
+    let mut t = *code32;
+    let bits1 = t & 0xFF00_0010;
+    let bits2 = t & 0x7F00_0000;
+    if bits1 == 0x5400_0000 || bits2 == 0x3400_0000 || bits2 == 0x3500_0000 {
+        if disp % 4 != 0 || !signed_fit(disp, 21) {
+            return false;
+        }
+        let imm19 = unsigned_bits(disp as u32, 2, 20);
+        t &= 0xFF00_001F;
+        t |= imm19 << 5;
+        *code32 = t;
+        return true;
+    }
+    false
+}
+
+pub fn read_immd19(instr_rva: u32, code32: u32) -> Option<u32> {
+    if is_misaligned(instr_rva, ArmAlign::Align4) {
+        return None;
+    }
+    let (align, disp) = decode_immd19(code32);
+    if align == ArmAlign::Fail {
+        return None;
+    }
+    Some(get_target_rva_from_disp(instr_rva, disp))
+}
+
+pub fn write_immd19(instr_rva: u32, target_rva: u32, code32: &mut u32) -> bool {
+    if is_misaligned(instr_rva, ArmAlign::Align4) || is_misaligned(target_rva, ArmAlign::Align4) {
+        return false;
+    }
+    let disp = get_disp_from_target_rva(instr_rva, target_rva);
+    encode_immd19(disp, code32)
+}
+
+pub fn decode_immd26(code32: u32) -> (ArmAlign, i32) {
+    let bits = code32 & 0xFC00_0000;
+    if bits == 0x1400_0000 || bits == 0x9400_0000 {
+        return (ArmAlign::Align4, signed_bits(code32, 0, 25) << 2);
+    }
+    (ArmAlign::Fail, 0)
+}
+
+pub fn encode_immd26(disp: i32, code32: &mut u32) -> bool {
+    let mut t = *code32;
+    let bits = t & 0xFC00_0000;
+    if bits == 0x1400_0000 || bits == 0x9400_0000 {
+        if disp % 4 != 0 || !signed_fit(disp, 28) {
+            return false;
+        }
+        let imm26 = unsigned_bits(disp as u32, 2, 27);
+        t &= 0xFC00_0000;
+        t |= imm26;
+        *code32 = t;
+        return true;
+    }
+    false
+}
+
+pub fn read_immd26(instr_rva: u32, code32: u32) -> Option<u32> {
+    if is_misaligned(instr_rva, ArmAlign::Align4) {
+        return None;
+    }
+    let (align, disp) = decode_immd26(code32);
+    if align == ArmAlign::Fail {
+        return None;
+    }
+    Some(get_target_rva_from_disp(instr_rva, disp))
+}
+
+pub fn write_immd26(instr_rva: u32, target_rva: u32, code32: &mut u32) -> bool {
+    if is_misaligned(instr_rva, ArmAlign::Align4) || is_misaligned(target_rva, ArmAlign::Align4) {
+        return false;
+    }
+    let disp = get_disp_from_target_rva(instr_rva, target_rva);
+    encode_immd26(disp, code32)
+}
diff --git a/src/zucchini_pure/bytes.rs b/src/zucchini_pure/bytes.rs
new file mode 100644
index 0000000..591b2eb
--- /dev/null
+++ b/src/zucchini_pure/bytes.rs
@@ -0,0 +1,96 @@
+//! Little-endian byte access helpers shared by the pure-Rust Zucchini port.
+
+pub fn read_u8(data: &[u8], offset: usize) -> Option<u8> {
+    data.get(offset).copied()
+}
+
+pub fn read_u16(data: &[u8], offset: usize) -> Option<u16> {
+    let bytes = data.get(offset..offset.checked_add(2)?)?;
+    Some(u16::from_le_bytes(bytes.try_into().ok()?))
+}
+
+pub fn read_i16(data: &[u8], offset: usize) -> Option<i16> {
+    Some(read_u16(data, offset)? as i16)
+}
+
+pub fn read_u32(data: &[u8], offset: usize) -> Option<u32> {
+    let bytes = data.get(offset..offset.checked_add(4)?)?;
+    Some(u32::from_le_bytes(bytes.try_into().ok()?))
+}
+
+pub fn read_i32(data: &[u8], offset: usize) -> Option<i32> {
+    Some(read_u32(data, offset)? as i32)
+}
+
+pub fn read_u64(data: &[u8], offset: usize) -> Option<u64> {
+    let bytes = data.get(offset..offset.checked_add(8)?)?;
+    Some(u64::from_le_bytes(bytes.try_into().ok()?))
+}
+
+pub fn write_u16(data: &mut [u8], offset: usize, value: u16) -> Option<()> {
+    let end = offset.checked_add(2)?;
+    data.get_mut(offset..end)?.copy_from_slice(&value.to_le_bytes());
+    Some(())
+}
+
+pub fn write_u32(data: &mut [u8], offset: usize, value: u32) -> Option<()> {
+    let end = offset.checked_add(4)?;
+    data.get_mut(offset..end)?.copy_from_slice(&value.to_le_bytes());
+    Some(())
+}
+
+pub fn write_u64(data: &mut [u8], offset: usize, value: u64) -> Option<()> {
+    let end = offset.checked_add(8)?;
+    data.get_mut(offset..end)?.copy_from_slice(&value.to_le_bytes());
+    Some(())
+}
+
+/// Mirrors `zucchini::RangeIsBounded`: `begin < bound && size <= bound - begin`.
+pub fn range_is_bounded(begin: u64, size: u64, bound: u64) -> bool {
+    begin < bound && size <= bound - begin
+}
+
+/// Mirrors `zucchini::RangeCovers`: `begin <= value && value - begin < size`.
+pub fn range_covers(begin: u64, size: u64, value: u64) -> bool {
+    begin <= value && value - begin < size
+}
+
+/// Mirrors `zucchini::IncrementForAlignCeil2`.
+pub fn increment_for_align_ceil2(pos: u64) -> u64 {
+    pos & 1
+}
+
+/// Mirrors `zucchini::IncrementForAlignCeil4`.
+pub fn increment_for_align_ceil4(pos: u64) -> u64 {
+    (-(pos as i64) & 3) as u64
+}
+
+/// Mirrors `zucchini::AlignCeil`.
+pub fn align_ceil(x: u64, m: u64) -> u64 {
+    x.div_ceil(m) * m
+}
+
+/// Zero-extends bits `[lo, hi]` (inclusive) of a 32-bit value.
+pub fn get_unsigned_bits_u32(value: u32, lo: u32, hi: u32) -> u32 {
+    let num_bits = 32u32;
+    (value << (num_bits - 1 - hi)) >> (num_bits - 1 - hi + lo)
+}
+
+/// Sign-extends bits `[lo, hi]` (inclusive) of a 32-bit value.
+pub fn get_signed_bits_u32(value: u32, lo: u32, hi: u32) -> i32 {
+    let num_bits = 32i32;
+    let shift = num_bits - 1 - hi as i32;
+    ((value << shift) as i32) >> (shift + lo as i32)
+}
+
+/// Sign-extends the low `pos + 1` bits of `value`.
+pub fn sign_extend_u32(value: u32, pos: u32) -> i32 {
+    let shift = 31 - pos;
+    ((value << shift) as i32) >> shift
+}
+
+/// Mirrors `zucchini::SignedFit<digs>` for a 32-bit signed value.
+pub fn signed_fit(value: i32, digs: u32) -> bool {
+    let shift = 32 - digs;
+    (value << shift) >> shift == value
+}
diff --git a/src/zucchini_pure/crc32.rs b/src/zucchini_pure/crc32.rs
new file mode 100644
index 0000000..9d88a24
--- /dev/null
+++ b/src/zucchini_pure/crc32.rs
@@ -0,0 +1,34 @@
+//! CRC-32 implementation matching `components/zucchini/crc32.cc`.
+
+fn make_crc32_table() -> [u32; 256] {
+    const POLY: u32 = 0xEDB8_8320;
+    let mut table = [0u32; 256];
+    for (i, entry) in table.iter_mut().enumerate() {
+        let mut r = i as u32;
+        for _ in 0..8 {
+            r = (r >> 1) ^ (POLY & (!((r & 1).wrapping_sub(1))));
+        }
+        *entry = r;
+    }
+    table
+}
+
+pub fn calculate_crc32(data: &[u8]) -> u32 {
+    let table = make_crc32_table();
+    let mut ret = 0xFFFF_FFFFu32;
+    for &byte in data {
+        ret = table[((ret ^ byte as u32) & 0xFF) as usize] ^ (ret >> 8);
+    }
+    ret ^ 0xFFFF_FFFF
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn known_vectors() {
+        assert_eq!(calculate_crc32(b""), 0x0000_0000);
+        assert_eq!(calculate_crc32(b"123456789"), 0xCBF4_3926);
+    }
+}
diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
new file mode 100644
index 0000000..9841e15
--- /dev/null
+++ b/src/zucchini_pure/dex.rs
@@ -0,0 +1,31 @@
+//! DEX disassembler (apply path).
+//!
+//! Placeholder: the full port of `disassembler_dex.cc` is tracked in
+//! `docs/zucchini-rust-port.md`. Until it lands, DEX elements are reported as
+//! unsupported by the pure-Rust engine.
+
+use super::{Disassembler, GroupTraits, Reference};
+
+pub struct DexDisassembler;
+
+impl DexDisassembler {
+    pub fn parse(_image: &[u8]) -> Option<Self> {
+        None
+    }
+}
+
+impl Disassembler for DexDisassembler {
+    fn size(&self) -> u32 {
+        0
+    }
+
+    fn groups(&self) -> &[GroupTraits] {
+        &[]
+    }
+
+    fn read(&self, _group: usize, _image: &[u8], _lo: u32, _hi: u32) -> Vec<Reference> {
+        Vec::new()
+    }
+
+    fn write(&self, _group: usize, _image: &mut [u8], _reference: Reference) {}
+}
diff --git a/src/zucchini_pure/elf.rs b/src/zucchini_pure/elf.rs
new file mode 100644
index 0000000..1439dce
--- /dev/null
+++ b/src/zucchini_pure/elf.rs
@@ -0,0 +1,1225 @@
+//! Pure-Rust port of `disassembler_elf.cc` + `reloc_elf.cc` + `abs32_utils.cc`
+//! + `rel32_utils.cc` + `rel32_finder.cc` + `address_translator.cc` for apply.
+
+use super::arm;
+use super::bytes::{
+    align_ceil, increment_for_align_ceil2, increment_for_align_ceil4, range_covers,
+    range_is_bounded, read_i32, read_u16, read_u32, read_u64, write_u16, write_u32, write_u64,
+};
+use super::{Disassembler, GroupTraits, Reference, K_INVALID_OFFSET, K_INVALID_RVA, OFFSET_BOUND};
+
+const K_RVA_BOUND: u32 = 0x7FFF_FFFF;
+const K_SIZE_BOUND: u64 = 0x7FFF_0000;
+
+const SHT_PROGBITS: u32 = 1;
+const SHT_RELA: u32 = 4;
+const SHT_NOBITS: u32 = 8;
+const SHT_REL: u32 = 9;
+const SHF_EXECINSTR: u64 = 1 << 2;
+const SHF_TLS: u64 = 1 << 10;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ElfKind {
+    X86,
+    X64,
+    AArch32,
+    AArch64,
+}
+
+impl ElfKind {
+    fn bitness(self) -> u32 {
+        match self {
+            ElfKind::X86 | ElfKind::AArch32 => 4,
+            ElfKind::X64 | ElfKind::AArch64 => 8,
+        }
+    }
+
+    fn class(self) -> u8 {
+        match self {
+            ElfKind::X86 | ElfKind::AArch32 => 1,
+            ElfKind::X64 | ElfKind::AArch64 => 2,
+        }
+    }
+
+    fn machine(self) -> u16 {
+        match self {
+            ElfKind::X86 => 3,
+            ElfKind::X64 => 62,
+            ElfKind::AArch32 => 40,
+            ElfKind::AArch64 => 183,
+        }
+    }
+
+    fn shdr_size(self) -> u16 {
+        match self {
+            ElfKind::X86 | ElfKind::AArch32 => 40,
+            ElfKind::X64 | ElfKind::AArch64 => 64,
+        }
+    }
+
+    fn phdr_size(self) -> u16 {
+        match self {
+            ElfKind::X86 | ElfKind::AArch32 => 32,
+            ElfKind::X64 | ElfKind::AArch64 => 56,
+        }
+    }
+
+    fn rel_type(self) -> u32 {
+        match self {
+            ElfKind::X86 | ElfKind::X64 => 8,
+            ElfKind::AArch32 => 23,
+            ElfKind::AArch64 => 0x403,
+        }
+    }
+
+    fn va_width(self) -> u32 {
+        self.bitness()
+    }
+
+    fn is_arm(self) -> bool {
+        matches!(self, ElfKind::AArch32 | ElfKind::AArch64)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct SectionHeader {
+    sh_type: u32,
+    sh_flags: u64,
+    sh_addr: u64,
+    sh_offset: u64,
+    sh_size: u64,
+    sh_entsize: u64,
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct RelocSection {
+    offset: u32,
+    size: u32,
+    entry_size: u32,
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct ExecHeader {
+    offset: u32,
+    size: u32,
+    addr: u32,
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct Unit {
+    offset_begin: u32,
+    offset_size: u32,
+    rva_begin: u32,
+    rva_size: u32,
+}
+
+impl Unit {
+    fn offset_end(&self) -> u32 {
+        self.offset_begin.wrapping_add(self.offset_size)
+    }
+
+    fn rva_end(&self) -> u32 {
+        self.rva_begin.wrapping_add(self.rva_size)
+    }
+
+    fn covers_offset(&self, offset: u32) -> bool {
+        range_covers(u64::from(self.offset_begin), u64::from(self.offset_size), u64::from(offset))
+    }
+
+    fn covers_rva(&self, rva: u32) -> bool {
+        range_covers(u64::from(self.rva_begin), u64::from(self.rva_size), u64::from(rva))
+    }
+
+    fn has_dangling_rva(&self) -> bool {
+        self.rva_size > self.offset_size
+    }
+
+    fn covers_dangling_rva(&self, rva: u32) -> bool {
+        self.covers_rva(rva) && rva - self.rva_begin >= self.offset_size
+    }
+
+    fn offset_to_rva_unsafe(&self, offset: u32) -> u32 {
+        offset.wrapping_sub(self.offset_begin).wrapping_add(self.rva_begin)
+    }
+
+    fn rva_to_offset_unsafe(&self, rva: u32, fake_offset_begin: u32) -> u32 {
+        let delta = rva.wrapping_sub(self.rva_begin);
+        if delta < self.offset_size {
+            delta.wrapping_add(self.offset_begin)
+        } else {
+            fake_offset_begin.wrapping_add(rva)
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+struct AddressTranslator {
+    by_offset: Vec<Unit>,
+    by_rva: Vec<Unit>,
+    fake_offset_begin: u32,
+}
+
+impl AddressTranslator {
+    fn initialize(&mut self, mut units: Vec<Unit>) -> bool {
+        for unit in &mut units {
+            if !range_is_bounded(
+                u64::from(unit.offset_begin),
+                u64::from(unit.offset_size),
+                u64::from(K_RVA_BOUND),
+            ) || !range_is_bounded(
+                u64::from(unit.rva_begin),
+                u64::from(unit.rva_size),
+                u64::from(K_RVA_BOUND),
+            ) {
+                return false;
+            }
+            unit.offset_size = unit.offset_size.min(unit.rva_size);
+        }
+        units.retain(|unit| unit.rva_size != 0);
+
+        units.sort_by_key(|unit| (unit.rva_begin, unit.rva_size));
+        units.dedup_by(|a, b| a.rva_begin == b.rva_begin && a.rva_size == b.rva_size);
+
+        if units.len() > 1 {
+            let mut slow = 0usize;
+            for fast in 1..units.len() {
+                if units[slow].rva_end() < units[fast].rva_begin {
+                    slow += 1;
+                    units[slow] = units[fast];
+                    continue;
+                }
+                let merge_optional = units[slow].rva_end() == units[fast].rva_begin;
+                if units[fast].offset_begin < units[slow].offset_begin
+                    || units[fast].offset_begin.wrapping_sub(units[slow].offset_begin)
+                        != units[fast].rva_begin.wrapping_sub(units[slow].rva_begin)
+                {
+                    if merge_optional {
+                        slow += 1;
+                        units[slow] = units[fast];
+                        continue;
+                    }
+                    return false;
+                }
+                let dangling_mismatch = (units[fast].has_dangling_rva()
+                    && units[fast].offset_end() < units[slow].offset_end())
+                    || (units[slow].has_dangling_rva()
+                        && units[slow].offset_end() < units[fast].offset_end());
+                if dangling_mismatch {
+                    if merge_optional {
+                        slow += 1;
+                        units[slow] = units[fast];
+                        continue;
+                    }
+                    return false;
+                }
+                units[slow].rva_size = units[slow]
+                    .rva_size
+                    .max(units[fast].rva_end().wrapping_sub(units[slow].rva_begin));
+                units[slow].offset_size = units[slow]
+                    .offset_size
+                    .max(units[fast].offset_end().wrapping_sub(units[slow].offset_begin));
+            }
+            slow += 1;
+            units.truncate(slow);
+        }
+
+        units.sort_by_key(|unit| unit.offset_begin);
+        for pair in units.windows(2) {
+            if pair[0].offset_end() > pair[1].offset_begin {
+                return false;
+            }
+        }
+
+        let mut offset_bound = 0u32;
+        let mut rva_bound = 0u32;
+        for unit in &units {
+            offset_bound = offset_bound.max(unit.offset_end());
+            rva_bound = rva_bound.max(unit.rva_end());
+        }
+        if !range_is_bounded(
+            u64::from(offset_bound),
+            u64::from(rva_bound),
+            u64::from(K_RVA_BOUND),
+        ) {
+            return false;
+        }
+
+        self.by_offset = units.clone();
+        units.sort_by_key(|unit| unit.rva_begin);
+        self.by_rva = units;
+        self.fake_offset_begin = offset_bound;
+        true
+    }
+
+    fn offset_to_unit(&self, offset: u32) -> Option<&Unit> {
+        let index = self.by_offset.partition_point(|unit| unit.offset_begin <= offset);
+        if index == 0 {
+            return None;
+        }
+        let unit = &self.by_offset[index - 1];
+        unit.covers_offset(offset).then_some(unit)
+    }
+
+    fn rva_to_unit(&self, rva: u32) -> Option<&Unit> {
+        let index = self.by_rva.partition_point(|unit| unit.rva_begin <= rva);
+        if index == 0 {
+            return None;
+        }
+        let unit = &self.by_rva[index - 1];
+        unit.covers_rva(rva).then_some(unit)
+    }
+
+    fn offset_to_rva(&self, offset: u32) -> Option<u32> {
+        if offset >= self.fake_offset_begin {
+            let rva = offset.wrapping_sub(self.fake_offset_begin);
+            return match self.rva_to_unit(rva) {
+                Some(unit) if unit.has_dangling_rva() && unit.covers_dangling_rva(rva) => Some(rva),
+                _ => None,
+            };
+        }
+        self.offset_to_unit(offset).map(|unit| unit.offset_to_rva_unsafe(offset))
+    }
+
+    fn rva_to_offset(&self, rva: u32) -> Option<u32> {
+        self.rva_to_unit(rva).map(|unit| unit.rva_to_offset_unsafe(rva, self.fake_offset_begin))
+    }
+}
+
+pub struct ElfDisassembler {
+    kind: ElfKind,
+    size: u32,
+    groups: Vec<GroupTraits>,
+    translator: AddressTranslator,
+    reloc_sections: Vec<RelocSection>,
+    exec_headers: Vec<ExecHeader>,
+    abs32_locations: Vec<u32>,
+    /// Rel32 locations per address type. Intel uses index 0 only.
+    rel32_locations: Vec<Vec<u32>>,
+}
+
+impl ElfDisassembler {
+    pub fn parse(kind: ElfKind, image: &[u8]) -> Option<Self> {
+        let (sections, offset_bound) = parse_elf_header(kind, image)?;
+
+        let mut units = Vec::new();
+        let mut judgements = vec![0i32; sections.len()];
+        let mut offset_bound = offset_bound;
+
+        for (index, section) in sections.iter().enumerate() {
+            let judgement = judge_section(kind, image.len() as u64, section);
+            judgements[index] = judgement;
+            if judgement & 1 == 0 {
+                return None;
+            }
+            let sh_size = section.sh_size as u32;
+            let sh_offset = section.sh_offset as u32;
+            let sh_addr = section.sh_addr as u32;
+            if judgement & (1 << 1) != 0 {
+                units.push(Unit {
+                    offset_begin: sh_offset,
+                    offset_size: sh_size,
+                    rva_begin: sh_addr,
+                    rva_size: sh_size,
+                });
+            }
+            if judgement & (1 << 2) != 0 {
+                let end = sh_offset.checked_add(sh_size)?;
+                offset_bound = offset_bound.max(end);
+            }
+        }
+
+        let mut translator = AddressTranslator::default();
+        if !translator.initialize(units) {
+            return None;
+        }
+
+        let mut disassembler = ElfDisassembler {
+            kind,
+            size: offset_bound,
+            groups: build_groups(kind),
+            translator,
+            reloc_sections: Vec::new(),
+            exec_headers: Vec::new(),
+            abs32_locations: Vec::new(),
+            rel32_locations: vec![Vec::new(); rel32_type_count(kind)],
+        };
+
+        disassembler.extract_interesting_section_headers(&sections, &judgements);
+        disassembler.get_abs32_from_reloc_sections(image)?;
+        disassembler.get_rel32_from_code_sections(image);
+        Some(disassembler)
+    }
+
+    fn extract_interesting_section_headers(
+        &mut self,
+        sections: &[SectionHeader],
+        judgements: &[i32],
+    ) {
+        for (index, section) in sections.iter().enumerate() {
+            if judgements[index] & (1 << 3) == 0 {
+                continue;
+            }
+            if is_reloc_section(self.kind, section) {
+                self.reloc_sections.push(RelocSection {
+                    offset: section.sh_offset as u32,
+                    size: section.sh_size as u32,
+                    entry_size: section.sh_entsize as u32,
+                });
+            } else if is_exec_section(section) {
+                self.exec_headers.push(ExecHeader {
+                    offset: section.sh_offset as u32,
+                    size: section.sh_size as u32,
+                    addr: section.sh_addr as u32,
+                });
+            }
+        }
+        self.reloc_sections.sort_by_key(|section| section.offset);
+        self.exec_headers.sort_by_key(|header| header.offset);
+    }
+
+    fn get_abs32_from_reloc_sections(&mut self, image: &[u8]) -> Option<()> {
+        let relocs = self.read_relocs(image, 0, self.size);
+        let mut locations: Vec<u32> = relocs.iter().map(|reference| reference.target).collect();
+        locations.sort_unstable();
+
+        // RemoveUntranslatableAbs32.
+        let mut kept = Vec::with_capacity(locations.len());
+        for location in locations {
+            let value = self.read_absolute(location, image);
+            let Some(value) = value else { continue };
+            if value >= u64::from(K_RVA_BOUND) {
+                continue;
+            }
+            let target_rva = value as u32;
+            if self.translator.rva_to_offset(target_rva).is_some() {
+                kept.push(location);
+            }
+        }
+        locations = kept;
+
+        // RemoveOverlappingAbs32Locations.
+        remove_overlapping(self.kind.va_width(), &mut locations);
+        self.abs32_locations = locations;
+        Some(())
+    }
+
+    fn read_absolute(&self, offset: u32, image: &[u8]) -> Option<u64> {
+        if self.kind.bitness() == 4 {
+            read_u32(image, offset as usize).map(u64::from)
+        } else {
+            read_u64(image, offset as usize)
+        }
+    }
+
+    fn get_rel32_from_code_sections(&mut self, image: &[u8]) {
+        let headers = self.exec_headers.clone();
+        for section in headers {
+            if !self.kind.is_arm() {
+                self.parse_exec_section_intel(&section, image);
+            } else {
+                self.parse_exec_section_arm(&section, image);
+            }
+        }
+        for locations in self.rel32_locations.iter_mut() {
+            locations.sort_unstable();
+        }
+    }
+
+    fn parse_exec_section_intel(&mut self, section: &ExecHeader, image: &[u8]) {
+        let start_rva = section.addr;
+        let end_rva = start_rva.wrapping_add(section.size);
+        let Some(region) = image.get(section.offset as usize..) else { return };
+        let region = &region[..section.size.min(region.len() as u32) as usize];
+        for (gap_start, gap_end) in
+            self.abs32_gaps(section.offset, section.offset.wrapping_add(section.size))
+        {
+            let mut cursor = gap_start as usize;
+            let gap_end = gap_end as usize;
+            while cursor < gap_end {
+                let candidate = intel_candidate(self.kind, image, cursor, gap_end);
+                if let Some((location, can_point_outside)) = candidate {
+                    if let Some(location_rva) = self.translator.offset_to_rva(location as u32) {
+                        let disp = read_u32(image, location).unwrap_or(0);
+                        let target_rva = location_rva.wrapping_add(4).wrapping_add(disp);
+                        if self.translator.rva_to_offset(target_rva).is_some()
+                            && (can_point_outside
+                                || (start_rva <= target_rva && target_rva < end_rva))
+                        {
+                            self.rel32_locations[0].push(location as u32);
+                            cursor = location + 4;
+                            continue;
+                        }
+                    }
+                }
+                cursor += 1;
+            }
+        }
+        let _ = region;
+    }
+
+    fn parse_exec_section_arm(&mut self, section: &ExecHeader, image: &[u8]) {
+        let is_thumb2 = if self.kind == ElfKind::AArch32 {
+            is_exec_section_thumb2(image, section)
+        } else {
+            false
+        };
+        let gaps = self.abs32_gaps(section.offset, section.offset.wrapping_add(section.size));
+        for (gap_start, gap_end) in gaps {
+            match self.kind {
+                ElfKind::AArch32 => {
+                    let mut cursor = align_gap_start_a32(gap_start, gap_end, is_thumb2);
+                    let step = if is_thumb2 { 2 } else { 4 };
+                    while cursor + step <= gap_end {
+                        let location = cursor as u32;
+                        let Some(instr_rva) = self.translator.offset_to_rva(location) else {
+                            cursor += step;
+                            continue;
+                        };
+                        let found = if is_thumb2 {
+                            scan_thumb2(image, instr_rva, location)
+                        } else {
+                            scan_arm32(image, instr_rva, location)
+                        };
+                        match found {
+                            Some((addr_type, target_rva, instr_size)) => {
+                                if let Some(target_offset) = self.translator.rva_to_offset(target_rva)
+                                {
+                                    if self.is_target_in_exec_section(target_offset) {
+                                        self.rel32_locations[addr_type as usize]
+                                            .push(location);
+                                    }
+                                }
+                                cursor += instr_size as usize;
+                            }
+                            None => cursor += step,
+                        }
+                    }
+                }
+                ElfKind::AArch64 => {
+                    let mut cursor =
+                        gap_start + increment_for_align_ceil4(gap_start as u64) as usize;
+                    while cursor + 4 <= gap_end {
+                        let location = cursor as u32;
+                        if let Some(instr_rva) = self.translator.offset_to_rva(location) {
+                            if let Some((addr_type, target_rva)) =
+                                scan_aarch64(image, instr_rva, location)
+                            {
+                                if let Some(target_offset) =
+                                    self.translator.rva_to_offset(target_rva)
+                                {
+                                    if self.is_target_in_exec_section(target_offset) {
+                                        self.rel32_locations[addr_type as usize]
+                                            .push(location);
+                                    }
+                                }
+                            }
+                        }
+                        cursor += 4;
+                    }
+                }
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    fn is_target_in_exec_section(&self, offset: u32) -> bool {
+        let index = self.exec_headers.partition_point(|header| header.offset <= offset);
+        if index == 0 {
+            return false;
+        }
+        let header = self.exec_headers[index - 1];
+        offset >= header.offset && offset - header.offset < header.size
+    }
+
+    /// Mirrors `Abs32GapFinder`: non-empty gaps in `[region_start, region_end)`
+    /// that do not overlap an abs32 body.
+    fn abs32_gaps(&self, region_start: u32, region_end: u32) -> Vec<(usize, usize)> {
+        let width = self.kind.va_width();
+        let mut gaps = Vec::new();
+        let mut current = self
+            .abs32_locations
+            .partition_point(|location| *location < region_start);
+        let mut cur_lo = region_start;
+        if current > 0 {
+            let previous = self.abs32_locations[current - 1];
+            cur_lo = cur_lo.max(previous.saturating_add(width));
+        }
+        while current < self.abs32_locations.len()
+            && self.abs32_locations[current] < region_end
+        {
+            let hi = self.abs32_locations[current];
+            if hi > cur_lo {
+                gaps.push((cur_lo as usize, hi as usize));
+            }
+            cur_lo = hi.saturating_add(width);
+            current += 1;
+        }
+        if cur_lo < region_end {
+            gaps.push((cur_lo as usize, region_end as usize));
+        }
+        gaps
+    }
+
+    fn read_relocs(&self, image: &[u8], lo: u32, hi: u32) -> Vec<Reference> {
+        if self.reloc_sections.is_empty() {
+            return Vec::new();
+        }
+        let mut result = Vec::new();
+        let bitness = self.kind.bitness();
+        let rel_type = self.kind.rel_type();
+
+        let mut current = self
+            .reloc_sections
+            .partition_point(|section| section.offset <= lo);
+        if current > 0 {
+            current -= 1;
+        }
+        let mut cursor = self.reloc_sections[current].offset;
+        if cursor < lo {
+            cursor += align_ceil(u64::from(lo - cursor), u64::from(self.reloc_sections[current].entry_size)) as u32;
+        }
+
+        let mut hi = hi;
+        let end_index = self.reloc_sections.partition_point(|section| section.offset <= hi);
+        if end_index > 0 {
+            let section = self.reloc_sections[end_index - 1];
+            if hi - section.offset < section.size {
+                hi = section.offset
+                    + align_ceil(u64::from(hi - section.offset), u64::from(section.entry_size))
+                        as u32;
+            }
+        }
+
+        loop {
+            while current < self.reloc_sections.len()
+                && cursor >= self.reloc_sections[current].offset + self.reloc_sections[current].size
+            {
+                current += 1;
+                if current == self.reloc_sections.len() {
+                    return result;
+                }
+                cursor = self.reloc_sections[current].offset;
+                if cursor + self.reloc_sections[current].entry_size > hi {
+                    return result;
+                }
+            }
+            if current >= self.reloc_sections.len() {
+                return result;
+            }
+            let entry_size = self.reloc_sections[current].entry_size;
+            if cursor + entry_size > hi {
+                return result;
+            }
+
+            let (r_offset, r_info) = if bitness == 4 {
+                (
+                    read_u32(image, cursor as usize).unwrap_or(0),
+                    read_u32(image, cursor as usize + 4).unwrap_or(0) as u64,
+                )
+            } else {
+                (
+                    read_u64(image, cursor as usize).unwrap_or(0) as u32,
+                    read_u64(image, cursor as usize + 8).unwrap_or(0),
+                )
+            };
+            let rel_type_value = if bitness == 4 {
+                (r_info & 0xFF) as u32
+            } else {
+                (r_info & 0xFFFF_FFFF) as u32
+            };
+            if rel_type_value == rel_type {
+                let valid_r_offset =
+                    bitness == 4 || (r_offset as u64 & 0xFFFF_FFFF) == r_offset as u64;
+                if valid_r_offset {
+                    if let Some(target) = self.translator.rva_to_offset(r_offset) {
+                        if range_covers(0, image.len() as u64, u64::from(target))
+                            && target as usize + (bitness as usize) <= image.len()
+                        {
+                            result.push(Reference { location: cursor, target });
+                        }
+                    }
+                }
+            }
+            cursor += entry_size;
+        }
+    }
+
+    fn read_abs32(&self, image: &[u8], lo: u32, hi: u32) -> Vec<Reference> {
+        let mut result = Vec::new();
+        for &location in &self.abs32_locations {
+            if location < lo {
+                continue;
+            }
+            if location >= hi {
+                break;
+            }
+            let Some(value) = self.read_absolute(location, image) else { continue };
+            if value >= u64::from(K_RVA_BOUND) {
+                continue;
+            }
+            if let Some(target) = self.translator.rva_to_offset(value as u32) {
+                result.push(Reference { location, target });
+            }
+        }
+        result
+    }
+
+    fn read_rel32_intel(&self, image: &[u8], lo: u32, hi: u32) -> Vec<Reference> {
+        let mut result = Vec::new();
+        for &location in &self.rel32_locations[0] {
+            if location < lo {
+                continue;
+            }
+            if location >= hi {
+                break;
+            }
+            let Some(location_rva) = self.translator.offset_to_rva(location) else { continue };
+            let disp = read_i32(image, location as usize).unwrap_or(0);
+            let target_rva = location_rva.wrapping_add(4).wrapping_add(disp as u32);
+            if let Some(target) = self.translator.rva_to_offset(target_rva) {
+                result.push(Reference { location, target });
+            }
+        }
+        result
+    }
+
+    fn read_rel32_arm(
+        &self,
+        image: &[u8],
+        addr_type: usize,
+        lo: u32,
+        hi: u32,
+    ) -> Vec<Reference> {
+        let mut result = Vec::new();
+        for &location in &self.rel32_locations[addr_type] {
+            if location < lo {
+                continue;
+            }
+            if location >= hi {
+                break;
+            }
+            let Some(instr_rva) = self.translator.offset_to_rva(location) else { continue };
+            let target_rva = if self.kind == ElfKind::AArch32 {
+                fetch_and_read_a32(image, addr_type, location, instr_rva)
+            } else {
+                fetch_and_read_a64(image, addr_type, location, instr_rva)
+            };
+            if let Some(target_rva) = target_rva {
+                if let Some(target) = self.translator.rva_to_offset(target_rva) {
+                    result.push(Reference { location, target });
+                }
+            }
+        }
+        result
+    }
+
+    fn write_reloc(&self, image: &mut [u8], reference: Reference) {
+        let target_rva = self.translator.offset_to_rva(reference.target).unwrap_or(K_INVALID_RVA);
+        if self.kind.bitness() == 4 {
+            let _ = write_u32(image, reference.location as usize, target_rva);
+        } else {
+            let _ = write_u64(image, reference.location as usize, u64::from(target_rva));
+        }
+    }
+
+    fn write_abs32(&self, image: &mut [u8], reference: Reference) {
+        let Some(target_rva) = self.translator.offset_to_rva(reference.target) else { return };
+        if self.kind.bitness() == 4 {
+            let _ = write_u32(image, reference.location as usize, target_rva);
+        } else {
+            let _ = write_u64(image, reference.location as usize, u64::from(target_rva));
+        }
+    }
+
+    fn write_rel32_intel(&self, image: &mut [u8], reference: Reference) {
+        let target_rva = self.translator.offset_to_rva(reference.target).unwrap_or(K_INVALID_RVA);
+        let location_rva =
+            self.translator.offset_to_rva(reference.location).unwrap_or(K_INVALID_RVA);
+        let code = target_rva.wrapping_sub(location_rva.wrapping_add(4));
+        let _ = write_u32(image, reference.location as usize, code);
+    }
+
+    fn write_rel32_arm(&self, image: &mut [u8], addr_type: usize, reference: Reference) {
+        let instr_rva = self.translator.offset_to_rva(reference.location).unwrap_or(K_INVALID_RVA);
+        let target_rva = self.translator.offset_to_rva(reference.target).unwrap_or(K_INVALID_RVA);
+        if self.kind == ElfKind::AArch32 {
+            write_arm32(image, addr_type, reference.location, instr_rva, target_rva);
+        } else {
+            write_aarch64(image, addr_type, reference.location, instr_rva, target_rva);
+        }
+    }
+}
+
+impl Disassembler for ElfDisassembler {
+    fn size(&self) -> u32 {
+        self.size
+    }
+
+    fn groups(&self) -> &[GroupTraits] {
+        &self.groups
+    }
+
+    fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Vec<Reference> {
+        if group == 0 {
+            return self.read_relocs(image, lo, hi);
+        }
+        if group == 1 {
+            return self.read_abs32(image, lo, hi);
+        }
+        match self.kind {
+            ElfKind::X86 | ElfKind::X64 => self.read_rel32_intel(image, lo, hi),
+            ElfKind::AArch32 | ElfKind::AArch64 => {
+                // Group index == address type index + 2 for ARM.
+                let addr_type = group - 2;
+                if addr_type < self.rel32_locations.len() {
+                    self.read_rel32_arm(image, addr_type, lo, hi)
+                } else {
+                    Vec::new()
+                }
+            }
+        }
+    }
+
+    fn write(&self, group: usize, image: &mut [u8], reference: Reference) {
+        if group == 0 {
+            self.write_reloc(image, reference);
+        } else if group == 1 {
+            self.write_abs32(image, reference);
+        } else {
+            match self.kind {
+                ElfKind::X86 | ElfKind::X64 => self.write_rel32_intel(image, reference),
+                ElfKind::AArch32 | ElfKind::AArch64 => {
+                    self.write_rel32_arm(image, group - 2, reference);
+                }
+            }
+        }
+    }
+}
+
+fn rel32_type_count(kind: ElfKind) -> usize {
+    match kind {
+        ElfKind::X86 | ElfKind::X64 => 1,
+        ElfKind::AArch32 => 5,
+        ElfKind::AArch64 => 3,
+    }
+}
+
+fn build_groups(kind: ElfKind) -> Vec<GroupTraits> {
+    let mut groups = Vec::new();
+    let reloc_width = kind.bitness();
+    groups.push(GroupTraits { width: reloc_width, type_tag: 0, pool_tag: 0 });
+    groups.push(GroupTraits { width: kind.va_width(), type_tag: 1, pool_tag: 1 });
+    match kind {
+        ElfKind::X86 | ElfKind::X64 => {
+            groups.push(GroupTraits { width: 4, type_tag: 2, pool_tag: 2 });
+        }
+        ElfKind::AArch32 => {
+            groups.push(GroupTraits { width: 4, type_tag: 2, pool_tag: 2 }); // A24
+            groups.push(GroupTraits { width: 2, type_tag: 3, pool_tag: 2 }); // T8
+            groups.push(GroupTraits { width: 2, type_tag: 4, pool_tag: 2 }); // T11
+            groups.push(GroupTraits { width: 4, type_tag: 5, pool_tag: 2 }); // T20
+            groups.push(GroupTraits { width: 4, type_tag: 6, pool_tag: 2 }); // T24
+        }
+        ElfKind::AArch64 => {
+            groups.push(GroupTraits { width: 4, type_tag: 2, pool_tag: 2 }); // Immd14
+            groups.push(GroupTraits { width: 4, type_tag: 3, pool_tag: 2 }); // Immd19
+            groups.push(GroupTraits { width: 4, type_tag: 4, pool_tag: 2 }); // Immd26
+        }
+    }
+    groups
+}
+
+fn judge_section(_kind: ElfKind, image_size: u64, section: &SectionHeader) -> i32 {
+    // Bit flags mirror `SectionJudgement`.
+    const SAFE: i32 = 1 << 0;
+    const USEFUL_ADDRESS: i32 = 1 << 1;
+    const USEFUL_BOUND: i32 = 1 << 2;
+    const MAYBE_POINTERS: i32 = 1 << 3;
+    const USELESS: i32 = SAFE;
+
+    if !region_fits(section.sh_addr, section.sh_size, K_SIZE_BOUND) {
+        return 0;
+    }
+    let offset_bound = if section.sh_type == SHT_NOBITS { K_SIZE_BOUND } else { image_size };
+    if !region_fits(section.sh_offset, section.sh_size, offset_bound) {
+        return 0;
+    }
+    if section.sh_size == 0 {
+        return USELESS;
+    }
+    if section.sh_addr == 0 {
+        return USELESS;
+    }
+    if section.sh_type == SHT_NOBITS {
+        if section.sh_flags & SHF_TLS != 0 {
+            return USELESS;
+        }
+        return SAFE | USEFUL_ADDRESS;
+    }
+    SAFE | USEFUL_ADDRESS | USEFUL_BOUND | MAYBE_POINTERS
+}
+
+fn region_fits(offset: u64, size: u64, container: u64) -> bool {
+    offset <= container && container - offset >= size
+}
+
+fn is_reloc_section(kind: ElfKind, section: &SectionHeader) -> bool {
+    if section.sh_type == SHT_REL {
+        return section.sh_entsize == kind.bitness() as u64 * 2;
+    }
+    if section.sh_type == SHT_RELA {
+        return section.sh_entsize == kind.bitness() as u64 * 2 + kind.bitness() as u64;
+    }
+    false
+}
+
+fn is_exec_section(section: &SectionHeader) -> bool {
+    section.sh_type == SHT_PROGBITS && section.sh_flags & SHF_EXECINSTR != 0
+}
+
+fn remove_overlapping(width: u32, locations: &mut Vec<u32>) {
+    if locations.len() <= 1 {
+        return;
+    }
+    let mut slow = 0usize;
+    let mut fast = 1usize;
+    loop {
+        while fast < locations.len() && locations[fast] - locations[slow] < width {
+            fast += 1;
+        }
+        slow += 1;
+        if fast == locations.len() {
+            break;
+        }
+        if slow != fast {
+            locations[slow] = locations[fast];
+        }
+        fast += 1;
+    }
+    locations.truncate(slow);
+}
+
+/// Parses the ELF header, section table, program table, and derives the
+/// `offset_bound` estimate. Mirrors `DisassemblerElf::ParseHeader`.
+fn parse_elf_header(
+    kind: ElfKind,
+    image: &[u8],
+) -> Option<(Vec<SectionHeader>, u32)> {
+    if u64::from(kind.class()) != 0 {
+        // QuickDetect checks.
+        if image.len() < 16 || &image[..4] != b"\x7FELF" {
+            return None;
+        }
+        if image[4] != kind.class() || image[5] != 1 {
+            return None;
+        }
+        let e_type = read_u16(image, 16)?;
+        if e_type != 2 && e_type != 3 {
+            return None;
+        }
+        let e_machine = read_u16(image, 18)?;
+        let e_version = read_u32(image, 20)?;
+        if e_version != 1 || image[6] != 1 || e_machine != kind.machine() {
+            return None;
+        }
+        let e_shentsize = read_u16(image, if kind.class() == 2 { 58 } else { 46 })?;
+        if e_shentsize != kind.shdr_size() {
+            return None;
+        }
+    }
+
+    let (e_shoff, e_phoff, e_shnum, e_phnum, e_shstrndx, e_phentsize) = if kind.class() == 2 {
+        (read_u64(image, 40)?, read_u64(image, 32)?, read_u16(image, 60)?, read_u16(image, 56)?, read_u16(image, 62)?, read_u16(image, 54)?)
+    } else {
+        (u64::from(read_u32(image, 32)?), u64::from(read_u32(image, 28)?), read_u16(image, 48)?, read_u16(image, 44)?, read_u16(image, 50)?, read_u16(image, 42)?)
+    };
+    if e_phentsize != kind.phdr_size() {
+        // Not part of QuickDetect, but the array read would fail anyway.
+    }
+
+    let sections_count = e_shnum as usize;
+    let shdr_size = kind.shdr_size() as usize;
+    let sections_start = usize::try_from(e_shoff).ok()?;
+    let sections_end = sections_start.checked_add(sections_count.checked_mul(shdr_size)?)?;
+    if sections_end > image.len() {
+        return None;
+    }
+    let mut sections = Vec::with_capacity(sections_count);
+    for index in 0..sections_count {
+        let base = sections_start + index * shdr_size;
+        sections.push(parse_shdr(kind, image, base)?);
+    }
+    let section_table_end = sections_end as u32;
+
+    let segments_count = e_phnum as usize;
+    let phdr_size = kind.phdr_size() as usize;
+    let segments_start = usize::try_from(e_phoff).ok()?;
+    let segments_end = segments_start.checked_add(segments_count.checked_mul(phdr_size)?)?;
+    if segments_end > image.len() {
+        return None;
+    }
+    let segment_table_end = segments_end as u32;
+
+    // String section check.
+    let string_section_id = e_shstrndx as usize;
+    if string_section_id >= sections_count {
+        return None;
+    }
+    let section_names_size = sections[string_section_id].sh_size;
+    if section_names_size > 0 {
+        let offset = usize::try_from(sections[string_section_id].sh_offset).ok()?;
+        let end = offset.checked_add(usize::try_from(section_names_size).ok()?)?;
+        let names = image.get(offset..end)?;
+        if *names.last()? != 0 {
+            return None;
+        }
+    }
+
+    let mut offset_bound = section_table_end.max(segment_table_end);
+    for index in 0..segments_count {
+        let base = segments_start + index * phdr_size;
+        let (p_offset, p_filesz) = parse_phdr(kind, image, base)?;
+        let segment_end = p_offset.checked_add(p_filesz)?;
+        if segment_end > image.len() as u32 {
+            return None;
+        }
+        offset_bound = offset_bound.max(segment_end);
+    }
+
+    Some((sections, offset_bound))
+}
+
+fn parse_shdr(kind: ElfKind, image: &[u8], base: usize) -> Option<SectionHeader> {
+    if kind.class() == 2 {
+        Some(SectionHeader {
+            sh_type: read_u32(image, base + 4)?,
+            sh_flags: read_u64(image, base + 8)?,
+            sh_addr: read_u64(image, base + 16)?,
+            sh_offset: read_u64(image, base + 24)?,
+            sh_size: read_u64(image, base + 32)?,
+            sh_entsize: read_u64(image, base + 56)?,
+        })
+    } else {
+        Some(SectionHeader {
+            sh_type: read_u32(image, base + 4)?,
+            sh_flags: u64::from(read_u32(image, base + 8)?),
+            sh_addr: u64::from(read_u32(image, base + 12)?),
+            sh_offset: u64::from(read_u32(image, base + 16)?),
+            sh_size: u64::from(read_u32(image, base + 20)?),
+            sh_entsize: u64::from(read_u32(image, base + 36)?),
+        })
+    }
+}
+
+fn parse_phdr(kind: ElfKind, image: &[u8], base: usize) -> Option<(u32, u32)> {
+    if kind.class() == 2 {
+        Some((read_u64(image, base + 8)? as u32, read_u64(image, base + 32)? as u32))
+    } else {
+        Some((read_u32(image, base + 4)?, read_u32(image, base + 16)?))
+    }
+}
+
+fn is_exec_section_thumb2(image: &[u8], section: &ExecHeader) -> bool {
+    if section.addr % 4 != 0 || section.size % 4 != 0 {
+        return true;
+    }
+    let start = section.offset as usize;
+    let end = start + section.size as usize;
+    let Some(data) = image.get(start..end) else { return true };
+    let mut num = 0usize;
+    let mut den = 0usize;
+    let mut cursor = 0usize;
+    while cursor + 4 <= data.len() {
+        if data[cursor + 3] & 0xF0 == 0xE0 {
+            num += 1;
+        }
+        den += 1;
+        cursor += 4;
+    }
+    num < (den as f64 * 0.4) as usize
+}
+
+fn intel_candidate(
+    kind: ElfKind,
+    image: &[u8],
+    cursor: usize,
+    region_end: usize,
+) -> Option<(usize, bool)> {
+    if cursor + 5 <= region_end {
+        let first = *image.get(cursor)?;
+        if first == 0xE8 || first == 0xE9 {
+            return Some((cursor + 1, false));
+        }
+    }
+    if cursor + 6 <= region_end {
+        let c0 = *image.get(cursor)?;
+        let c1 = *image.get(cursor + 1)?;
+        if c0 == 0x0F && (c1 & 0xF0) == 0x80 {
+            return Some((cursor + 2, false));
+        }
+        if kind == ElfKind::X64
+            && ((c0 == 0xFF && (c1 == 0x15 || c1 == 0x25))
+                || ((c0 == 0x89 || c0 == 0x8B || c0 == 0x8D) && (c1 & 0xC7) == 0x05))
+        {
+            return Some((cursor + 2, true));
+        }
+    }
+    None
+}
+
+fn align_gap_start_a32(gap_start: usize, gap_end: usize, is_thumb2: bool) -> usize {
+    if is_thumb2 {
+        if gap_end.saturating_sub(gap_start) < 2 {
+            return gap_end;
+        }
+        gap_start + increment_for_align_ceil2(gap_start as u64) as usize
+    } else {
+        if gap_end.saturating_sub(gap_start) < 4 {
+            return gap_end;
+        }
+        gap_start + increment_for_align_ceil4(gap_start as u64) as usize
+    }
+}
+
+/// Returns `(addr_type, target_rva, instruction_size)` for ARM mode.
+fn scan_arm32(image: &[u8], instr_rva: u32, location: u32) -> Option<(u8, u32, u32)> {
+    let code32 = arm::fetch_arm_code32(image, location);
+    arm::read_a24(instr_rva, code32).map(|target| (0u8, target, 4u32))
+}
+
+/// Returns `(addr_type, target_rva, instruction_size)` for THUMB2 mode.
+fn scan_thumb2(image: &[u8], instr_rva: u32, location: u32) -> Option<(u8, u32, u32)> {
+    let code16 = arm::fetch_thumb2_code16(image, location);
+    let instr_size = arm::get_thumb2_instruction_size(code16);
+    if instr_size == 2 {
+        if let Some(target) = arm::read_t8(instr_rva, code16) {
+            return Some((1, target, 2));
+        }
+        if let Some(target) = arm::read_t11(instr_rva, code16) {
+            return Some((2, target, 2));
+        }
+        return None;
+    }
+    let code32 = arm::fetch_thumb2_code32(image, location);
+    if let Some(target) = arm::read_t20(instr_rva, code32) {
+        return Some((3, target, 4));
+    }
+    if let Some(target) = arm::read_t24(instr_rva, code32) {
+        return Some((4, target, 4));
+    }
+    None
+}
+
+fn scan_aarch64(image: &[u8], instr_rva: u32, location: u32) -> Option<(u8, u32)> {
+    let code32 = arm::fetch_arm_code32(image, location);
+    if let Some(target) = arm::read_immd14(instr_rva, code32) {
+        return Some((0, target));
+    }
+    if let Some(target) = arm::read_immd19(instr_rva, code32) {
+        return Some((1, target));
+    }
+    if let Some(target) = arm::read_immd26(instr_rva, code32) {
+        return Some((2, target));
+    }
+    None
+}
+
+fn fetch_and_read_a32(
+    image: &[u8],
+    addr_type: usize,
+    location: u32,
+    instr_rva: u32,
+) -> Option<u32> {
+    match addr_type {
+        0 => arm::read_a24(instr_rva, arm::fetch_arm_code32(image, location)),
+        1 => arm::read_t8(instr_rva, arm::fetch_thumb2_code16(image, location)),
+        2 => arm::read_t11(instr_rva, arm::fetch_thumb2_code16(image, location)),
+        3 => arm::read_t20(instr_rva, arm::fetch_thumb2_code32(image, location)),
+        4 => arm::read_t24(instr_rva, arm::fetch_thumb2_code32(image, location)),
+        _ => None,
+    }
+}
+
+fn fetch_and_read_a64(
+    image: &[u8],
+    addr_type: usize,
+    location: u32,
+    instr_rva: u32,
+) -> Option<u32> {
+    let code32 = arm::fetch_arm_code32(image, location);
+    match addr_type {
+        0 => arm::read_immd14(instr_rva, code32),
+        1 => arm::read_immd19(instr_rva, code32),
+        2 => arm::read_immd26(instr_rva, code32),
+        _ => None,
+    }
+}
+
+fn write_arm32(
+    image: &mut [u8],
+    addr_type: usize,
+    location: u32,
+    instr_rva: u32,
+    target_rva: u32,
+) {
+    match addr_type {
+        0 => {
+            let mut code = arm::fetch_arm_code32(image, location);
+            if arm::write_a24(instr_rva, target_rva, &mut code) {
+                arm::store_arm_code32(image, location, code);
+            }
+        }
+        1 => {
+            let mut code = arm::fetch_thumb2_code16(image, location);
+            if arm::write_t8(instr_rva, target_rva, &mut code) {
+                arm::store_thumb2_code16(image, location, code);
+            }
+        }
+        2 => {
+            let mut code = arm::fetch_thumb2_code16(image, location);
+            if arm::write_t11(instr_rva, target_rva, &mut code) {
+                arm::store_thumb2_code16(image, location, code);
+            }
+        }
+        3 => {
+            let mut code = arm::fetch_thumb2_code32(image, location);
+            if arm::write_t20(instr_rva, target_rva, &mut code) {
+                arm::store_thumb2_code32(image, location, code);
+            }
+        }
+        4 => {
+            let mut code = arm::fetch_thumb2_code32(image, location);
+            if arm::write_t24(instr_rva, target_rva, &mut code) {
+                arm::store_thumb2_code32(image, location, code);
+            }
+        }
+        _ => {}
+    }
+}
+
+fn write_aarch64(
+    image: &mut [u8],
+    addr_type: usize,
+    location: u32,
+    instr_rva: u32,
+    target_rva: u32,
+) {
+    let mut code = arm::fetch_arm_code32(image, location);
+    let ok = match addr_type {
+        0 => arm::write_immd14(instr_rva, target_rva, &mut code),
+        1 => arm::write_immd19(instr_rva, target_rva, &mut code),
+        2 => arm::write_immd26(instr_rva, target_rva, &mut code),
+        _ => false,
+    };
+    if ok {
+        arm::store_arm_code32(image, location, code);
+    }
+}
+
+#[allow(dead_code)]
+fn _keep_helpers() {
+    let _ = write_u16;
+    let _ = range_is_bounded;
+    let _ = K_INVALID_OFFSET;
+    let _ = OFFSET_BOUND;
+}
diff --git a/src/zucchini_pure/engine.rs b/src/zucchini_pure/engine.rs
new file mode 100644
index 0000000..81e82b1
--- /dev/null
+++ b/src/zucchini_pure/engine.rs
@@ -0,0 +1,426 @@
+//! Format-independent apply engine: equivalences, extra data, raw deltas,
+//! reference correction, `OffsetMapper`, and `TargetPool`.
+
+use std::collections::BTreeMap;
+
+use super::bytes::{range_is_bounded, range_covers};
+use super::patch::{Equivalence, PatchElement};
+use super::{make_disassembler, Disassembler, Error, GroupTraits, Result, Status, K_INVALID_OFFSET, OFFSET_BOUND};
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct Reference {
+    pub location: u32,
+    pub target: u32,
+}
+
+pub(crate) struct NoOpDisassembler {
+    pub size: u32,
+}
+
+impl Disassembler for NoOpDisassembler {
+    fn size(&self) -> u32 {
+        self.size
+    }
+
+    fn groups(&self) -> &[GroupTraits] {
+        &[]
+    }
+
+    fn read(&self, _group: usize, _image: &[u8], _lo: u32, _hi: u32) -> Vec<Reference> {
+        Vec::new()
+    }
+
+    fn write(&self, _group: usize, _image: &mut [u8], _reference: Reference) {}
+}
+
+fn apply_error(message: impl Into<String>) -> Error {
+    Error::new(Status::ApplyError, message)
+}
+
+pub(crate) fn apply_element(
+    old: &[u8],
+    element: &PatchElement,
+    output: &mut [u8],
+) -> Result<()> {
+    let matching = &element.element_match;
+    let old_end = (matching.old_offset as usize)
+        .checked_add(matching.old_size as usize)
+        .ok_or_else(|| apply_error("old element range overflow"))?;
+    let new_end = (matching.new_offset as usize)
+        .checked_add(matching.new_size as usize)
+        .ok_or_else(|| apply_error("new element range overflow"))?;
+    let old_element = old
+        .get(matching.old_offset as usize..old_end)
+        .ok_or_else(|| apply_error("old element out of bounds"))?;
+    let new_element = output
+        .get_mut(matching.new_offset as usize..new_end)
+        .ok_or_else(|| apply_error("new element out of bounds"))?;
+
+    apply_equivalence_and_extra_data(old_element, element, new_element)?;
+    apply_raw_delta(element, new_element)?;
+    apply_references_correction(matching.exe_type, old_element, element, new_element)?;
+    Ok(())
+}
+
+/// Mirrors `ApplyEquivalenceAndExtraData`.
+fn apply_equivalence_and_extra_data(
+    old_image: &[u8],
+    element: &PatchElement,
+    new_image: &mut [u8],
+) -> Result<()> {
+    let mut extra_cursor = 0usize;
+    let mut dst_it = 0usize;
+
+    for equivalence in &element.equivalences {
+        let next_dst_it = equivalence.dst_offset as usize;
+        if next_dst_it < dst_it {
+            return Err(apply_error("overlapping equivalences"));
+        }
+        let gap = next_dst_it - dst_it;
+        let extra = take_extra(&element.extra_data, &mut extra_cursor, gap)?;
+        new_image
+            .get_mut(dst_it..next_dst_it)
+            .ok_or_else(|| apply_error("extra data out of bounds"))?
+            .copy_from_slice(extra);
+
+        let src_begin = equivalence.src_offset as usize;
+        let src_end = src_begin
+            .checked_add(equivalence.length as usize)
+            .ok_or_else(|| apply_error("equivalence source overflow"))?;
+        let dst_end = next_dst_it
+            .checked_add(equivalence.length as usize)
+            .ok_or_else(|| apply_error("equivalence destination overflow"))?;
+        let source = old_image
+            .get(src_begin..src_end)
+            .ok_or_else(|| apply_error("equivalence source out of bounds"))?;
+        new_image
+            .get_mut(next_dst_it..dst_end)
+            .ok_or_else(|| apply_error("equivalence destination out of bounds"))?
+            .copy_from_slice(source);
+        dst_it = dst_end;
+    }
+
+    let gap = new_image
+        .len()
+        .checked_sub(dst_it)
+        .ok_or_else(|| apply_error("extra data length mismatch"))?;
+    let extra = take_extra(&element.extra_data, &mut extra_cursor, gap)?;
+    new_image
+        .get_mut(dst_it..)
+        .ok_or_else(|| apply_error("extra data out of bounds"))?
+        .copy_from_slice(extra);
+
+    if !element.equivalences_done || extra_cursor != element.extra_data.len() {
+        return Err(apply_error("trailing equivalence or extra data"));
+    }
+    Ok(())
+}
+
+fn take_extra<'a>(extra: &'a [u8], cursor: &mut usize, size: usize) -> Result<&'a [u8]> {
+    let end = cursor
+        .checked_add(size)
+        .ok_or_else(|| apply_error("extra data length overflow"))?;
+    let slice = extra.get(*cursor..end).ok_or_else(|| apply_error("extra data exhausted"))?;
+    *cursor = end;
+    Ok(slice)
+}
+
+/// Mirrors `ApplyRawDelta`.
+fn apply_raw_delta(element: &PatchElement, new_image: &mut [u8]) -> Result<()> {
+    let mut base_copy_offset: u32 = 0;
+    let mut equivalence_index = 0usize;
+
+    for delta in &element.raw_deltas {
+        while equivalence_index < element.equivalences.len() {
+            let equivalence = element.equivalences[equivalence_index];
+            let end = base_copy_offset
+                .checked_add(equivalence.length)
+                .ok_or_else(|| apply_error("equivalence length overflow"))?;
+            if end <= delta.copy_offset {
+                base_copy_offset = end;
+                equivalence_index += 1;
+            } else {
+                break;
+            }
+        }
+        let equivalence = element
+            .equivalences
+            .get(equivalence_index)
+            .ok_or_else(|| apply_error("error reading equivalences"))?;
+        if delta.copy_offset < base_copy_offset
+            || delta.copy_offset
+                >= base_copy_offset
+                    .checked_add(equivalence.length)
+                    .ok_or_else(|| apply_error("equivalence length overflow"))?
+        {
+            return Err(apply_error("raw delta out of equivalence range"));
+        }
+        let index = equivalence
+            .dst_offset
+            .checked_sub(base_copy_offset)
+            .and_then(|value| value.checked_add(delta.copy_offset))
+            .ok_or_else(|| apply_error("raw delta destination overflow"))?;
+        let slot = new_image
+            .get_mut(index as usize)
+            .ok_or_else(|| apply_error("raw delta out of bounds"))?;
+        *slot = slot.wrapping_add(delta.diff as u8);
+    }
+
+    if !element.raw_deltas_done {
+        return Err(apply_error("found trailing raw delta"));
+    }
+    Ok(())
+}
+
+/// Mirrors `ApplyReferencesCorrection`.
+fn apply_references_correction(
+    exe_type: u32,
+    old_image: &[u8],
+    element: &PatchElement,
+    new_image: &mut [u8],
+) -> Result<()> {
+    let old_disasm = make_disassembler(exe_type, old_image)
+        .ok_or_else(|| apply_error("failed to create old disassembler"))?;
+    let new_disasm = make_disassembler(exe_type, new_image)
+        .ok_or_else(|| apply_error("failed to create new disassembler"))?;
+    if old_disasm.size() != old_image.len() as u32 || new_disasm.size() != new_image.len() as u32 {
+        return Err(apply_error("disassembler and element size mismatch"));
+    }
+
+    let old_groups = old_disasm.groups();
+    let new_groups = new_disasm.groups();
+    let mapper = OffsetMapper::new(
+        &element.equivalences,
+        old_image.len() as u32,
+        new_image.len() as u32,
+    );
+
+    let mut pools: BTreeMap<u8, Vec<usize>> = BTreeMap::new();
+    for (index, group) in old_groups.iter().enumerate() {
+        pools.entry(group.pool_tag).or_default().push(index);
+    }
+
+    let mut deltas = element.reference_deltas.iter();
+    for (pool_tag, sub_groups) in &pools {
+        let mut targets = TargetPool::default();
+        for &group_index in sub_groups {
+            let references = old_disasm.read(group_index, old_image, 0, old_image.len() as u32);
+            targets.insert_references(&references);
+        }
+        targets.filter_and_project(&mapper);
+
+        if let Some(extra) = element.extra_targets.get(pool_tag) {
+            targets.insert_targets(&extra.targets);
+            if !extra.done {
+                return Err(apply_error("found trailing extra targets"));
+            }
+        }
+
+        for &group_index in sub_groups {
+            let type_tag = old_groups[group_index].type_tag as usize;
+            if type_tag >= new_groups.len() {
+                return Err(apply_error("new reference group is missing"));
+            }
+            for equivalence in &element.equivalences {
+                let references = old_disasm.read(
+                    group_index,
+                    old_image,
+                    equivalence.src_offset,
+                    equivalence.src_end(),
+                );
+                for mut reference in references {
+                    let projected = mapper.extended_forward_project(reference.target);
+                    let expected_key = targets.key_for_nearest_offset(projected);
+                    let delta = deltas
+                        .next()
+                        .ok_or_else(|| apply_error("error reading reference delta"))?;
+                    let key = expected_key.wrapping_add(*delta as u32);
+                    if !targets.key_is_valid(key) {
+                        return Err(apply_error("invalid reference delta"));
+                    }
+                    reference.target = targets.offset_for_key(key);
+                    reference.location = reference
+                        .location
+                        .wrapping_sub(equivalence.src_offset)
+                        .wrapping_add(equivalence.dst_offset);
+                    new_disasm.write(type_tag, new_image, reference);
+                }
+            }
+        }
+    }
+
+    if deltas.next().is_some() {
+        return Err(apply_error("found trailing reference delta"));
+    }
+    Ok(())
+}
+
+/// Mirrors `OffsetMapper` in `equivalence_map.cc`.
+struct OffsetMapper {
+    equivalences: Vec<Equivalence>,
+    old_image_size: u32,
+    new_image_size: u32,
+}
+
+impl OffsetMapper {
+    fn new(source: &[Equivalence], old_image_size: u32, new_image_size: u32) -> Self {
+        let mut equivalences = source.to_vec();
+        PruneEquivalencesAndSortBySource::prune(&mut equivalences);
+        Self { equivalences, old_image_size, new_image_size }
+    }
+
+    fn naive_extended_forward_project(&self, unit: &Equivalence, offset: u32) -> u32 {
+        let value = offset as i64 - unit.src_offset as i64 + unit.dst_offset as i64;
+        let clamped = value.clamp(0, self.new_image_size as i64 - 1);
+        clamped as u32
+    }
+
+    fn extended_forward_project(&self, offset: u32) -> u32 {
+        if offset < self.old_image_size {
+            // First equivalence with `src_offset > offset`.
+            let pos = self
+                .equivalences
+                .partition_point(|equivalence| equivalence.src_offset <= offset);
+            let mut chosen = pos;
+            if pos != 0 {
+                let back = self.equivalences[pos - 1];
+                let take_back = pos == self.equivalences.len()
+                    || offset < back.src_end()
+                    || (offset - back.src_end()) < (self.equivalences[pos].src_offset - offset);
+                if take_back {
+                    chosen = pos - 1;
+                }
+            }
+            return self.naive_extended_forward_project(&self.equivalences[chosen], offset);
+        }
+        let delta = offset - self.old_image_size;
+        if delta < OFFSET_BOUND as u32 - self.new_image_size {
+            self.new_image_size + delta
+        } else {
+            (OFFSET_BOUND - 1) as u32
+        }
+    }
+
+    fn forward_project_all(&self, offsets: &mut Vec<u32>) {
+        let mut current = 0usize;
+        for source in offsets.iter_mut() {
+            while current < self.equivalences.len()
+                && self.equivalences[current].src_end() <= *source
+            {
+                current += 1;
+            }
+            if current < self.equivalences.len()
+                && self.equivalences[current].src_offset <= *source
+            {
+                *source = *source - self.equivalences[current].src_offset
+                    + self.equivalences[current].dst_offset;
+            } else {
+                *source = K_INVALID_OFFSET;
+            }
+        }
+        offsets.retain(|value| *value != K_INVALID_OFFSET);
+    }
+}
+
+/// Mirrors `OffsetMapper::PruneEquivalencesAndSortBySource`.
+struct PruneEquivalencesAndSortBySource;
+
+impl PruneEquivalencesAndSortBySource {
+    fn prune(equivalences: &mut Vec<Equivalence>) {
+        equivalences.sort_by_key(|equivalence| equivalence.src_offset);
+
+        let mut current = 0usize;
+        while current < equivalences.len() {
+            let mut next_is_reaper = false;
+            let mut next = current + 1;
+            while next < equivalences.len() {
+                if equivalences[next].src_offset >= equivalences[current].src_end() {
+                    break;
+                }
+                if equivalences[current].length < equivalences[next].length {
+                    let delta =
+                        equivalences[current].src_end() - equivalences[next].src_offset;
+                    equivalences[current].length -= delta;
+                    next_is_reaper = true;
+                    break;
+                }
+                next += 1;
+            }
+
+            if next_is_reaper {
+                for reduced in (current + 1)..next {
+                    equivalences[reduced].length = 0;
+                }
+                current = next;
+            } else {
+                for reduced in (current + 1)..next {
+                    let delta =
+                        equivalences[current].src_end() - equivalences[reduced].src_offset;
+                    let shrink = equivalences[reduced].length.min(delta);
+                    equivalences[reduced].length -= shrink;
+                    equivalences[reduced].src_offset += delta;
+                    equivalences[reduced].dst_offset += delta;
+                }
+                current += 1;
+            }
+        }
+
+        equivalences.retain(|equivalence| equivalence.length != 0);
+    }
+}
+
+/// Mirrors `TargetPool`.
+#[derive(Default)]
+struct TargetPool {
+    targets: Vec<u32>,
+}
+
+impl TargetPool {
+    fn sort_and_uniquify(&mut self) {
+        self.targets.sort_unstable();
+        self.targets.dedup();
+    }
+
+    fn insert_references(&mut self, references: &[Reference]) {
+        self.targets.extend(references.iter().map(|reference| reference.target));
+        self.sort_and_uniquify();
+    }
+
+    fn insert_targets(&mut self, targets: &[u32]) {
+        self.targets.extend_from_slice(targets);
+        self.sort_and_uniquify();
+    }
+
+    fn filter_and_project(&mut self, mapper: &OffsetMapper) {
+        mapper.forward_project_all(&mut self.targets);
+        self.targets.sort_unstable();
+    }
+
+    /// Mirrors `KeyForNearestOffset`, including its lower-key tie-breaking.
+    fn key_for_nearest_offset(&self, offset: u32) -> u32 {
+        let mut pos = self.targets.partition_point(|target| *target < offset);
+        if pos != 0 {
+            if pos == self.targets.len()
+                || self.targets[pos] - offset >= offset - self.targets[pos - 1]
+            {
+                pos -= 1;
+            }
+        }
+        pos as u32
+    }
+
+    fn offset_for_key(&self, key: u32) -> u32 {
+        self.targets[key as usize]
+    }
+
+    fn key_is_valid(&self, key: u32) -> bool {
+        (key as usize) < self.targets.len()
+    }
+}
+
+/// Keeps the range helpers referenced for later DEX validation code.
+#[allow(dead_code)]
+fn _range_helpers() {
+    let _ = range_covers;
+    let _ = range_is_bounded;
+}
diff --git a/src/zucchini_pure/mod.rs b/src/zucchini_pure/mod.rs
new file mode 100644
index 0000000..3bb4ffe
--- /dev/null
+++ b/src/zucchini_pure/mod.rs
@@ -0,0 +1,173 @@
+//! Pure-Rust, apply-only reimplementation of the Zucchini executable patcher.
+//!
+//! The native implementation vendored for this crate links the upstream C++
+//! `components/zucchini` sources plus libchrome. This module is an independent
+//! Rust port of the apply path (no C++ and no libchrome). It targets exactly
+//! the element formats that Android delta OTA payloads use: `NoOp`, ELF
+//! x86/x86-64/AArch32/AArch64, and DEX.
+//!
+//! Scope and status are documented in `docs/zucchini-rust-port.md`.
+
+use std::error;
+use std::fmt;
+
+mod arm;
+pub mod bytes;
+mod crc32;
+mod dex;
+mod elf;
+mod engine;
+pub mod patch;
+
+pub use engine::Reference;
+pub use elf::ElfDisassembler;
+
+/// Exclusive upper bound for buffers represented by Zucchini offsets.
+pub const OFFSET_BOUND: usize = (u32::MAX / 2) as usize;
+/// `0xFFFFFFFE`, distinct from the fake-offset sentinel used by DEX indices.
+pub const K_INVALID_OFFSET: u32 = 0xFFFF_FFFE;
+pub const K_INVALID_RVA: u32 = 0xFFFF_FFFE;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Status {
+    InvalidArgument,
+    InvalidPatch,
+    UnsupportedElement,
+    WrongOutputSize,
+    ApplyError,
+    AllocationFailure,
+    UnsupportedTarget,
+    Unknown(i32),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Error {
+    status: Status,
+    message: String,
+}
+
+impl Error {
+    pub fn status(&self) -> Status {
+        self.status
+    }
+
+    pub(crate) fn new(status: Status, message: impl Into<String>) -> Self {
+        Self { status, message: message.into() }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter.write_str(&self.message)
+    }
+}
+
+impl error::Error for Error {}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// A parsed reference type within an executable element.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct GroupTraits {
+    pub width: u32,
+    pub type_tag: u8,
+    pub pool_tag: u8,
+}
+
+/// The reference-correction interface implemented by each element format.
+pub trait Disassembler {
+    /// Size of the recognized executable, after header parsing shrinks the view.
+    fn size(&self) -> u32;
+
+    /// Reference groups, in the native `MakeReferenceGroups()` order.
+    fn groups(&self) -> &[GroupTraits];
+
+    /// Emits references of `group` whose bodies lie in `[lo, hi)`.
+    fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Vec<Reference>;
+
+    /// Writes a single corrected reference into the new image.
+    fn write(&self, group: usize, image: &mut [u8], reference: Reference);
+}
+
+/// Applies a Zucchini patch into a newly allocated, exact-size output buffer.
+pub fn apply(old: &[u8], patch_bytes: &[u8], output_size: usize) -> Result<Vec<u8>> {
+    if old.len() >= OFFSET_BOUND || output_size >= OFFSET_BOUND {
+        return Err(Error::new(Status::InvalidArgument, "image exceeds Zucchini offset bound"));
+    }
+    if patch_bytes.len() >= OFFSET_BOUND {
+        return Err(Error::new(Status::InvalidArgument, "patch exceeds Zucchini offset bound"));
+    }
+
+    let patch = patch::Patch::parse(patch_bytes)?;
+    if patch.header.new_size as usize != output_size {
+        return Err(Error::new(Status::WrongOutputSize, "output buffer size does not match patch"));
+    }
+    if !patch::check_old_file(&patch.header, old) {
+        return Err(Error::new(Status::ApplyError, "invalid old image"));
+    }
+
+    // Reject element formats that Android never emits, matching the native FFI
+    // allow-list (NoOp plus Android executables).
+    for element in &patch.elements {
+        if element.element_match.exe_type != patch::EXE_TYPE_NOOP
+            && !is_android_executable(element.element_match.exe_type)
+        {
+            return Err(Error::new(
+                Status::UnsupportedElement,
+                "element format is not enabled by Android",
+            ));
+        }
+    }
+
+    let mut output = Vec::new();
+    output.try_reserve_exact(output_size).map_err(|error| {
+        Error::new(Status::AllocationFailure, format!("unable to allocate Zucchini output: {error}"))
+    })?;
+    output.resize(output_size, 0);
+
+    for element in &patch.elements {
+        engine::apply_element(old, element, &mut output)?;
+    }
+
+    if !patch::check_new_file(&patch.header, &output) {
+        return Err(Error::new(Status::ApplyError, "invalid new image"));
+    }
+    Ok(output)
+}
+
+fn is_android_executable(exe_type: u32) -> bool {
+    matches!(
+        exe_type,
+        patch::EXE_TYPE_ELF_X86
+            | patch::EXE_TYPE_ELF_X64
+            | patch::EXE_TYPE_ELF_AARCH32
+            | patch::EXE_TYPE_ELF_AARCH64
+            | patch::EXE_TYPE_DEX
+    )
+}
+
+/// Dispatches to the format disassembler for `exe_type`, parsing `image`.
+pub(crate) fn make_disassembler(
+    exe_type: u32,
+    image: &[u8],
+) -> Option<Box<dyn Disassembler>> {
+    match exe_type {
+        patch::EXE_TYPE_NOOP => Some(Box::new(engine::NoOpDisassembler { size: image.len() as u32 })),
+        patch::EXE_TYPE_ELF_X86 => {
+            elf::ElfDisassembler::parse(elf::ElfKind::X86, image).map(|d| Box::new(d) as _)
+        }
+        patch::EXE_TYPE_ELF_X64 => {
+            elf::ElfDisassembler::parse(elf::ElfKind::X64, image).map(|d| Box::new(d) as _)
+        }
+        patch::EXE_TYPE_ELF_AARCH32 => {
+            elf::ElfDisassembler::parse(elf::ElfKind::AArch32, image).map(|d| Box::new(d) as _)
+        }
+        patch::EXE_TYPE_ELF_AARCH64 => {
+            elf::ElfDisassembler::parse(elf::ElfKind::AArch64, image).map(|d| Box::new(d) as _)
+        }
+        patch::EXE_TYPE_DEX => {
+            dex::DexDisassembler::parse(image).map(|d| Box::new(d) as _)
+        }
+        _ => None,
+    }
+}
diff --git a/src/zucchini_pure/patch.rs b/src/zucchini_pure/patch.rs
new file mode 100644
index 0000000..16b5a12
--- /dev/null
+++ b/src/zucchini_pure/patch.rs
@@ -0,0 +1,474 @@
+//! Parsing for the Zucchini ensemble patch format.
+//!
+//! This mirrors `components/zucchini/patch_reader.{h,cc}` and
+//! `components/zucchini/patch_utils.h`, including the stream-termination
+//! semantics that the native apply path relies on.
+
+use std::collections::BTreeMap;
+
+use super::bytes::read_u16;
+use super::bytes::read_u32;
+use super::{Error, Result, Status};
+
+/// Magic signature `'Z' | ('u' << 8) | ('c' << 16) | ('c' << 24)`.
+pub const PATCH_MAGIC: u32 = u32::from_le_bytes(*b"Zucc");
+pub const MAJOR_VERSION: u16 = 1;
+pub const K_INVALID_VERSION: u16 = 0xFFFF;
+
+pub const EXE_TYPE_NOOP: u32 = u32::from_le_bytes(*b"NoOp");
+pub const EXE_TYPE_ELF_X86: u32 = u32::from_le_bytes(*b"Ex86");
+pub const EXE_TYPE_ELF_X64: u32 = u32::from_le_bytes(*b"Ex64");
+pub const EXE_TYPE_ELF_AARCH32: u32 = u32::from_le_bytes(*b"EA32");
+pub const EXE_TYPE_ELF_AARCH64: u32 = u32::from_le_bytes(*b"EA64");
+pub const EXE_TYPE_DEX: u32 = u32::from_le_bytes(*b"DEX ");
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct PatchHeader {
+    pub magic: u32,
+    pub major_version: u16,
+    pub minor_version: u16,
+    pub old_size: u32,
+    pub old_crc: u32,
+    pub new_size: u32,
+    pub new_crc: u32,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct ElementMatch {
+    pub old_offset: u32,
+    pub old_size: u32,
+    pub new_offset: u32,
+    pub new_size: u32,
+    pub exe_type: u32,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct Equivalence {
+    pub src_offset: u32,
+    pub dst_offset: u32,
+    pub length: u32,
+}
+
+impl Equivalence {
+    pub fn src_end(&self) -> u32 {
+        self.src_offset.wrapping_add(self.length)
+    }
+
+    pub fn dst_end(&self) -> u32 {
+        self.dst_offset.wrapping_add(self.length)
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct RawDeltaUnit {
+    pub copy_offset: u32,
+    pub diff: i8,
+}
+
+#[derive(Clone, Debug)]
+pub struct PatchElement {
+    pub element_match: ElementMatch,
+    pub equivalences: Vec<Equivalence>,
+    /// Whether every equivalence stream was fully consumed (native `Done()`).
+    pub equivalences_done: bool,
+    pub extra_data: Vec<u8>,
+    pub raw_deltas: Vec<RawDeltaUnit>,
+    pub raw_deltas_done: bool,
+    pub reference_deltas: Vec<i32>,
+    pub reference_deltas_done: bool,
+    pub extra_targets: BTreeMap<u8, ExtraTargets>,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct ExtraTargets {
+    pub targets: Vec<u32>,
+    pub done: bool,
+}
+
+#[derive(Clone, Debug)]
+pub struct Patch {
+    pub header: PatchHeader,
+    pub elements: Vec<PatchElement>,
+}
+
+struct Cursor<'a> {
+    data: &'a [u8],
+    pos: usize,
+}
+
+impl<'a> Cursor<'a> {
+    fn new(data: &'a [u8]) -> Self {
+        Self { data, pos: 0 }
+    }
+
+    fn remaining(&self) -> usize {
+        self.data.len().saturating_sub(self.pos)
+    }
+
+    fn empty(&self) -> bool {
+        self.remaining() == 0
+    }
+
+    fn take(&mut self, count: usize) -> Option<&'a [u8]> {
+        let end = self.pos.checked_add(count)?;
+        let slice = self.data.get(self.pos..end)?;
+        self.pos = end;
+        Some(slice)
+    }
+
+    fn u8(&mut self) -> Option<u8> {
+        let value = *self.data.get(self.pos)?;
+        self.pos += 1;
+        Some(value)
+    }
+
+    fn u16(&mut self) -> Option<u16> {
+        let value = read_u16(self.data, self.pos)?;
+        self.pos += 2;
+        Some(value)
+    }
+
+    fn u32(&mut self) -> Option<u32> {
+        let value = read_u32(self.data, self.pos)?;
+        self.pos += 4;
+        Some(value)
+    }
+
+    /// Decodes a `uint32_t` base-128 varint, mirroring `DecodeVarUInt`.
+    fn var_u32(&mut self) -> Option<u32> {
+        let mut value = 0u32;
+        for shift in (0..32).step_by(7) {
+            let byte = self.u8()?;
+            value |= u32::from(byte & 0x7F) << shift;
+            if byte < 0x80 {
+                return Some(value);
+            }
+        }
+        None
+    }
+
+    /// Decodes an `int32_t` zig-zag varint, mirroring `DecodeVarInt`.
+    fn var_i32(&mut self) -> Option<i32> {
+        let tmp = self.var_u32()?;
+        if tmp & 1 != 0 {
+            Some(!((tmp >> 1) as i32))
+        } else {
+            Some((tmp >> 1) as i32)
+        }
+    }
+
+    /// Mirrors `patch::ParseBuffer`: a `uint32_t` size followed by that many bytes.
+    fn buffer(&mut self) -> Option<&'a [u8]> {
+        let size = self.u32()? as usize;
+        self.take(size)
+    }
+}
+
+fn invalid_patch(message: &str) -> Error {
+    Error { status: Status::InvalidPatch, message: message.into() }
+}
+
+fn executable_version(exe_type: u32) -> Option<u16> {
+    match exe_type {
+        EXE_TYPE_NOOP
+        | EXE_TYPE_ELF_X86
+        | EXE_TYPE_ELF_X64
+        | EXE_TYPE_ELF_AARCH32
+        | EXE_TYPE_ELF_AARCH64
+        | EXE_TYPE_DEX => Some(1),
+        _ => None,
+    }
+}
+
+fn parse_element_match(cursor: &mut Cursor<'_>) -> Option<ElementMatch> {
+    let old_offset = cursor.u32()?;
+    let old_size = cursor.u32()?;
+    let new_offset = cursor.u32()?;
+    let new_size = cursor.u32()?;
+    let exe_type = cursor.u32()?;
+    let version = cursor.u16()?;
+    let expected = executable_version(exe_type)?;
+    if expected != version {
+        return None;
+    }
+    if old_size == 0 || new_size == 0 {
+        return None;
+    }
+    Some(ElementMatch { old_offset, old_size, new_offset, new_size, exe_type })
+}
+
+/// Decodes all equivalences and reports whether the three streams were fully
+/// consumed, matching `EquivalenceSource::Done()`.
+fn parse_equivalences(
+    src_skip: &[u8],
+    dst_skip: &[u8],
+    copy_count: &[u8],
+) -> (Vec<Equivalence>, bool) {
+    let mut src = Cursor::new(src_skip);
+    let mut dst = Cursor::new(dst_skip);
+    let mut count = Cursor::new(copy_count);
+    let mut result = Vec::new();
+    let mut previous_src: u32 = 0;
+    let mut previous_dst: u32 = 0;
+    while !src.empty() && !dst.empty() && !count.empty() {
+        let length = match count.var_u32() {
+            Some(value) => value,
+            None => break,
+        };
+        let src_diff = match src.var_i32() {
+            Some(value) => value,
+            None => break,
+        };
+        let src_offset = match (previous_src as i64).checked_add(src_diff as i64) {
+            Some(value) if (0..=u32::MAX as i64).contains(&value) => value as u32,
+            _ => break,
+        };
+        previous_src = match src_offset.checked_add(length) {
+            Some(value) => value,
+            None => break,
+        };
+        let dst_diff = match dst.var_u32() {
+            Some(value) => value,
+            None => break,
+        };
+        let dst_offset = match previous_dst.checked_add(dst_diff) {
+            Some(value) => value,
+            None => break,
+        };
+        previous_dst = match dst_offset.checked_add(length) {
+            Some(value) => value,
+            None => break,
+        };
+        result.push(Equivalence { src_offset, dst_offset, length });
+    }
+    let done = src.empty() && dst.empty() && count.empty();
+    (result, done)
+}
+
+fn parse_raw_deltas(skip: &[u8], diffs: &[u8]) -> (Vec<RawDeltaUnit>, bool) {
+    let mut skip = Cursor::new(skip);
+    let mut diffs = Cursor::new(diffs);
+    let mut result = Vec::new();
+    let mut compensation: u32 = 0;
+    while !skip.empty() && !diffs.empty() {
+        let diff = match skip.var_u32() {
+            Some(value) => value,
+            None => break,
+        };
+        let copy_offset = match diff.checked_add(compensation) {
+            Some(value) => value,
+            None => break,
+        };
+        let byte = match diffs.u8() {
+            Some(value) => value,
+            None => break,
+        };
+        let byte_diff = byte as i8;
+        if byte_diff == 0 {
+            break;
+        }
+        compensation = match copy_offset.checked_add(1) {
+            Some(value) => value,
+            None => break,
+        };
+        result.push(RawDeltaUnit { copy_offset, diff: byte_diff });
+    }
+    let done = skip.empty() && diffs.empty();
+    (result, done)
+}
+
+fn parse_reference_deltas(source: &[u8]) -> (Vec<i32>, bool) {
+    let mut cursor = Cursor::new(source);
+    let mut result = Vec::new();
+    while !cursor.empty() {
+        match cursor.var_i32() {
+            Some(value) => result.push(value),
+            None => break,
+        }
+    }
+    (result, cursor.empty())
+}
+
+fn parse_extra_targets(source: &[u8]) -> ExtraTargets {
+    let mut cursor = Cursor::new(source);
+    let mut targets = Vec::new();
+    let mut compensation: u32 = 0;
+    while !cursor.empty() {
+        let diff = match cursor.var_u32() {
+            Some(value) => value,
+            None => break,
+        };
+        let target = match diff.checked_add(compensation) {
+            Some(value) => value,
+            None => break,
+        };
+        compensation = match target.checked_add(1) {
+            Some(value) => value,
+            None => break,
+        };
+        targets.push(target);
+    }
+    ExtraTargets { targets, done: cursor.empty() }
+}
+
+impl PatchElement {
+    fn parse(cursor: &mut Cursor<'_>) -> Result<Self> {
+        let element_match =
+            parse_element_match(cursor).ok_or_else(|| invalid_patch("invalid patch element"))?;
+
+        let src_skip = cursor
+            .buffer()
+            .ok_or_else(|| invalid_patch("invalid equivalence source"))?;
+        let dst_skip = cursor
+            .buffer()
+            .ok_or_else(|| invalid_patch("invalid equivalence source"))?;
+        let copy_count = cursor
+            .buffer()
+            .ok_or_else(|| invalid_patch("invalid equivalence source"))?;
+        let (equivalences, equivalences_done) =
+            parse_equivalences(src_skip, dst_skip, copy_count);
+        let extra_data = cursor
+            .buffer()
+            .ok_or_else(|| invalid_patch("invalid extra data"))?
+            .to_vec();
+
+        // Mirrors ValidateEquivalencesAndExtraData().
+        let old_region_size = u64::from(element_match.old_size);
+        let new_region_size = u64::from(element_match.new_size);
+        let mut total_length: u64 = 0;
+        let mut previous_dst_end: u64 = 0;
+        for equivalence in &equivalences {
+            if !super::bytes::range_is_bounded(
+                u64::from(equivalence.src_offset),
+                u64::from(equivalence.length),
+                old_region_size,
+            ) || !super::bytes::range_is_bounded(
+                u64::from(equivalence.dst_offset),
+                u64::from(equivalence.length),
+                new_region_size,
+            ) {
+                return Err(invalid_patch("out of bounds equivalence"));
+            }
+            if previous_dst_end > u64::from(equivalence.dst_end()) {
+                return Err(invalid_patch("out of order equivalence"));
+            }
+            previous_dst_end = u64::from(equivalence.dst_end());
+            total_length += u64::from(equivalence.length);
+        }
+        if total_length > new_region_size
+            || extra_data.len() as u64 != new_region_size - total_length
+        {
+            return Err(invalid_patch("incorrect amount of extra data"));
+        }
+
+        let raw_skip = cursor
+            .buffer()
+            .ok_or_else(|| invalid_patch("invalid raw delta source"))?;
+        let raw_diff = cursor
+            .buffer()
+            .ok_or_else(|| invalid_patch("invalid raw delta source"))?;
+        let (raw_deltas, raw_deltas_done) = parse_raw_deltas(raw_skip, raw_diff);
+
+        let reference_source = cursor
+            .buffer()
+            .ok_or_else(|| invalid_patch("invalid reference delta source"))?;
+        let (reference_deltas, reference_deltas_done) =
+            parse_reference_deltas(reference_source);
+
+        let pool_count = cursor
+            .u32()
+            .ok_or_else(|| invalid_patch("invalid extra target list"))?;
+        let mut extra_targets = BTreeMap::new();
+        for _ in 0..pool_count {
+            let pool_tag = cursor
+                .u8()
+                .ok_or_else(|| invalid_patch("invalid extra target list"))?;
+            if pool_tag == 0xFF {
+                return Err(invalid_patch("invalid pool tag"));
+            }
+            let source = cursor
+                .buffer()
+                .ok_or_else(|| invalid_patch("invalid extra target list"))?;
+            if extra_targets.insert(pool_tag, parse_extra_targets(source)).is_some() {
+                return Err(invalid_patch("duplicate pool tag"));
+            }
+        }
+
+        Ok(PatchElement {
+            element_match,
+            equivalences,
+            equivalences_done,
+            extra_data,
+            raw_deltas,
+            raw_deltas_done,
+            reference_deltas,
+            reference_deltas_done,
+            extra_targets,
+        })
+    }
+}
+
+impl Patch {
+    pub fn parse(data: &[u8]) -> Result<Self> {
+        let mut cursor = Cursor::new(data);
+        let header = PatchHeader {
+            magic: cursor.u32().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
+            major_version: cursor.u16().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
+            minor_version: cursor.u16().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
+            old_size: cursor.u32().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
+            old_crc: cursor.u32().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
+            new_size: cursor.u32().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
+            new_crc: cursor.u32().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
+        };
+        if header.magic != PATCH_MAGIC || header.major_version != MAJOR_VERSION {
+            return Err(invalid_patch("invalid ensemble patch"));
+        }
+        let element_count = cursor
+            .u32()
+            .ok_or_else(|| invalid_patch("invalid ensemble patch"))?;
+        let mut elements = Vec::new();
+        let mut current_dst_offset: u32 = 0;
+        for _ in 0..element_count {
+            let element = PatchElement::parse(&mut cursor)?;
+            if !region_fits(element.element_match.old_offset, element.element_match.old_size, header.old_size)
+                || !region_fits(
+                    element.element_match.new_offset,
+                    element.element_match.new_size,
+                    header.new_size,
+                )
+            {
+                return Err(invalid_patch("invalid patch element"));
+            }
+            if element.element_match.new_offset != current_dst_offset {
+                return Err(invalid_patch("invalid patch element"));
+            }
+            current_dst_offset = element
+                .element_match
+                .new_offset
+                .checked_add(element.element_match.new_size)
+                .ok_or_else(|| invalid_patch("invalid patch element"))?;
+            elements.push(element);
+        }
+        if current_dst_offset != header.new_size {
+            return Err(invalid_patch("patch elements do not fully cover new image"));
+        }
+        if !cursor.empty() {
+            return Err(invalid_patch("patch was not fully consumed"));
+        }
+        Ok(Patch { header, elements })
+    }
+}
+
+fn region_fits(offset: u32, size: u32, container: u32) -> bool {
+    offset <= container && container - offset >= size
+}
+
+pub fn check_old_file(header: &PatchHeader, old_image: &[u8]) -> bool {
+    old_image.len() == header.old_size as usize
+        && super::crc32::calculate_crc32(old_image) == header.old_crc
+}
+
+pub fn check_new_file(header: &PatchHeader, new_image: &[u8]) -> bool {
+    new_image.len() == header.new_size as usize
+        && super::crc32::calculate_crc32(new_image) == header.new_crc
+}

From d72a53f8fba3e65adc133a660dc849a2314218b8 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 17:36:09 +0530
Subject: [PATCH 17/42] zucchini: pure-Rust DEX apply support

Port the full DisassemblerDex apply path: header/map parsing, code-item
and item-offset parsing, all 42 reference groups (readers and writers),
instruction parsing, and the 16/32-bit index and relative-code codecs.

All seven zucchini fixtures now reconstruct byte-exactly with no C++.
---
 src/zucchini_pure/bytes.rs |    4 +
 src/zucchini_pure/dex.rs   | 1270 +++++++++++++++++++++++++++++++++++-
 2 files changed, 1260 insertions(+), 14 deletions(-)

diff --git a/src/zucchini_pure/bytes.rs b/src/zucchini_pure/bytes.rs
index 591b2eb..10358a9 100644
--- a/src/zucchini_pure/bytes.rs
+++ b/src/zucchini_pure/bytes.rs
@@ -13,6 +13,10 @@ pub fn read_i16(data: &[u8], offset: usize) -> Option<i16> {
     Some(read_u16(data, offset)? as i16)
 }
 
+pub fn read_i8(data: &[u8], offset: usize) -> Option<i8> {
+    Some(read_u8(data, offset)? as i8)
+}
+
 pub fn read_u32(data: &[u8], offset: usize) -> Option<u32> {
     let bytes = data.get(offset..offset.checked_add(4)?)?;
     Some(u32::from_le_bytes(bytes.try_into().ok()?))
diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
index 9841e15..0690b94 100644
--- a/src/zucchini_pure/dex.rs
+++ b/src/zucchini_pure/dex.rs
@@ -1,31 +1,1273 @@
-//! DEX disassembler (apply path).
-//!
-//! Placeholder: the full port of `disassembler_dex.cc` is tracked in
-//! `docs/zucchini-rust-port.md`. Until it lands, DEX elements are reported as
-//! unsupported by the pure-Rust engine.
+//! Pure-Rust port of `disassembler_dex.cc` for the apply path.
 
-use super::{Disassembler, GroupTraits, Reference};
+use std::collections::BTreeMap;
 
-pub struct DexDisassembler;
+use super::bytes::{align_ceil, read_i16, read_i32, read_i8, read_u16, read_u32, write_u16, write_u32};
+use super::{Disassembler, GroupTraits, Reference, K_INVALID_OFFSET, OFFSET_BOUND};
+
+const HEADER_SIZE: usize = 112;
+const CODE_ITEM_HEADER: usize = 16;
+const MAP_ITEM_SIZE: usize = 12;
+const K_MAX_ITEM_LIST_SIZE: u32 = 21;
+const K_MAX_LEB128_SIZE: usize = 5;
+const SENTINEL_OFFSET: u32 = 0;
+const SENTINEL_INDEX: u32 = 0xFFFF_FFFF;
+
+// Map item type codes.
+const T_STRING_ID: u16 = 0x0001;
+const T_TYPE_ID: u16 = 0x0002;
+const T_PROTO_ID: u16 = 0x0003;
+const T_FIELD_ID: u16 = 0x0004;
+const T_METHOD_ID: u16 = 0x0005;
+const T_CLASS_DEF: u16 = 0x0006;
+const T_CALL_SITE_ID: u16 = 0x0007;
+const T_METHOD_HANDLE: u16 = 0x0008;
+const T_TYPE_LIST: u16 = 0x1001;
+const T_ANNOTATION_SET_REF_LIST: u16 = 0x1002;
+const T_ANNOTATION_SET_ITEM: u16 = 0x1003;
+const T_CODE_ITEM: u16 = 0x2001;
+const T_ANNOTATIONS_DIRECTORY: u16 = 0x2006;
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+struct MapItem {
+    size: u32,
+    offset: u32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum Format {
+    B,
+    C,
+    H,
+    I,
+    L,
+    N,
+    S,
+    T,
+    X,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct Bytecode {
+    layout: u8,
+    format: Format,
+}
+
+/// `dex::kByteCode`, expanded into a flat 256-entry opcode table.
+const BYTECODE: &[(u8, u8, Format, u8)] = &[
+    (0x00, 1, Format::X, 1),
+    (0x01, 1, Format::X, 1),
+    (0x02, 2, Format::X, 1),
+    (0x03, 3, Format::X, 1),
+    (0x04, 1, Format::X, 1),
+    (0x05, 2, Format::X, 1),
+    (0x06, 3, Format::X, 1),
+    (0x07, 1, Format::X, 1),
+    (0x08, 2, Format::X, 1),
+    (0x09, 3, Format::X, 1),
+    (0x0A, 1, Format::X, 1),
+    (0x0B, 1, Format::X, 1),
+    (0x0C, 1, Format::X, 1),
+    (0x0D, 1, Format::X, 1),
+    (0x0E, 1, Format::X, 1),
+    (0x0F, 1, Format::X, 1),
+    (0x10, 1, Format::X, 1),
+    (0x11, 1, Format::X, 1),
+    (0x12, 1, Format::N, 1),
+    (0x13, 2, Format::S, 1),
+    (0x14, 3, Format::I, 1),
+    (0x15, 2, Format::H, 1),
+    (0x16, 2, Format::S, 1),
+    (0x17, 3, Format::I, 1),
+    (0x18, 5, Format::L, 1),
+    (0x19, 2, Format::H, 1),
+    (0x1A, 2, Format::C, 1),
+    (0x1B, 3, Format::C, 1),
+    (0x1C, 2, Format::C, 1),
+    (0x1D, 1, Format::X, 1),
+    (0x1E, 1, Format::X, 1),
+    (0x1F, 2, Format::C, 1),
+    (0x20, 2, Format::C, 1),
+    (0x21, 1, Format::X, 1),
+    (0x22, 2, Format::C, 1),
+    (0x23, 2, Format::C, 1),
+    (0x24, 3, Format::C, 1),
+    (0x25, 3, Format::C, 1),
+    (0x26, 3, Format::T, 1),
+    (0x27, 1, Format::X, 1),
+    (0x28, 1, Format::T, 1),
+    (0x29, 2, Format::T, 1),
+    (0x2A, 3, Format::T, 1),
+    (0x2B, 3, Format::T, 1),
+    (0x2C, 3, Format::T, 1),
+    (0x2D, 2, Format::X, 5),
+    (0x32, 2, Format::T, 6),
+    (0x38, 2, Format::T, 6),
+    (0x44, 2, Format::X, 14),
+    (0x52, 2, Format::C, 14),
+    (0x60, 2, Format::C, 14),
+    (0x6E, 3, Format::C, 5),
+    (0x74, 3, Format::C, 5),
+    (0x7B, 1, Format::X, 21),
+    (0x90, 2, Format::X, 32),
+    (0xB0, 1, Format::X, 32),
+    (0xD0, 2, Format::S, 8),
+    (0xD8, 2, Format::B, 11),
+    (0xFA, 4, Format::C, 1),
+    (0xFB, 4, Format::C, 1),
+    (0xFC, 3, Format::C, 1),
+    (0xFD, 3, Format::C, 1),
+    (0xFE, 2, Format::C, 1),
+    (0xFF, 2, Format::C, 1),
+];
+
+fn find_instruction(opcode: u8) -> Option<Bytecode> {
+    BYTECODE
+        .iter()
+        .find(|(start, _, _, variant)| {
+            opcode >= *start && opcode < start.wrapping_add(*variant)
+        })
+        .map(|(_, layout, format, _)| Bytecode { layout: *layout, format: *format })
+}
+
+#[derive(Clone, Debug)]
+pub struct DexDisassembler {
+    size: u32,
+    groups: Vec<GroupTraits>,
+    string_map: MapItem,
+    type_map: MapItem,
+    proto_map: MapItem,
+    field_map: MapItem,
+    method_map: MapItem,
+    class_def_map: MapItem,
+    call_site_map: MapItem,
+    method_handle_map: MapItem,
+    code_map: MapItem,
+    code_item_offsets: Vec<u32>,
+    type_list_offsets: Vec<u32>,
+    annotation_set_ref_list_offsets: Vec<u32>,
+    annotation_set_offsets: Vec<u32>,
+    annotations_directory_item_offsets: Vec<u32>,
+    field_annotation_offsets: Vec<u32>,
+    method_annotation_offsets: Vec<u32>,
+    parameter_annotation_offsets: Vec<u32>,
+}
+
+fn get_item_base_size(kind: u16) -> usize {
+    match kind {
+        T_STRING_ID => 4,
+        T_TYPE_ID => 4,
+        T_PROTO_ID => 12,
+        T_FIELD_ID => 8,
+        T_METHOD_ID => 8,
+        T_CLASS_DEF => 32,
+        T_CALL_SITE_ID => 4,
+        T_METHOD_HANDLE => 8,
+        T_TYPE_LIST => 4,
+        T_ANNOTATION_SET_REF_LIST => 4,
+        T_ANNOTATION_SET_ITEM => 4,
+        T_CODE_ITEM => CODE_ITEM_HEADER,
+        T_ANNOTATIONS_DIRECTORY => 16,
+        _ => 1,
+    }
+}
+
+fn covers_array(image: &[u8], offset: usize, num: usize, elt_size: usize) -> bool {
+    if elt_size == 0 {
+        return false;
+    }
+    offset <= image.len() && (image.len() - offset) / elt_size >= num
+}
 
 impl DexDisassembler {
-    pub fn parse(_image: &[u8]) -> Option<Self> {
-        None
+    pub fn parse(image: &[u8]) -> Option<Self> {
+        let (file_size, map_off) = read_dex_header(image)?;
+        let image = &image[..file_size as usize];
+
+        let list_start = map_off as usize;
+        let list_size = read_u32(image, list_start)?;
+        if list_size > K_MAX_ITEM_LIST_SIZE {
+            return None;
+        }
+        let items_start = list_start.checked_add(4)?;
+        let items_end = items_start.checked_add(list_size as usize * MAP_ITEM_SIZE)?;
+        if items_end > image.len() {
+            return None;
+        }
+        let mut map: BTreeMap<u16, MapItem> = BTreeMap::new();
+        for index in 0..list_size as usize {
+            let base = items_start + index * MAP_ITEM_SIZE;
+            let kind = read_u16(image, base)?;
+            let size = read_u32(image, base + 4)?;
+            let offset = read_u32(image, base + 8)?;
+            let item_size = get_item_base_size(kind);
+            if !covers_array(image, offset as usize, size as usize, item_size) {
+                return None;
+            }
+            if map.insert(kind, MapItem { size, offset }).is_some() {
+                return None;
+            }
+        }
+
+        let get = |kind: u16| *map.get(&kind).unwrap_or(&MapItem::default());
+
+        let type_list_map = get(T_TYPE_LIST);
+        let annotation_set_ref_map = get(T_ANNOTATION_SET_REF_LIST);
+        let annotation_set_map = get(T_ANNOTATION_SET_ITEM);
+        let annotations_directory_map = get(T_ANNOTATIONS_DIRECTORY);
+        let code_map = get(T_CODE_ITEM);
+
+        let type_list_offsets = parse_item_offsets(image, type_list_map, 2)?;
+        let annotation_set_ref_list_offsets =
+            parse_item_offsets(image, annotation_set_ref_map, 4)?;
+        let annotation_set_offsets = parse_item_offsets(image, annotation_set_map, 4)?;
+        let (
+            annotations_directory_item_offsets,
+            field_annotation_offsets,
+            method_annotation_offsets,
+            parameter_annotation_offsets,
+        ) = parse_annotations_directory_items(image, annotations_directory_map)?;
+
+        let code_item_offsets = parse_code_item_offsets(image, code_map)?;
+        if code_item_offsets.is_empty() {
+            return None;
+        }
+
+        Some(DexDisassembler {
+            size: file_size,
+            groups: build_groups(),
+            string_map: get(T_STRING_ID),
+            type_map: get(T_TYPE_ID),
+            proto_map: get(T_PROTO_ID),
+            field_map: get(T_FIELD_ID),
+            method_map: get(T_METHOD_ID),
+            class_def_map: get(T_CLASS_DEF),
+            call_site_map: get(T_CALL_SITE_ID),
+            method_handle_map: get(T_METHOD_HANDLE),
+            code_map,
+            code_item_offsets,
+            type_list_offsets,
+            annotation_set_ref_list_offsets,
+            annotation_set_offsets,
+            annotations_directory_item_offsets,
+            field_annotation_offsets,
+            method_annotation_offsets,
+            parameter_annotation_offsets,
+        })
+    }
+}
+
+fn read_dex_header(image: &[u8]) -> Option<(u32, u32)> {
+    if image.len() < HEADER_SIZE {
+        return None;
+    }
+    let magic = &image[..8];
+    if &magic[..4] != b"dex\n" || magic[7] != 0 {
+        return None;
+    }
+    let mut version = 0u32;
+    for &byte in &magic[4..7] {
+        if !byte.is_ascii_digit() {
+            return None;
+        }
+        version = version * 10 + u32::from(byte - b'0');
+    }
+    if !matches!(version, 35 | 37 | 38 | 39) {
+        return None;
+    }
+    let file_size = read_u32(image, 32)?;
+    let map_off = read_u32(image, 52)?;
+    if file_size > image.len() as u32 || file_size < HEADER_SIZE as u32 || map_off < HEADER_SIZE as u32
+    {
+        return None;
+    }
+    Some((file_size, map_off))
+}
+
+fn parse_item_offsets(
+    image: &[u8],
+    map_item: MapItem,
+    item_width: usize,
+) -> Option<Vec<u32>> {
+    if !covers_array(image, map_item.offset as usize, map_item.size as usize, 4) {
+        return None;
+    }
+    let mut offsets = Vec::new();
+    let mut pos = map_item.offset as usize;
+    for _ in 0..map_item.size {
+        // AlignOn(image, 4).
+        let aligned = align_ceil(pos as u64, 4) as usize;
+        if aligned > image.len() {
+            return None;
+        }
+        pos = aligned;
+        let count = read_u32(image, pos)? as usize;
+        pos += 4;
+        if (image.len() - pos) / item_width < count {
+            return None;
+        }
+        for _ in 0..count {
+            offsets.push(pos as u32);
+            pos += item_width;
+        }
+    }
+    Some(offsets)
+}
+
+fn parse_annotations_directory_items(
+    image: &[u8],
+    map_item: MapItem,
+) -> Option<(Vec<u32>, Vec<u32>, Vec<u32>, Vec<u32>)> {
+    if !covers_array(image, map_item.offset as usize, map_item.size as usize, 16) {
+        return None;
+    }
+    let mut directory_offsets = Vec::new();
+    let mut field_offsets = Vec::new();
+    let mut method_offsets = Vec::new();
+    let mut parameter_offsets = Vec::new();
+    let mut pos = map_item.offset as usize;
+
+    let mut parse_list = |pos: &mut usize, count: u32, width: usize, out: &mut Vec<u32>| -> Option<()> {
+        if (image.len() - *pos) / width < count as usize {
+            return None;
+        }
+        for _ in 0..count {
+            out.push(*pos as u32);
+            *pos += width;
+        }
+        Some(())
+    };
+
+    for _ in 0..map_item.size {
+        let aligned = align_ceil(pos as u64, 4) as usize;
+        if aligned > image.len() {
+            return None;
+        }
+        pos = aligned;
+        if pos + 16 > image.len() {
+            return None;
+        }
+        directory_offsets.push(pos as u32);
+        let class_annotations_off = read_u32(image, pos)?;
+        let fields_size = read_u32(image, pos + 4)?;
+        let methods_size = read_u32(image, pos + 8)?;
+        let parameters_size = read_u32(image, pos + 12)?;
+        let _ = class_annotations_off;
+        pos += 16;
+        parse_list(&mut pos, fields_size, 8, &mut field_offsets)?;
+        parse_list(&mut pos, methods_size, 8, &mut method_offsets)?;
+        parse_list(&mut pos, parameters_size, 8, &mut parameter_offsets)?;
+    }
+    Some((directory_offsets, field_offsets, method_offsets, parameter_offsets))
+}
+
+fn parse_code_item_offsets(image: &[u8], code_map: MapItem) -> Option<Vec<u32>> {
+    if !covers_array(image, code_map.offset as usize, code_map.size as usize, CODE_ITEM_HEADER) {
+        return None;
+    }
+    let mut parser = CodeItemParser::new(code_map.offset as usize);
+    let mut offsets = Vec::with_capacity(code_map.size as usize);
+    for _ in 0..code_map.size {
+        offsets.push(parser.get_next(image)?);
+    }
+    Some(offsets)
+}
+
+struct CodeItemParser {
+    pos: usize,
+}
+
+impl CodeItemParser {
+    fn new(pos: usize) -> Self {
+        Self { pos }
+    }
+
+    fn get_next(&mut self, image: &[u8]) -> Option<u32> {
+        let aligned = align_ceil(self.pos as u64, 4) as usize;
+        if aligned > image.len() {
+            return None;
+        }
+        self.pos = aligned;
+        let code_item_offset = self.pos;
+        if self.pos + CODE_ITEM_HEADER > image.len() {
+            return None;
+        }
+        let tries_size = read_u16(image, self.pos + 6)? as usize;
+        let insns_size = read_u32(image, self.pos + 12)? as usize;
+        self.pos += CODE_ITEM_HEADER;
+        let insns_bytes = insns_size.checked_mul(2)?;
+        self.pos = self.pos.checked_add(insns_bytes)?;
+        if self.pos > image.len() {
+            return None;
+        }
+        if tries_size > 0 {
+            let aligned = align_ceil(self.pos as u64, 4) as usize;
+            if aligned > image.len() {
+                return None;
+            }
+            self.pos = aligned;
+            self.pos = self.pos.checked_add(tries_size.checked_mul(8)?)?;
+            if self.pos > image.len() {
+                return None;
+            }
+            let handlers_size = get_uleb128(image, &mut self.pos)?;
+            if image.len() - self.pos < handlers_size as usize {
+                return None;
+            }
+            for _ in 0..handlers_size {
+                let encoded_size = get_sleb128(image, &mut self.pos)?;
+                let abs_size = encoded_size.unsigned_abs() as usize;
+                if image.len() - self.pos < abs_size {
+                    return None;
+                }
+                for _ in 0..abs_size {
+                    if !skip_leb128(image, &mut self.pos) || !skip_leb128(image, &mut self.pos) {
+                        return None;
+                    }
+                }
+                if encoded_size <= 0 && !skip_leb128(image, &mut self.pos) {
+                    return None;
+                }
+            }
+        }
+        Some(code_item_offset as u32)
+    }
+}
+
+fn get_uleb128(image: &[u8], pos: &mut usize) -> Option<u32> {
+    let limit = K_MAX_LEB128_SIZE.min(image.len() - *pos) * 7;
+    let mut value = 0u32;
+    let mut shift = 0usize;
+    while shift < limit {
+        let byte = *image.get(*pos)?;
+        *pos += 1;
+        value |= u32::from(byte & 0x7F) << shift;
+        if byte & 0x80 == 0 {
+            return Some(value);
+        }
+        shift += 7;
+    }
+    None
+}
+
+fn get_sleb128(image: &[u8], pos: &mut usize) -> Option<i32> {
+    let limit = K_MAX_LEB128_SIZE.min(image.len() - *pos) * 7;
+    let mut value: i32 = 0;
+    let mut shift = 0usize;
+    while shift < limit {
+        let byte = *image.get(*pos)?;
+        *pos += 1;
+        value |= ((u32::from(byte & 0x7F)) << shift) as i32;
+        if byte & 0x80 == 0 {
+            return Some(if shift == 28 {
+                value
+            } else {
+                let num_bits = 32i32;
+                let s = num_bits - 1 - (shift as i32 + 6);
+                (value << s) >> s
+            });
+        }
+        shift += 7;
+    }
+    None
+}
+
+fn skip_leb128(image: &[u8], pos: &mut usize) -> bool {
+    let limit = K_MAX_LEB128_SIZE.min(image.len() - *pos);
+    for _ in 0..limit {
+        let byte = match image.get(*pos) {
+            Some(byte) => *byte,
+            None => return false,
+        };
+        *pos += 1;
+        if byte & 0x80 == 0 {
+            return true;
+        }
+    }
+    false
+}
+
+fn build_groups() -> Vec<GroupTraits> {
+    const WIDTHS: [u32; 42] = [
+        4, 4, 4, 4, 4, 2, 4, 4, 2, 2, 2, 4, 4, 2, 2, 2, 2, 2, 2, 4, 2, 2, 4, 4, 2, 2, 4, 4, 4,
+        4, 4, 4, 4, 4, 1, 2, 4, 4, 4, 4, 4, 4,
+    ];
+    const POOLS: [u8; 42] = [
+        0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 6, 7, 7, 8,
+        9, 9, 9, 9, 10, 11, 11, 11, 12, 13, 14, 15, 16,
+    ];
+    (0..42)
+        .map(|index| GroupTraits {
+            width: WIDTHS[index],
+            type_tag: index as u8,
+            pool_tag: POOLS[index],
+        })
+        .collect()
+}
+
+// Readers.
+
+#[derive(Clone, Copy)]
+enum ItemMapper {
+    TargetIndex { map: MapItem, item_size: u32, width: u8 },
+    TargetOffset32,
+    MethodHandle { map: MapItem, item_size: u32, min_type: u16, max_type: u16 },
+}
+
+#[derive(Clone, Copy)]
+enum ListMapper {
+    TargetIndex { map: MapItem, item_size: u32 },
+    TargetOffset32,
+}
+
+#[derive(Clone, Copy)]
+enum InstrMapper {
+    TargetIndex { map: MapItem, item_size: u32, width: u8 },
+    RelCode8,
+    RelCode16,
+    RelCode32,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+enum CodeFilter {
+    String16,
+    String32,
+    Type,
+    Proto,
+    CallSite,
+    MethodHandle,
+    Field,
+    Method,
+    Rel8,
+    Rel16,
+    Rel32,
+}
+
+fn read_target_index(
+    image: &[u8],
+    map: MapItem,
+    item_size: u32,
+    location: u32,
+    width: u8,
+) -> u32 {
+    let unsafe_idx = if width == 2 {
+        u32::from(read_u16(image, location as usize).unwrap_or(0))
+    } else {
+        read_u32(image, location as usize).unwrap_or(0)
+    };
+    if width == 4 && unsafe_idx == SENTINEL_INDEX {
+        return SENTINEL_INDEX;
+    }
+    if unsafe_idx >= map.size {
+        return K_INVALID_OFFSET;
+    }
+    map.offset.wrapping_add(unsafe_idx.wrapping_mul(item_size))
+}
+
+fn read_target_offset32(image: &[u8], location: u32) -> u32 {
+    let target = read_u32(image, location as usize).unwrap_or(0);
+    if target == SENTINEL_OFFSET {
+        return SENTINEL_OFFSET;
+    }
+    if target as usize >= image.len() {
+        return K_INVALID_OFFSET;
+    }
+    target
+}
+
+fn read_method_handle_field_or_method_id(
+    image: &[u8],
+    map: MapItem,
+    item_size: u32,
+    min_type: u16,
+    max_type: u16,
+    location: u32,
+) -> u32 {
+    let method_handle_type = read_u16(image, location as usize).unwrap_or(0);
+    if method_handle_type >= 0x09 {
+        return K_INVALID_OFFSET;
+    }
+    if method_handle_type < min_type || method_handle_type > max_type {
+        return SENTINEL_INDEX;
+    }
+    read_target_index(image, map, item_size, location + 4, 2)
+}
+
+fn run_item_mapper(mapper: ItemMapper, image: &[u8], input: u32) -> u32 {
+    match mapper {
+        ItemMapper::TargetIndex { map, item_size, width } => {
+            read_target_index(image, map, item_size, input, width)
+        }
+        ItemMapper::TargetOffset32 => read_target_offset32(image, input),
+        ItemMapper::MethodHandle { map, item_size, min_type, max_type } => {
+            read_method_handle_field_or_method_id(image, map, item_size, min_type, max_type, input)
+        }
+    }
+}
+
+fn run_list_mapper(mapper: ListMapper, image: &[u8], location: u32) -> u32 {
+    match mapper {
+        ListMapper::TargetIndex { map, item_size } => {
+            read_target_index(image, map, item_size, location, 2)
+        }
+        ListMapper::TargetOffset32 => read_target_offset32(image, location),
+    }
+}
+
+fn item_reader(
+    image: &[u8],
+    lo: u32,
+    hi: u32,
+    map: MapItem,
+    item_size: u32,
+    rel_location: u32,
+    mapper: ItemMapper,
+    wants_item: bool,
+) -> Vec<Reference> {
+    let item_base_offset = map.offset;
+    let num_items = map.size;
+    let mapper_input_delta = if wants_item { 0 } else { rel_location };
+    let offset_of_index = |index: u32| item_base_offset.wrapping_add(index.wrapping_mul(item_size));
+
+    let mut cur_idx: u32;
+    if item_base_offset == 0 {
+        cur_idx = num_items;
+    } else if lo < item_base_offset {
+        cur_idx = 0;
+    } else if lo < offset_of_index(num_items) {
+        cur_idx = (lo - item_base_offset) / item_size;
+        if lo > offset_of_index(cur_idx).wrapping_add(rel_location) {
+            cur_idx += 1;
+        }
+    } else {
+        cur_idx = num_items;
+    }
+
+    let mut result = Vec::new();
+    while cur_idx < num_items {
+        let item_offset = offset_of_index(cur_idx);
+        let location = item_offset.wrapping_add(rel_location);
+        if location >= hi {
+            break;
+        }
+        let target = run_item_mapper(mapper, image, item_offset.wrapping_add(mapper_input_delta));
+        if target == SENTINEL_OFFSET || target == SENTINEL_INDEX {
+            cur_idx += 1;
+            continue;
+        }
+        if target == K_INVALID_OFFSET {
+            break;
+        }
+        cur_idx += 1;
+        if location >= lo {
+            result.push(Reference { location, target });
+        }
+    }
+    result
+}
+
+fn cached_item_list_reader(
+    image: &[u8],
+    lo: u32,
+    hi: u32,
+    rel_location: u32,
+    offsets: &[u32],
+    mapper: ListMapper,
+) -> Vec<Reference> {
+    let mut index = offsets.partition_point(|offset| *offset <= lo);
+    if index != 0 && offsets[index - 1].wrapping_add(rel_location) >= lo {
+        index -= 1;
+    }
+    let mut result = Vec::new();
+    while index < offsets.len() {
+        let location = offsets[index].wrapping_add(rel_location);
+        if location >= hi {
+            break;
+        }
+        let target = run_list_mapper(mapper, image, location);
+        if target == K_INVALID_OFFSET {
+            break;
+        }
+        index += 1;
+        if target == SENTINEL_OFFSET {
+            continue;
+        }
+        result.push(Reference { location, target });
+    }
+    result
+}
+
+#[derive(Clone, Copy)]
+struct InstructionValue {
+    instr_offset: u32,
+    opcode: u8,
+    format: Format,
+}
+
+fn code_item_insns(image: &[u8], base_offset: u32) -> Option<(usize, usize)> {
+    let base = base_offset as usize;
+    if base + CODE_ITEM_HEADER > image.len() {
+        return None;
+    }
+    let insns_size = read_u32(image, base + 12)? as usize;
+    let start = base + CODE_ITEM_HEADER;
+    let end = start.checked_add(insns_size.checked_mul(2)?)?;
+    if end > image.len() {
+        return None;
+    }
+    Some((start, end))
+}
+
+fn parse_instructions(image: &[u8], base_offset: u32) -> Vec<InstructionValue> {
+    let Some((insns_start, insns_end)) = code_item_insns(image, base_offset) else {
+        return Vec::new();
+    };
+    let mut pos = insns_start;
+    let mut boundary = insns_end;
+    let mut result = Vec::new();
+    while pos < boundary {
+        let opcode = image[pos];
+        let Some(instruction) = find_instruction(opcode) else { break };
+        let length_bytes = instruction.layout as usize * 2;
+        if insns_end - pos < length_bytes {
+            break;
+        }
+        if opcode == 0x26 || opcode == 0x2B || opcode == 0x2C {
+            let payload_rel = read_i32(image, pos + 2).unwrap_or(0);
+            if payload_rel < i32::from(instruction.layout)
+                || payload_rel as u32 >= (insns_end - insns_start) as u32 / 2
+            {
+                break;
+            }
+            boundary = boundary.min(pos + payload_rel as usize * 2);
+        }
+        result.push(InstructionValue {
+            instr_offset: pos as u32,
+            opcode,
+            format: instruction.format,
+        });
+        pos += length_bytes;
+    }
+    result
+}
+
+fn filter_location(filter: CodeFilter, value: InstructionValue) -> Option<u32> {
+    let format_c = value.format == Format::C;
+    let format_t = value.format == Format::T;
+    let location = match filter {
+        CodeFilter::String16 if format_c && value.opcode == 0x1A => value.instr_offset + 2,
+        CodeFilter::String32 if format_c && value.opcode == 0x1B => value.instr_offset + 2,
+        CodeFilter::Type
+            if format_c
+                && matches!(value.opcode, 0x1C | 0x1F | 0x20 | 0x22 | 0x23 | 0x24 | 0x25) =>
+        {
+            value.instr_offset + 2
+        }
+        CodeFilter::Proto if format_c && matches!(value.opcode, 0xFA | 0xFB) => {
+            value.instr_offset + 6
+        }
+        CodeFilter::Proto if format_c && value.opcode == 0xFF => value.instr_offset + 2,
+        CodeFilter::CallSite if format_c && matches!(value.opcode, 0xFC | 0xFD) => {
+            value.instr_offset + 2
+        }
+        CodeFilter::MethodHandle if format_c && value.opcode == 0xFE => value.instr_offset + 2,
+        CodeFilter::Field if format_c && matches!(value.opcode, 0x52 | 0x60) => {
+            value.instr_offset + 2
+        }
+        CodeFilter::Method
+            if format_c && matches!(value.opcode, 0x6E | 0x74 | 0xFA | 0xFB) =>
+        {
+            value.instr_offset + 2
+        }
+        CodeFilter::Rel8 if format_t && value.opcode == 0x28 => value.instr_offset + 1,
+        CodeFilter::Rel16 if format_t && matches!(value.opcode, 0x29 | 0x32 | 0x38) => {
+            value.instr_offset + 2
+        }
+        CodeFilter::Rel32 if format_t && matches!(value.opcode, 0x26 | 0x2A | 0x2B | 0x2C) => {
+            value.instr_offset + 2
+        }
+        _ => return None,
+    };
+    Some(location)
+}
+
+fn run_instr_mapper(mapper: InstrMapper, image: &[u8], location: u32) -> u32 {
+    match mapper {
+        InstrMapper::TargetIndex { map, item_size, width } => {
+            read_target_index(image, map, item_size, location, width)
+        }
+        InstrMapper::RelCode8 => {
+            let delta = read_i8(image, location as usize).unwrap_or(0) as i32;
+            location.wrapping_add((delta - 1).wrapping_mul(2) as u32)
+        }
+        InstrMapper::RelCode16 => {
+            let delta = read_i16(image, location as usize).unwrap_or(0) as i32;
+            location.wrapping_add((delta - 1).wrapping_mul(2) as u32)
+        }
+        InstrMapper::RelCode32 => {
+            let delta = read_i32(image, location as usize).unwrap_or(0);
+            let target = i64::from(location) + i64::from(delta - 1) * 2;
+            if !(0..=u32::MAX as i64).contains(&target) || target >= i64::from(OFFSET_BOUND as u32) {
+                K_INVALID_OFFSET
+            } else {
+                target as u32
+            }
+        }
+    }
+}
+
+fn instruction_reader(
+    image: &[u8],
+    lo: u32,
+    hi: u32,
+    code_item_offsets: &[u32],
+    filter: CodeFilter,
+    mapper: InstrMapper,
+) -> Vec<Reference> {
+    if code_item_offsets.is_empty() {
+        return Vec::new();
+    }
+    let mut index = code_item_offsets.partition_point(|offset| *offset <= lo);
+    if index != 0 {
+        index -= 1;
+    }
+    let mut result = Vec::new();
+    loop {
+        for value in parse_instructions(image, code_item_offsets[index]) {
+            if value.instr_offset >= hi {
+                return result;
+            }
+            let Some(location) = filter_location(filter, value) else { continue };
+            if location == K_INVALID_OFFSET || location < lo {
+                continue;
+            }
+            if location >= hi {
+                return result;
+            }
+            let target = run_instr_mapper(mapper, image, location);
+            if target != K_INVALID_OFFSET {
+                result.push(Reference { location, target });
+            }
+        }
+        index += 1;
+        if index >= code_item_offsets.len() {
+            return result;
+        }
+    }
+}
+
+// Writers.
+
+#[derive(Clone, Copy)]
+enum WriteKind {
+    StringId16,
+    StringId32,
+    TypeId16,
+    TypeId32,
+    ProtoId16,
+    FieldId16,
+    FieldId32,
+    MethodId16,
+    MethodId32,
+    CallSiteId16,
+    MethodHandle16,
+    Abs32,
+    RelCode8,
+    RelCode16,
+    RelCode32,
+}
+
+fn write_kind(group: usize) -> WriteKind {
+    match group {
+        0 | 1 | 2 | 3 | 4 | 6 => WriteKind::StringId32,
+        5 => WriteKind::StringId16,
+        7 | 11 | 12 => WriteKind::TypeId32,
+        8 | 9 | 10 | 13 | 14 => WriteKind::TypeId16,
+        15 | 16 => WriteKind::ProtoId16,
+        17 | 18 => WriteKind::FieldId16,
+        19 => WriteKind::FieldId32,
+        20 | 21 => WriteKind::MethodId16,
+        22 | 23 => WriteKind::MethodId32,
+        24 => WriteKind::CallSiteId16,
+        25 => WriteKind::MethodHandle16,
+        34 => WriteKind::RelCode8,
+        35 => WriteKind::RelCode16,
+        36 => WriteKind::RelCode32,
+        _ => WriteKind::Abs32,
+    }
+}
+
+impl DexDisassembler {
+    fn write_target_index(
+        &self,
+        image: &mut [u8],
+        map: MapItem,
+        item_size: u32,
+        reference: Reference,
+        width: u8,
+    ) {
+        let unsafe_idx = reference.target.wrapping_sub(map.offset) / item_size;
+        if unsafe_idx >= map.size {
+            return;
+        }
+        if width == 2 {
+            let _ = write_u16(image, reference.location as usize, unsafe_idx as u16);
+        } else {
+            let _ = write_u32(image, reference.location as usize, unsafe_idx);
+        }
     }
 }
 
 impl Disassembler for DexDisassembler {
     fn size(&self) -> u32 {
-        0
+        self.size
     }
 
     fn groups(&self) -> &[GroupTraits] {
-        &[]
+        &self.groups
     }
 
-    fn read(&self, _group: usize, _image: &[u8], _lo: u32, _hi: u32) -> Vec<Reference> {
-        Vec::new()
+    #[allow(clippy::too_many_lines)]
+    fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Vec<Reference> {
+        let string_index = |width: u8| ItemMapper::TargetIndex {
+            map: self.string_map,
+            item_size: 4,
+            width,
+        };
+        let type_index = |width: u8| ItemMapper::TargetIndex {
+            map: self.type_map,
+            item_size: 4,
+            width,
+        };
+        let proto_index = ItemMapper::TargetIndex { map: self.proto_map, item_size: 12, width: 2 };
+        match group {
+            0 => item_reader(image, lo, hi, self.type_map, 4, 0, string_index(2), false),
+            1 => item_reader(image, lo, hi, self.proto_map, 12, 0, string_index(4), false),
+            2 => item_reader(image, lo, hi, self.field_map, 8, 4, string_index(4), false),
+            3 => item_reader(image, lo, hi, self.method_map, 8, 4, string_index(4), false),
+            4 => item_reader(image, lo, hi, self.class_def_map, 32, 16, string_index(4), false),
+            5 => instruction_reader(
+                image,
+                lo,
+                hi,
+                &self.code_item_offsets,
+                CodeFilter::String16,
+                InstrMapper::TargetIndex { map: self.string_map, item_size: 4, width: 2 },
+            ),
+            6 => instruction_reader(
+                image,
+                lo,
+                hi,
+                &self.code_item_offsets,
+                CodeFilter::String32,
+                InstrMapper::TargetIndex { map: self.string_map, item_size: 4, width: 4 },
+            ),
+            7 => item_reader(image, lo, hi, self.proto_map, 12, 4, type_index(4), false),
+            8 => item_reader(image, lo, hi, self.field_map, 8, 0, type_index(2), false),
+            9 => item_reader(image, lo, hi, self.field_map, 8, 2, type_index(2), false),
+            10 => item_reader(image, lo, hi, self.method_map, 8, 0, type_index(2), false),
+            11 => item_reader(image, lo, hi, self.class_def_map, 32, 0, type_index(4), false),
+            12 => item_reader(image, lo, hi, self.class_def_map, 32, 8, type_index(4), false),
+            13 => cached_item_list_reader(
+                image,
+                lo,
+                hi,
+                0,
+                &self.type_list_offsets,
+                ListMapper::TargetIndex { map: self.type_map, item_size: 4 },
+            ),
+            14 => instruction_reader(
+                image,
+                lo,
+                hi,
+                &self.code_item_offsets,
+                CodeFilter::Type,
+                InstrMapper::TargetIndex { map: self.type_map, item_size: 4, width: 2 },
+            ),
+            15 => instruction_reader(
+                image,
+                lo,
+                hi,
+                &self.code_item_offsets,
+                CodeFilter::Proto,
+                InstrMapper::TargetIndex { map: self.proto_map, item_size: 12, width: 2 },
+            ),
+            16 => item_reader(image, lo, hi, self.method_map, 8, 2, proto_index, false),
+            17 => instruction_reader(
+                image,
+                lo,
+                hi,
+                &self.code_item_offsets,
+                CodeFilter::Field,
+                InstrMapper::TargetIndex { map: self.field_map, item_size: 8, width: 2 },
+            ),
+            18 => item_reader(
+                image,
+                lo,
+                hi,
+                self.method_handle_map,
+                8,
+                2,
+                ItemMapper::MethodHandle {
+                    map: self.field_map,
+                    item_size: 8,
+                    min_type: 0,
+                    max_type: 3,
+                },
+                true,
+            ),
+            19 => cached_item_list_reader(
+                image,
+                lo,
+                hi,
+                0,
+                &self.field_annotation_offsets,
+                ListMapper::TargetIndex { map: self.field_map, item_size: 8 },
+            ),
+            20 => instruction_reader(
+                image,
+                lo,
+                hi,
+                &self.code_item_offsets,
+                CodeFilter::Method,
+                InstrMapper::TargetIndex { map: self.method_map, item_size: 8, width: 2 },
+            ),
+            21 => item_reader(
+                image,
+                lo,
+                hi,
+                self.method_handle_map,
+                8,
+                2,
+                ItemMapper::MethodHandle {
+                    map: self.method_map,
+                    item_size: 8,
+                    min_type: 4,
+                    max_type: 8,
+                },
+                true,
+            ),
+            22 => cached_item_list_reader(
+                image,
+                lo,
+                hi,
+                0,
+                &self.method_annotation_offsets,
+                ListMapper::TargetIndex { map: self.method_map, item_size: 8 },
+            ),
+            23 => cached_item_list_reader(
+                image,
+                lo,
+                hi,
+                0,
+                &self.parameter_annotation_offsets,
+                ListMapper::TargetIndex { map: self.method_map, item_size: 8 },
+            ),
+            24 => instruction_reader(
+                image,
+                lo,
+                hi,
+                &self.code_item_offsets,
+                CodeFilter::CallSite,
+                InstrMapper::TargetIndex { map: self.call_site_map, item_size: 4, width: 2 },
+            ),
+            25 => instruction_reader(
+                image,
+                lo,
+                hi,
+                &self.code_item_offsets,
+                CodeFilter::MethodHandle,
+                InstrMapper::TargetIndex { map: self.method_handle_map, item_size: 8, width: 2 },
+            ),
+            26 => item_reader(image, lo, hi, self.proto_map, 12, 8, ItemMapper::TargetOffset32, false),
+            27 => item_reader(
+                image,
+                lo,
+                hi,
+                self.class_def_map,
+                32,
+                12,
+                ItemMapper::TargetOffset32,
+                false,
+            ),
+            28 => cached_item_list_reader(
+                image,
+                lo,
+                hi,
+                4,
+                &self.parameter_annotation_offsets,
+                ListMapper::TargetOffset32,
+            ),
+            29 => cached_item_list_reader(
+                image,
+                lo,
+                hi,
+                0,
+                &self.annotation_set_ref_list_offsets,
+                ListMapper::TargetOffset32,
+            ),
+            30 => cached_item_list_reader(
+                image,
+                lo,
+                hi,
+                0,
+                &self.annotations_directory_item_offsets,
+                ListMapper::TargetOffset32,
+            ),
+            31 => cached_item_list_reader(
+                image,
+                lo,
+                hi,
+                4,
+                &self.field_annotation_offsets,
+                ListMapper::TargetOffset32,
+            ),
+            32 => cached_item_list_reader(
+                image,
+                lo,
+                hi,
+                4,
+                &self.method_annotation_offsets,
+                ListMapper::TargetOffset32,
+            ),
+            33 => item_reader(
+                image,
+                lo,
+                hi,
+                self.class_def_map,
+                32,
+                24,
+                ItemMapper::TargetOffset32,
+                false,
+            ),
+            34 => instruction_reader(
+                image,
+                lo,
+                hi,
+                &self.code_item_offsets,
+                CodeFilter::Rel8,
+                InstrMapper::RelCode8,
+            ),
+            35 => instruction_reader(
+                image,
+                lo,
+                hi,
+                &self.code_item_offsets,
+                CodeFilter::Rel16,
+                InstrMapper::RelCode16,
+            ),
+            36 => instruction_reader(
+                image,
+                lo,
+                hi,
+                &self.code_item_offsets,
+                CodeFilter::Rel32,
+                InstrMapper::RelCode32,
+            ),
+            37 => item_reader(image, lo, hi, self.string_map, 4, 0, ItemMapper::TargetOffset32, false),
+            38 => cached_item_list_reader(
+                image,
+                lo,
+                hi,
+                0,
+                &self.annotation_set_offsets,
+                ListMapper::TargetOffset32,
+            ),
+            39 => item_reader(
+                image,
+                lo,
+                hi,
+                self.class_def_map,
+                32,
+                28,
+                ItemMapper::TargetOffset32,
+                false,
+            ),
+            40 => item_reader(
+                image,
+                lo,
+                hi,
+                self.class_def_map,
+                32,
+                20,
+                ItemMapper::TargetOffset32,
+                false,
+            ),
+            41 => item_reader(
+                image,
+                lo,
+                hi,
+                self.call_site_map,
+                4,
+                0,
+                ItemMapper::TargetOffset32,
+                false,
+            ),
+            _ => Vec::new(),
+        }
     }
 
-    fn write(&self, _group: usize, _image: &mut [u8], _reference: Reference) {}
+    fn write(&self, group: usize, image: &mut [u8], reference: Reference) {
+        match write_kind(group) {
+            WriteKind::StringId16 => {
+                self.write_target_index(image, self.string_map, 4, reference, 2);
+            }
+            WriteKind::StringId32 => {
+                self.write_target_index(image, self.string_map, 4, reference, 4);
+            }
+            WriteKind::TypeId16 => {
+                self.write_target_index(image, self.type_map, 4, reference, 2);
+            }
+            WriteKind::TypeId32 => {
+                self.write_target_index(image, self.type_map, 4, reference, 4);
+            }
+            WriteKind::ProtoId16 => {
+                self.write_target_index(image, self.proto_map, 12, reference, 2);
+            }
+            WriteKind::FieldId16 => {
+                self.write_target_index(image, self.field_map, 8, reference, 2);
+            }
+            WriteKind::FieldId32 => {
+                self.write_target_index(image, self.field_map, 8, reference, 4);
+            }
+            WriteKind::MethodId16 => {
+                self.write_target_index(image, self.method_map, 8, reference, 2);
+            }
+            WriteKind::MethodId32 => {
+                self.write_target_index(image, self.method_map, 8, reference, 4);
+            }
+            WriteKind::CallSiteId16 => {
+                self.write_target_index(image, self.call_site_map, 4, reference, 2);
+            }
+            WriteKind::MethodHandle16 => {
+                self.write_target_index(image, self.method_handle_map, 8, reference, 2);
+            }
+            WriteKind::Abs32 => {
+                let _ = write_u32(image, reference.location as usize, reference.target);
+            }
+            WriteKind::RelCode8 => {
+                let diff = reference.target as i64 - i64::from(reference.location);
+                let delta = diff / 2 + 1;
+                if i8::try_from(delta).is_ok() {
+                    if let Some(slot) = image.get_mut(reference.location as usize) {
+                        *slot = delta as i8 as u8;
+                    }
+                }
+            }
+            WriteKind::RelCode16 => {
+                let diff = reference.target as i64 - i64::from(reference.location);
+                let delta = diff / 2 + 1;
+                if i16::try_from(delta).is_ok() {
+                    let _ = write_u16(image, reference.location as usize, delta as i16 as u16);
+                }
+            }
+            WriteKind::RelCode32 => {
+                let diff = reference.target as i64 - i64::from(reference.location);
+                let delta = diff / 2 + 1;
+                if i32::try_from(delta).is_ok() {
+                    let _ = write_u32(image, reference.location as usize, delta as i32 as u32);
+                }
+            }
+        }
+    }
 }

From 277cf2afe9cc0f1a54a0629933193dfa53a9bcf4 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 17:38:49 +0530
Subject: [PATCH 18/42] zucchini: add pure-Rust fixture tests, port notes,
 clippy cleanups

- tests/zucchini_pure.rs replays every committed fixture byte-for-byte
- docs/zucchini-rust-port.md records scope, the Android preflight gap, and
  the smallest remaining C++ boundary
- silence style-only clippy lints that come from the faithful C++ port
---
 docs/zucchini-rust-port.md | 114 +++++++++++++++++++++++++++++++++++++
 src/zucchini_pure/arm.rs   |   2 +-
 src/zucchini_pure/dex.rs   |   4 +-
 src/zucchini_pure/mod.rs   |  13 +++++
 tests/zucchini_pure.rs     |  57 +++++++++++++++++++
 5 files changed, 186 insertions(+), 4 deletions(-)
 create mode 100644 docs/zucchini-rust-port.md
 create mode 100644 tests/zucchini_pure.rs

diff --git a/docs/zucchini-rust-port.md b/docs/zucchini-rust-port.md
new file mode 100644
index 0000000..72714a5
--- /dev/null
+++ b/docs/zucchini-rust-port.md
@@ -0,0 +1,114 @@
+# Pure-Rust Zucchini apply port
+
+Status: prototype, verified byte-exact against every committed Zucchini fixture.
+Scope: **apply only**, Android delta OTA element formats (`NoOp`, ELF
+x86/x86-64/AArch32/AArch64, DEX).
+
+## Motivation
+
+The current PR vendors AOSP `external/zucchini` plus `external/libchrome` and
+compiles them from `build.rs` (`src/zucchini.rs` calls the
+`otadump_zucchini_apply` C ABI). That boundary is large: ~5,200 lines of
+disassembler/generator C++ and a vendored libchrome slice. otadump only ever
+*applies* patches, so almost all of that surface is unnecessary.
+
+This port reimplements the apply path in safe Rust under
+`src/zucchini_pure/`, with no C++ and no libchrome.
+
+## What is implemented
+
+| Area | Source ported | File |
+| --- | --- | --- |
+| Ensemble patch format, varints, stream validation | `patch_reader.{h,cc}`, `patch_utils.h` | `patch.rs` |
+| CRC-32 | `crc32.cc` | `crc32.rs` |
+| Equivalence/extra-data/raw-delta/reference correction, `OffsetMapper`, `TargetPool` | `zucchini_apply.cc`, `equivalence_map.cc`, `target_pool.cc` | `engine.rs` |
+| NoOp element | `disassembler_no_op.cc` | `engine.rs` |
+| ELF parse, address translation, reloc/abs32, Intel + ARM rel32 finders | `disassembler_elf.cc`, `address_translator.cc`, `reloc_elf.cc`, `abs32_utils.cc`, `rel32_utils.cc`, `rel32_finder.cc` | `elf.rs` |
+| AArch32/AArch64 and THUMB2 instruction codecs | `arm_utils.cc` | `arm.rs` |
+| DEX header/map/code-item/item-list parsing and all 42 reference groups | `disassembler_dex.cc`, `type_dex.h` | `dex.rs` |
+| Little-endian helpers and bit fields | `buffer_view.h`, `algorithm.h` | `bytes.rs` |
+
+The `Disassembler` trait in `mod.rs` is the only abstraction the engine needs:
+size, reference groups, ranged reads, and single-reference writes. Both ELF and
+DEX implement it; `make_disassembler` rejects non-Android formats
+(`UnsupportedElement`), matching the native FFI allow-list.
+
+## Verification
+
+`tests/zucchini_pure.rs` replays the committed fixtures byte-for-byte:
+
+- `noop.zuc` → `noop-new.bin`
+- `elf-x86.zuc`, `elf.zuc`, `elf-arm32.zuc`, `elf-arm64.zuc`
+- `dex.zuc`, `dex-large.zuc` (65,537 strings, 16-bit and 32-bit code refs)
+
+Negative cases check that garbage and truncated patches return
+`Status::InvalidPatch` and a mismatched output size returns
+`Status::WrongOutputSize`.
+
+Run with:
+
+```sh
+cargo test --test zucchini_pure
+```
+
+The fixtures were already portable; no new goldens were required. This makes an
+incremental landing possible: each format/architecture can be merged and
+validated independently.
+
+## Fixture coverage caveat
+
+The fixtures exercise only a subset of each format's reference types (for
+example `elf-x86`/`elf` only hit rel32, `elf-arm32` only A24, `elf-arm64` only
+Immd26). Passing them is necessary but not sufficient. This port implements
+every reference type the native disassemblers emit, so it is deliberately
+broader than the fixtures.
+
+## Blockers and the smallest C++ boundary
+
+A complete apply rewrite is realistic. The remaining gaps are small and
+well-delimited:
+
+1. **Android preflight hardening (the only real semantic gap).**
+   `native/zucchini/src/zucchini_ffi.cc` layers three validations on top of
+   upstream `ApplyBuffer` that upstream Zucchini does not have:
+   - `ValidateReferenceBoundaries` — no reference/writer body may straddle an
+     equivalence boundary.
+   - `ValidateDexWriterWidths` — `type_id`/`proto_id`/`field_id`/`method_id`/
+     `call_site_id`/`method_handle` lists must fit a 16-bit writer.
+   - `ValidateDexReferenceTargets` — 16-bit `const-string` references must
+     resolve to string ids that fit in 16 bits.
+   These reject otherwise byte-valid patches (the `dex-large-unsafe16.zuc`
+   fixture). The pure port currently surfaces that case as a new-image CRC
+   mismatch (`ApplyError`), not as `"android executable preflight failed"`.
+   This is Android policy, not format math, so it must be ported deliberately
+   with dedicated tests.
+
+2. **Smallest C++ boundary.** Because the three validators above call the
+   vendored C++ disassemblers, *keeping any of them in C++ keeps the entire
+   zucchini + libchrome stack*. There is no useful smaller C++ subset. The two
+   coherent options are therefore:
+   - *Strict native parity now*: keep the existing C++ boundary unchanged.
+   - *Pure-Rust target*: port the three validators (≈250–350 lines) on top of
+     the existing Rust readers/writers. After that the C++ boundary for
+     apply-only builds is **zero** — `build.rs`, `native/`, `libchrome`, and
+     the `cc` build dependency can be removed for the apply path.
+
+3. **Non-Android formats (Win32, ZTF).** Not emitted by Android payloads and
+   intentionally rejected. Porting them would only matter for non-Android use.
+
+4. **Performance parity.** The C++ readers are lazy state machines; the Rust
+   `read` recomputes each group's references per range query, so DEX apply is
+   `O(groups × equivalences × items)`. Correct but slower on real partitions.
+   Before production cutover, cache each group's full reference list once per
+   parsed image (the engine already asks for it once per pool).
+
+5. **Wiring.** `zucchini_pure` is exposed alongside `zucchini::apply` rather
+   than replacing it, so the native path and tests remain intact. The final
+   step is to route `zucchini::apply` to the pure implementation and drop the
+   `otadump_zucchini` cfg/build once items 1 and 4 are addressed.
+
+## Reproducing the measurement
+
+The mini C++ diagnostic used to confirm which reference types each fixture
+touches lives outside the repo; the equivalent information is available from
+`tests/fixtures/zucchini/README.md` and the group tables in `dex.rs`/`elf.rs`.
diff --git a/src/zucchini_pure/arm.rs b/src/zucchini_pure/arm.rs
index 60023c7..52b8c54 100644
--- a/src/zucchini_pure/arm.rs
+++ b/src/zucchini_pure/arm.rs
@@ -30,7 +30,7 @@ fn signed_bits_u16(value: u16, lo: u32, hi: u32) -> i32 {
     // `GetSignedBits` on a 16-bit value.
     let num_bits = 16i32;
     let shift = num_bits - 1 - hi as i32;
-    ((i32::from(value) << shift) << 0) >> (shift + lo as i32)
+    (i32::from(value) << shift) >> (shift + lo as i32)
 }
 
 #[inline]
diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
index 0690b94..dd43cef 100644
--- a/src/zucchini_pure/dex.rs
+++ b/src/zucchini_pure/dex.rs
@@ -142,7 +142,6 @@ pub struct DexDisassembler {
     class_def_map: MapItem,
     call_site_map: MapItem,
     method_handle_map: MapItem,
-    code_map: MapItem,
     code_item_offsets: Vec<u32>,
     type_list_offsets: Vec<u32>,
     annotation_set_ref_list_offsets: Vec<u32>,
@@ -244,7 +243,6 @@ impl DexDisassembler {
             class_def_map: get(T_CLASS_DEF),
             call_site_map: get(T_CALL_SITE_ID),
             method_handle_map: get(T_METHOD_HANDLE),
-            code_map,
             code_item_offsets,
             type_list_offsets,
             annotation_set_ref_list_offsets,
@@ -327,7 +325,7 @@ fn parse_annotations_directory_items(
     let mut parameter_offsets = Vec::new();
     let mut pos = map_item.offset as usize;
 
-    let mut parse_list = |pos: &mut usize, count: u32, width: usize, out: &mut Vec<u32>| -> Option<()> {
+    let parse_list = |pos: &mut usize, count: u32, width: usize, out: &mut Vec<u32>| -> Option<()> {
         if (image.len() - *pos) / width < count as usize {
             return None;
         }
diff --git a/src/zucchini_pure/mod.rs b/src/zucchini_pure/mod.rs
index 3bb4ffe..1751e6a 100644
--- a/src/zucchini_pure/mod.rs
+++ b/src/zucchini_pure/mod.rs
@@ -8,6 +8,19 @@
 //!
 //! Scope and status are documented in `docs/zucchini-rust-port.md`.
 
+// This is a line-by-line port of the C++ apply path, so several clippy style
+// lints (control-flow shape, argument counts, explicit byte indexing) are
+// intentionally allowed rather than restructured away from the original.
+#![allow(
+    clippy::collapsible_if,
+    clippy::implicit_saturating_sub,
+    clippy::manual_is_multiple_of,
+    clippy::needless_range_loop,
+    clippy::too_many_arguments,
+    clippy::type_complexity,
+    clippy::unnecessary_cast
+)]
+
 use std::error;
 use std::fmt;
 
diff --git a/tests/zucchini_pure.rs b/tests/zucchini_pure.rs
new file mode 100644
index 0000000..d488496
--- /dev/null
+++ b/tests/zucchini_pure.rs
@@ -0,0 +1,57 @@
+//! Byte-exact fixture tests for the pure-Rust Zucchini apply path.
+
+use std::fs;
+use std::path::Path;
+
+use otadump::zucchini_pure::{self, Status};
+
+const FIXTURES: &str = "tests/fixtures/zucchini";
+
+/// Applies `<name>-old<ext>` + `<name>.zuc` and compares with `<name>-new<ext>`.
+fn assert_fixture(name: &str, extension: &str) {
+    let fixtures = Path::new(FIXTURES);
+    let old = fs::read(fixtures.join(format!("{name}-old{extension}"))).unwrap();
+    let expected = fs::read(fixtures.join(format!("{name}-new{extension}"))).unwrap();
+    let patch = fs::read(fixtures.join(format!("{name}.zuc"))).unwrap();
+    let output = zucchini_pure::apply(&old, &patch, expected.len()).unwrap();
+    assert_eq!(output, expected, "fixture {name} did not reconstruct byte-exactly");
+}
+
+#[test]
+fn pure_rust_applies_noop_and_elf_fixtures() {
+    assert_fixture("noop", ".bin");
+    assert_fixture("elf-x86", "");
+    assert_fixture("elf", "");
+    assert_fixture("elf-arm32", "");
+    assert_fixture("elf-arm64", "");
+}
+
+#[test]
+fn pure_rust_applies_dex_fixtures() {
+    assert_fixture("dex", ".dex");
+    assert_fixture("dex-large", ".dex");
+}
+
+#[test]
+fn pure_rust_rejects_garbage_patch() {
+    let error = zucchini_pure::apply(b"abcd", b"not a patch", 5).unwrap_err();
+    assert_eq!(error.status(), Status::InvalidPatch);
+}
+
+#[test]
+fn pure_rust_rejects_wrong_output_size() {
+    let fixtures = Path::new(FIXTURES);
+    let old = fs::read(fixtures.join("noop-old.bin")).unwrap();
+    let patch = fs::read(fixtures.join("noop.zuc")).unwrap();
+    let error = zucchini_pure::apply(&old, &patch, 999).unwrap_err();
+    assert_eq!(error.status(), Status::WrongOutputSize);
+}
+
+#[test]
+fn pure_rust_rejects_truncated_patch() {
+    let fixtures = Path::new(FIXTURES);
+    let old = fs::read(fixtures.join("noop-old.bin")).unwrap();
+    let patch = fs::read(fixtures.join("noop.zuc")).unwrap();
+    let error = zucchini_pure::apply(&old, &patch[..patch.len() - 1], 5).unwrap_err();
+    assert_eq!(error.status(), Status::InvalidPatch);
+}

From cb92075dd29b6bfc2300729867ac2aefe9bcda9e Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 17:40:49 +0530
Subject: [PATCH 19/42] zucchini: port Android preflight hardening to pure Rust

Add the FFI-only validations that upstream Zucchini lacks:
- ValidateReferenceBoundaries
- ValidateDexWriterWidths
- ValidateDexReferenceTargets

Reject dex-large-unsafe16.zuc with the native
"android executable preflight failed" message. With this, the apply path no
longer needs C++/libchrome at all for Android formats.
---
 docs/zucchini-rust-port.md  |  53 ++++------
 src/zucchini_pure/dex.rs    |  55 +++++++++-
 src/zucchini_pure/engine.rs | 205 +++++++++++++++++++++++++++++++++++-
 src/zucchini_pure/mod.rs    |  10 +-
 tests/zucchini_pure.rs      |  13 +++
 5 files changed, 299 insertions(+), 37 deletions(-)

diff --git a/docs/zucchini-rust-port.md b/docs/zucchini-rust-port.md
index 72714a5..ba5919a 100644
--- a/docs/zucchini-rust-port.md
+++ b/docs/zucchini-rust-port.md
@@ -26,6 +26,7 @@ This port reimplements the apply path in safe Rust under
 | ELF parse, address translation, reloc/abs32, Intel + ARM rel32 finders | `disassembler_elf.cc`, `address_translator.cc`, `reloc_elf.cc`, `abs32_utils.cc`, `rel32_utils.cc`, `rel32_finder.cc` | `elf.rs` |
 | AArch32/AArch64 and THUMB2 instruction codecs | `arm_utils.cc` | `arm.rs` |
 | DEX header/map/code-item/item-list parsing and all 42 reference groups | `disassembler_dex.cc`, `type_dex.h` | `dex.rs` |
+| Android preflight hardening | `native/zucchini/src/zucchini_ffi.cc` | `engine.rs` |
 | Little-endian helpers and bit fields | `buffer_view.h`, `algorithm.h` | `bytes.rs` |
 
 The `Disassembler` trait in `mod.rs` is the only abstraction the engine needs:
@@ -42,8 +43,10 @@ DEX implement it; `make_disassembler` rejects non-Android formats
 - `dex.zuc`, `dex-large.zuc` (65,537 strings, 16-bit and 32-bit code refs)
 
 Negative cases check that garbage and truncated patches return
-`Status::InvalidPatch` and a mismatched output size returns
-`Status::WrongOutputSize`.
+`Status::InvalidPatch`, a mismatched output size returns
+`Status::WrongOutputSize`, and `dex-large-unsafe16.zuc` is rejected by the
+ported Android preflight with `"android executable preflight failed"`,
+matching the native test exactly.
 
 Run with:
 
@@ -61,37 +64,25 @@ The fixtures exercise only a subset of each format's reference types (for
 example `elf-x86`/`elf` only hit rel32, `elf-arm32` only A24, `elf-arm64` only
 Immd26). Passing them is necessary but not sufficient. This port implements
 every reference type the native disassemblers emit, so it is deliberately
-broader than the fixtures.
+broader than the fixtures. The committed `dex-large-unsafe16.zuc` fixture
+exercises the Android-only preflight path end to end.
 
 ## Blockers and the smallest C++ boundary
 
-A complete apply rewrite is realistic. The remaining gaps are small and
-well-delimited:
-
-1. **Android preflight hardening (the only real semantic gap).**
-   `native/zucchini/src/zucchini_ffi.cc` layers three validations on top of
-   upstream `ApplyBuffer` that upstream Zucchini does not have:
-   - `ValidateReferenceBoundaries` — no reference/writer body may straddle an
-     equivalence boundary.
-   - `ValidateDexWriterWidths` — `type_id`/`proto_id`/`field_id`/`method_id`/
-     `call_site_id`/`method_handle` lists must fit a 16-bit writer.
-   - `ValidateDexReferenceTargets` — 16-bit `const-string` references must
-     resolve to string ids that fit in 16 bits.
-   These reject otherwise byte-valid patches (the `dex-large-unsafe16.zuc`
-   fixture). The pure port currently surfaces that case as a new-image CRC
-   mismatch (`ApplyError`), not as `"android executable preflight failed"`.
-   This is Android policy, not format math, so it must be ported deliberately
-   with dedicated tests.
-
-2. **Smallest C++ boundary.** Because the three validators above call the
-   vendored C++ disassemblers, *keeping any of them in C++ keeps the entire
-   zucchini + libchrome stack*. There is no useful smaller C++ subset. The two
-   coherent options are therefore:
-   - *Strict native parity now*: keep the existing C++ boundary unchanged.
-   - *Pure-Rust target*: port the three validators (≈250–350 lines) on top of
-     the existing Rust readers/writers. After that the C++ boundary for
-     apply-only builds is **zero** — `build.rs`, `native/`, `libchrome`, and
-     the `cc` build dependency can be removed for the apply path.
+A complete pure-Rust apply rewrite is realized for Android element formats. The
+remaining work is engineering hardening and wiring, not missing format support:
+
+1. **Android preflight hardening — ported.** The native FFI's extra validations
+   (`ValidateReferenceBoundaries`, `ValidateDexWriterWidths`,
+   `ValidateDexReferenceTargets`) now live in the Rust engine and run before the
+   apply pass, reproducing the native `"android executable preflight failed"`
+   rejection.
+
+2. **Smallest C++ boundary: zero for apply-only builds.** With the preflight
+   ported, nothing on the apply path needs C++. The `native/` tree, vendored
+   libchrome, `cc` build dependency, and the `otadump_zucchini` cfg can be
+   removed for apply-only builds. The remaining C++ is only useful if patch
+   *generation* is ever added.
 
 3. **Non-Android formats (Win32, ZTF).** Not emitted by Android payloads and
    intentionally rejected. Porting them would only matter for non-Android use.
@@ -105,7 +96,7 @@ well-delimited:
 5. **Wiring.** `zucchini_pure` is exposed alongside `zucchini::apply` rather
    than replacing it, so the native path and tests remain intact. The final
    step is to route `zucchini::apply` to the pure implementation and drop the
-   `otadump_zucchini` cfg/build once items 1 and 4 are addressed.
+   `otadump_zucchini` cfg/build once item 4 is addressed.
 
 ## Reproducing the measurement
 
diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
index dd43cef..311a7d9 100644
--- a/src/zucchini_pure/dex.rs
+++ b/src/zucchini_pure/dex.rs
@@ -29,9 +29,9 @@ const T_CODE_ITEM: u16 = 0x2001;
 const T_ANNOTATIONS_DIRECTORY: u16 = 0x2006;
 
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-struct MapItem {
-    size: u32,
-    offset: u32,
+pub(crate) struct MapItem {
+    pub(crate) size: u32,
+    pub(crate) offset: u32,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -282,6 +282,55 @@ fn read_dex_header(image: &[u8]) -> Option<(u32, u32)> {
     Some((file_size, map_off))
 }
 
+/// Reads the map item of `desired` type from a (possibly patched) DEX image.
+/// Mirrors the FFI's `ReadDexMapItem` helper.
+pub(crate) fn read_map_item(image: &[u8], desired: u16) -> Option<MapItem> {
+    let (_, map_off) = read_dex_header(image)?;
+    let list_start = map_off as usize;
+    let count = read_u32(image, list_start)?;
+    let items_start = list_start.checked_add(4)?;
+    let items_end = items_start.checked_add(count as usize * MAP_ITEM_SIZE)?;
+    if items_end > image.len() {
+        return None;
+    }
+    for index in 0..count as usize {
+        let base = items_start + index * MAP_ITEM_SIZE;
+        if read_u16(image, base)? == desired {
+            return Some(MapItem {
+                size: read_u32(image, base + 4)?,
+                offset: read_u32(image, base + 8)?,
+            });
+        }
+    }
+    None
+}
+
+/// Mirrors the FFI's `ValidateDexWriterWidths`: the narrow fixed-size lists must
+/// fit a 16-bit writer.
+pub(crate) fn narrow_writer_widths_ok(image: &[u8]) -> bool {
+    const NARROW_TYPES: [u16; 6] = [
+        T_TYPE_ID,
+        T_PROTO_ID,
+        T_FIELD_ID,
+        T_METHOD_ID,
+        T_CALL_SITE_ID,
+        T_METHOD_HANDLE,
+    ];
+    for kind in NARROW_TYPES {
+        if let Some(item) = read_map_item(image, kind) {
+            if item.size > u32::from(u16::MAX) + 1 {
+                return false;
+            }
+        }
+    }
+    true
+}
+
+/// Returns the `string_ids` list bounds from a patched DEX image.
+pub(crate) fn string_ids(image: &[u8]) -> Option<MapItem> {
+    read_map_item(image, T_STRING_ID)
+}
+
 fn parse_item_offsets(
     image: &[u8],
     map_item: MapItem,
diff --git a/src/zucchini_pure/engine.rs b/src/zucchini_pure/engine.rs
index 81e82b1..b982c24 100644
--- a/src/zucchini_pure/engine.rs
+++ b/src/zucchini_pure/engine.rs
@@ -4,8 +4,15 @@
 use std::collections::BTreeMap;
 
 use super::bytes::{range_is_bounded, range_covers};
-use super::patch::{Equivalence, PatchElement};
-use super::{make_disassembler, Disassembler, Error, GroupTraits, Result, Status, K_INVALID_OFFSET, OFFSET_BOUND};
+use super::dex;
+use super::patch::{
+    Equivalence, PatchElement, EXE_TYPE_DEX, EXE_TYPE_ELF_AARCH32, EXE_TYPE_ELF_AARCH64,
+    EXE_TYPE_ELF_X64, EXE_TYPE_ELF_X86, EXE_TYPE_NOOP,
+};
+use super::{
+    is_android_executable, make_disassembler, Disassembler, Error, GroupTraits, Result, Status,
+    K_INVALID_OFFSET, OFFSET_BOUND,
+};
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct Reference {
@@ -62,6 +69,200 @@ pub(crate) fn apply_element(
     Ok(())
 }
 
+/// Mirrors the native FFI's `PreflightAndroidElements` for one element: apply
+/// equivalence/extra/raw data to a scratch output, then run the Android
+/// boundary and DEX-target validations that upstream Zucchini does not.
+pub(crate) fn preflight_element(
+    old: &[u8],
+    element: &PatchElement,
+    output: &mut [u8],
+) -> Result<()> {
+    let exe_type = element.element_match.exe_type;
+    if exe_type == EXE_TYPE_NOOP || !is_android_executable(exe_type) {
+        return Ok(());
+    }
+
+    let matching = &element.element_match;
+    let old_end = (matching.old_offset as usize)
+        .checked_add(matching.old_size as usize)
+        .ok_or_else(|| apply_error("old element range overflow"))?;
+    let new_end = (matching.new_offset as usize)
+        .checked_add(matching.new_size as usize)
+        .ok_or_else(|| apply_error("new element range overflow"))?;
+    let old_element = old
+        .get(matching.old_offset as usize..old_end)
+        .ok_or_else(|| apply_error("old element out of bounds"))?;
+    let new_element = output
+        .get_mut(matching.new_offset as usize..new_end)
+        .ok_or_else(|| apply_error("new element out of bounds"))?;
+
+    apply_equivalence_and_extra_data(old_element, element, new_element)?;
+    apply_raw_delta(element, new_element)?;
+
+    let old_disasm = make_disassembler(exe_type, old_element)
+        .ok_or_else(|| apply_error("failed to create old disassembler"))?;
+    let new_disasm = make_disassembler(exe_type, new_element)
+        .ok_or_else(|| apply_error("failed to create new disassembler"))?;
+    if old_disasm.size() != old_element.len() as u32 {
+        return Err(apply_error("disassembler and element size mismatch"));
+    }
+    let new_size = new_element.len() as u32;
+    if !validate_reference_boundaries(&*old_disasm, exe_type, element, old_element, new_size) {
+        return Err(apply_error("reference boundary violation"));
+    }
+    if exe_type == EXE_TYPE_DEX {
+        if !dex::narrow_writer_widths_ok(new_element) {
+            return Err(apply_error("dex writer width violation"));
+        }
+        if !validate_dex_reference_targets(
+            &*old_disasm,
+            &*new_disasm,
+            element,
+            old_element,
+            new_element,
+        ) {
+            return Err(apply_error("dex reference target violation"));
+        }
+    }
+    Ok(())
+}
+
+/// Mirrors the FFI's `ValidateReferenceBoundaries`.
+fn validate_reference_boundaries(
+    old_disasm: &dyn Disassembler,
+    exe_type: u32,
+    element: &PatchElement,
+    old_image: &[u8],
+    new_size: u32,
+) -> bool {
+    let mut boundaries: Vec<u32> = Vec::new();
+    for equivalence in &element.equivalences {
+        boundaries.push(equivalence.src_offset);
+        boundaries.push(equivalence.src_end());
+    }
+    boundaries.sort_unstable();
+
+    let old_size = old_image.len() as u32;
+    for (group_index, group) in old_disasm.groups().iter().enumerate() {
+        let mut writer_width = group.width;
+        if group.type_tag == 0 {
+            match exe_type {
+                EXE_TYPE_ELF_X86 | EXE_TYPE_ELF_AARCH32 => writer_width = 8,
+                EXE_TYPE_ELF_X64 | EXE_TYPE_ELF_AARCH64 => writer_width = 16,
+                _ => {}
+            }
+        }
+
+        for reference in old_disasm.read(group_index, old_image, 0, old_size) {
+            let boundary = boundaries.partition_point(|value| *value <= reference.location);
+            if boundary < boundaries.len()
+                && boundaries[boundary] < reference.location.wrapping_add(group.width)
+            {
+                return false;
+            }
+        }
+
+        for equivalence in &element.equivalences {
+            for reference in old_disasm.read(
+                group_index,
+                old_image,
+                equivalence.src_offset,
+                equivalence.src_end(),
+            ) {
+                if reference.location < equivalence.src_offset
+                    || reference.location > equivalence.src_end()
+                    || group.width > equivalence.src_end() - reference.location
+                {
+                    return false;
+                }
+                let projected = equivalence.dst_offset.wrapping_add(
+                    reference.location.wrapping_sub(equivalence.src_offset),
+                );
+                if projected > new_size || writer_width > new_size - projected {
+                    return false;
+                }
+            }
+        }
+    }
+    true
+}
+
+/// Mirrors the FFI's `ValidateDexReferenceTargets`.
+fn validate_dex_reference_targets(
+    old_disasm: &dyn Disassembler,
+    new_disasm: &dyn Disassembler,
+    element: &PatchElement,
+    old_image: &[u8],
+    new_image: &[u8],
+) -> bool {
+    let Some(string_ids) = dex::string_ids(new_image) else { return false };
+
+    let mut pools: BTreeMap<u8, Vec<usize>> = BTreeMap::new();
+    for (index, group) in old_disasm.groups().iter().enumerate() {
+        pools.entry(group.pool_tag).or_default().push(index);
+    }
+
+    let mut deltas = element.reference_deltas.iter();
+    let old_size = old_image.len() as u32;
+    let mapper = OffsetMapper::new(
+        &element.equivalences,
+        old_size,
+        new_image.len() as u32,
+    );
+
+    for (pool_tag, sub_groups) in &pools {
+        let mut targets = TargetPool::default();
+        for &group_index in sub_groups {
+            targets.insert_references(&old_disasm.read(group_index, old_image, 0, old_size));
+        }
+        targets.filter_and_project(&mapper);
+        if let Some(extra) = element.extra_targets.get(pool_tag) {
+            targets.insert_targets(&extra.targets);
+            if !extra.done {
+                return false;
+            }
+        }
+
+        for &group_index in sub_groups {
+            let type_tag = old_disasm.groups()[group_index].type_tag;
+            if usize::from(type_tag) >= new_disasm.groups().len() {
+                return false;
+            }
+            for equivalence in &element.equivalences {
+                for reference in old_disasm.read(
+                    group_index,
+                    old_image,
+                    equivalence.src_offset,
+                    equivalence.src_end(),
+                ) {
+                    let projected = mapper.extended_forward_project(reference.target);
+                    let expected = targets.key_for_nearest_offset(projected);
+                    let Some(delta) = deltas.next() else { return false };
+                    let key = i64::from(expected) + i64::from(*delta);
+                    if !(0..=i64::from(u32::MAX)).contains(&key) {
+                        return false;
+                    }
+                    let key = key as u32;
+                    if !targets.key_is_valid(key) {
+                        return false;
+                    }
+                    if type_tag == 5 {
+                        let target = targets.offset_for_key(key);
+                        if target < string_ids.offset
+                            || (target - string_ids.offset) % 4 != 0
+                            || (target - string_ids.offset) / 4 > u32::from(u16::MAX)
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    deltas.next().is_none() && element.reference_deltas_done
+}
+
 /// Mirrors `ApplyEquivalenceAndExtraData`.
 fn apply_equivalence_and_extra_data(
     old_image: &[u8],
diff --git a/src/zucchini_pure/mod.rs b/src/zucchini_pure/mod.rs
index 1751e6a..5955242 100644
--- a/src/zucchini_pure/mod.rs
+++ b/src/zucchini_pure/mod.rs
@@ -138,6 +138,14 @@ pub fn apply(old: &[u8], patch_bytes: &[u8], output_size: usize) -> Result<Vec<u
     })?;
     output.resize(output_size, 0);
 
+    // Android hardens upstream apply with an additional preflight. Mirror the
+    // native FFI so unsafe patches are rejected before publication.
+    for element in &patch.elements {
+        engine::preflight_element(old, element, &mut output).map_err(|_| {
+            Error::new(Status::ApplyError, "android executable preflight failed")
+        })?;
+    }
+
     for element in &patch.elements {
         engine::apply_element(old, element, &mut output)?;
     }
@@ -148,7 +156,7 @@ pub fn apply(old: &[u8], patch_bytes: &[u8], output_size: usize) -> Result<Vec<u
     Ok(output)
 }
 
-fn is_android_executable(exe_type: u32) -> bool {
+pub(crate) fn is_android_executable(exe_type: u32) -> bool {
     matches!(
         exe_type,
         patch::EXE_TYPE_ELF_X86
diff --git a/tests/zucchini_pure.rs b/tests/zucchini_pure.rs
index d488496..b0e0e9a 100644
--- a/tests/zucchini_pure.rs
+++ b/tests/zucchini_pure.rs
@@ -47,6 +47,19 @@ fn pure_rust_rejects_wrong_output_size() {
     assert_eq!(error.status(), Status::WrongOutputSize);
 }
 
+/// Mirrors the native test for `dex-large-unsafe16.zuc`: the Android preflight
+/// must reject the unsafe 16-bit string reference before publication.
+#[test]
+fn pure_rust_rejects_unsafe_large_dex_string16_reference() {
+    let fixtures = Path::new(FIXTURES);
+    let old = fs::read(fixtures.join("dex-large-old.dex")).unwrap();
+    let patch = fs::read(fixtures.join("dex-large-unsafe16.zuc")).unwrap();
+    let expected_size = fs::metadata(fixtures.join("dex-large-new.dex")).unwrap().len() as usize;
+    let error = zucchini_pure::apply(&old, &patch, expected_size).unwrap_err();
+    assert_eq!(error.status(), Status::ApplyError);
+    assert_eq!(error.to_string(), "android executable preflight failed");
+}
+
 #[test]
 fn pure_rust_rejects_truncated_patch() {
     let fixtures = Path::new(FIXTURES);

From c6cf3d6c6ce7bceece88b83292d577e1b0d1bdf8 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 17:53:12 +0530
Subject: [PATCH 20/42] zucchini: fix apply-path edge cases found by audit

- patch: malformed trailing reference-delta varints no longer decode; the
  cursor is left unconsumed on failure (DecodeVarUInt semantics) and
  apply now honors reference_deltas_done like native Done()
- dex: widen opcode table arithmetic so opcode 0xFF (const-method-type)
  is reachable instead of wrapping to 0
- dex: payload offsets are bounded by remaining instruction units, not the
  whole code item
- dex: checked multiplication for map-array sizing; try_reserve code-item
  offsets
- elf: Thumb2 scanning advances by the decoded instruction size (4 for an
  unmatched 32-bit instruction) and does not fetch past the region
- elf: validate 64-bit program-header p_offset/p_filesz before narrowing
- engine: preflight checks the new disassembler size too

Adds unit regressions for opcodes/payloads/Thumb2/ELF64 bounds and an
integration regression for the trailing reference-delta case.
---
 src/zucchini_pure/dex.rs    |  60 ++++++++++++++--
 src/zucchini_pure/elf.rs    | 135 ++++++++++++++++++++++++++++--------
 src/zucchini_pure/engine.rs |   8 ++-
 src/zucchini_pure/patch.rs  |  12 +++-
 tests/zucchini_pure.rs      |  88 +++++++++++++++++++++++
 5 files changed, 265 insertions(+), 38 deletions(-)

diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
index 311a7d9..1499af2 100644
--- a/src/zucchini_pure/dex.rs
+++ b/src/zucchini_pure/dex.rs
@@ -122,10 +122,14 @@ const BYTECODE: &[(u8, u8, Format, u8)] = &[
 ];
 
 fn find_instruction(opcode: u8) -> Option<Bytecode> {
+    // Widening to `u16` matters: the final entry starts at 0xFF with variant 1,
+    // and `u8` arithmetic would wrap `0xFF + 1` to 0, making opcode 0xFF
+    // (const-method-type) unreachable.
+    let opcode = u16::from(opcode);
     BYTECODE
         .iter()
         .find(|(start, _, _, variant)| {
-            opcode >= *start && opcode < start.wrapping_add(*variant)
+            opcode >= u16::from(*start) && opcode < u16::from(*start) + u16::from(*variant)
         })
         .map(|(_, layout, format, _)| Bytecode { layout: *layout, format: *format })
 }
@@ -189,7 +193,8 @@ impl DexDisassembler {
             return None;
         }
         let items_start = list_start.checked_add(4)?;
-        let items_end = items_start.checked_add(list_size as usize * MAP_ITEM_SIZE)?;
+        let items_end =
+            items_start.checked_add((list_size as usize).checked_mul(MAP_ITEM_SIZE)?)?;
         if items_end > image.len() {
             return None;
         }
@@ -289,7 +294,7 @@ pub(crate) fn read_map_item(image: &[u8], desired: u16) -> Option<MapItem> {
     let list_start = map_off as usize;
     let count = read_u32(image, list_start)?;
     let items_start = list_start.checked_add(4)?;
-    let items_end = items_start.checked_add(count as usize * MAP_ITEM_SIZE)?;
+    let items_end = items_start.checked_add((count as usize).checked_mul(MAP_ITEM_SIZE)?)?;
     if items_end > image.len() {
         return None;
     }
@@ -413,7 +418,8 @@ fn parse_code_item_offsets(image: &[u8], code_map: MapItem) -> Option<Vec<u32>>
         return None;
     }
     let mut parser = CodeItemParser::new(code_map.offset as usize);
-    let mut offsets = Vec::with_capacity(code_map.size as usize);
+    let mut offsets = Vec::new();
+    offsets.try_reserve(code_map.size as usize).ok()?;
     for _ in 0..code_map.size {
         offsets.push(parser.get_next(image)?);
     }
@@ -781,8 +787,11 @@ fn parse_instructions(image: &[u8], base_offset: u32) -> Vec<InstructionValue> {
         }
         if opcode == 0x26 || opcode == 0x2B || opcode == 0x2C {
             let payload_rel = read_i32(image, pos + 2).unwrap_or(0);
+            // The native bound is relative to the remaining instruction bytes
+            // from the current instruction, not the whole code item.
+            let remaining_units = (insns_end - pos) as u32 / 2;
             if payload_rel < i32::from(instruction.layout)
-                || payload_rel as u32 >= (insns_end - insns_start) as u32 / 2
+                || payload_rel as u32 >= remaining_units
             {
                 break;
             }
@@ -1318,3 +1327,44 @@ impl Disassembler for DexDisassembler {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn opcode_ff_resolves_to_const_method_type() {
+        // Regression: `0xFF + variant` must not wrap in `u8` arithmetic.
+        let instruction = find_instruction(0xFF).expect("opcode 0xFF must be known");
+        assert_eq!(instruction.layout, 2);
+        assert_eq!(instruction.format, Format::C);
+
+        // Boundary of the 0xD8..=0xE2 variant range must not leak into 0xE3.
+        assert_eq!(find_instruction(0xE2).unwrap().layout, 2);
+        assert!(find_instruction(0xE3).is_none());
+    }
+
+    #[test]
+    fn const_method_type_maps_to_proto_reference() {
+        let value = InstructionValue { instr_offset: 0x40, opcode: 0xFF, format: Format::C };
+        assert_eq!(filter_location(CodeFilter::Proto, value), Some(0x42));
+    }
+
+    #[test]
+    fn payload_bound_is_relative_to_remaining_instructions() {
+        // 10 instruction units: `nop` then `fill-array-data` with payload
+        // offset 9. That offset is valid against the whole item (10 units) but
+        // not against the remaining 9 units, so native stops before emitting it.
+        let mut image = vec![0u8; CODE_ITEM_HEADER + 20];
+        image[12..16].copy_from_slice(&10u32.to_le_bytes()); // insns_size
+        image[16] = 0x00; // nop
+        image[17] = 0x00;
+        image[18] = 0x26; // fill-array-data (3 units)
+        image[19] = 0x00; // vAA
+        image[20..24].copy_from_slice(&9i32.to_le_bytes()); // payload offset
+
+        let instructions = parse_instructions(&image, 0);
+        assert_eq!(instructions.len(), 1);
+        assert_eq!(instructions[0].opcode, 0x00);
+    }
+}
diff --git a/src/zucchini_pure/elf.rs b/src/zucchini_pure/elf.rs
index 1439dce..f9fe797 100644
--- a/src/zucchini_pure/elf.rs
+++ b/src/zucchini_pure/elf.rs
@@ -475,24 +475,24 @@ impl ElfDisassembler {
                             cursor += step;
                             continue;
                         };
-                        let found = if is_thumb2 {
-                            scan_thumb2(image, instr_rva, location)
+                        let advancement = if is_thumb2 {
+                            let (found, size) =
+                                scan_thumb2(image, instr_rva, location, gap_end - cursor);
+                            if let Some((addr_type, target_rva)) = found {
+                                self.record_arm_rel32(addr_type, target_rva, location);
+                            }
+                            size
                         } else {
-                            scan_arm32(image, instr_rva, location)
-                        };
-                        match found {
-                            Some((addr_type, target_rva, instr_size)) => {
-                                if let Some(target_offset) = self.translator.rva_to_offset(target_rva)
-                                {
-                                    if self.is_target_in_exec_section(target_offset) {
-                                        self.rel32_locations[addr_type as usize]
-                                            .push(location);
-                                    }
-                                }
-                                cursor += instr_size as usize;
+                            if let Some((addr_type, target_rva, _)) =
+                                scan_arm32(image, instr_rva, location)
+                            {
+                                self.record_arm_rel32(addr_type, target_rva, location);
                             }
-                            None => cursor += step,
-                        }
+                            4
+                        };
+                        // Native always advances by the decoded instruction size,
+                        // including when no reference type matches.
+                        cursor += advancement as usize;
                     }
                 }
                 ElfKind::AArch64 => {
@@ -522,6 +522,14 @@ impl ElfDisassembler {
         }
     }
 
+    fn record_arm_rel32(&mut self, addr_type: u8, target_rva: u32, location: u32) {
+        if let Some(target_offset) = self.translator.rva_to_offset(target_rva) {
+            if self.is_target_in_exec_section(target_offset) {
+                self.rel32_locations[addr_type as usize].push(location);
+            }
+        }
+    }
+
     fn is_target_in_exec_section(&self, offset: u32) -> bool {
         let index = self.exec_headers.partition_point(|header| header.offset <= offset);
         if index == 0 {
@@ -944,7 +952,8 @@ fn parse_elf_header(
     if sections_end > image.len() {
         return None;
     }
-    let mut sections = Vec::with_capacity(sections_count);
+    let mut sections = Vec::new();
+    sections.try_reserve(sections_count).ok()?;
     for index in 0..sections_count {
         let base = sections_start + index * shdr_size;
         sections.push(parse_shdr(kind, image, base)?);
@@ -979,11 +988,15 @@ fn parse_elf_header(
     for index in 0..segments_count {
         let base = segments_start + index * phdr_size;
         let (p_offset, p_filesz) = parse_phdr(kind, image, base)?;
+        // Validate the original 64-bit values before narrowing to offset_t.
         let segment_end = p_offset.checked_add(p_filesz)?;
-        if segment_end > image.len() as u32 {
+        if segment_end > u64::from(u32::MAX) {
+            return None;
+        }
+        if !region_fits(p_offset, p_filesz, image.len() as u64) {
             return None;
         }
-        offset_bound = offset_bound.max(segment_end);
+        offset_bound = offset_bound.max(segment_end as u32);
     }
 
     Some((sections, offset_bound))
@@ -1011,11 +1024,11 @@ fn parse_shdr(kind: ElfKind, image: &[u8], base: usize) -> Option<SectionHeader>
     }
 }
 
-fn parse_phdr(kind: ElfKind, image: &[u8], base: usize) -> Option<(u32, u32)> {
+fn parse_phdr(kind: ElfKind, image: &[u8], base: usize) -> Option<(u64, u64)> {
     if kind.class() == 2 {
-        Some((read_u64(image, base + 8)? as u32, read_u64(image, base + 32)? as u32))
+        Some((read_u64(image, base + 8)?, read_u64(image, base + 32)?))
     } else {
-        Some((read_u32(image, base + 4)?, read_u32(image, base + 16)?))
+        Some((u64::from(read_u32(image, base + 4)?), u64::from(read_u32(image, base + 16)?)))
     }
 }
 
@@ -1088,26 +1101,37 @@ fn scan_arm32(image: &[u8], instr_rva: u32, location: u32) -> Option<(u8, u32, u
 }
 
 /// Returns `(addr_type, target_rva, instruction_size)` for THUMB2 mode.
-fn scan_thumb2(image: &[u8], instr_rva: u32, location: u32) -> Option<(u8, u32, u32)> {
+/// Returns `(reference, instruction_size)` for THUMB2. Native always advances
+/// by the decoded instruction size, even when no reference type matches.
+fn scan_thumb2(
+    image: &[u8],
+    instr_rva: u32,
+    location: u32,
+    available: usize,
+) -> (Option<(u8, u32)>, u32) {
     let code16 = arm::fetch_thumb2_code16(image, location);
     let instr_size = arm::get_thumb2_instruction_size(code16);
     if instr_size == 2 {
         if let Some(target) = arm::read_t8(instr_rva, code16) {
-            return Some((1, target, 2));
+            return (Some((1, target)), 2);
         }
         if let Some(target) = arm::read_t11(instr_rva, code16) {
-            return Some((2, target, 2));
+            return (Some((2, target)), 2);
         }
-        return None;
+        return (None, 2);
+    }
+    if available < 4 {
+        // Native does not fetch the second half if it lies outside the region.
+        return (None, 4);
     }
     let code32 = arm::fetch_thumb2_code32(image, location);
     if let Some(target) = arm::read_t20(instr_rva, code32) {
-        return Some((3, target, 4));
+        return (Some((3, target)), 4);
     }
     if let Some(target) = arm::read_t24(instr_rva, code32) {
-        return Some((4, target, 4));
+        return (Some((4, target)), 4);
     }
-    None
+    (None, 4)
 }
 
 fn scan_aarch64(image: &[u8], instr_rva: u32, location: u32) -> Option<(u8, u32)> {
@@ -1223,3 +1247,56 @@ fn _keep_helpers() {
     let _ = K_INVALID_OFFSET;
     let _ = OFFSET_BOUND;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn thumb2_unknown_32bit_reports_size_four() {
+        // code16 = 0xF800 selects a 32-bit THUMB2 instruction; the resulting
+        // code32 matches neither T20 nor T24, so it is advanced past in full.
+        let image = [0x00u8, 0xF8, 0x00, 0x00];
+        let (found, size) = scan_thumb2(&image, 0, 0, 4);
+        assert!(found.is_none());
+        assert_eq!(size, 4);
+    }
+
+    #[test]
+    fn thumb2_truncated_32bit_does_not_fetch() {
+        let image = [0x00u8, 0xF8, 0x00];
+        let (found, size) = scan_thumb2(&image, 0, 0, 2);
+        assert!(found.is_none());
+        assert_eq!(size, 4);
+    }
+
+    fn minimal_elf64(p_offset: u64, p_filesz: u64) -> Vec<u8> {
+        let mut image = vec![0u8; 64 + 56 + 64];
+        image[..4].copy_from_slice(b"\x7FELF");
+        image[4] = 2; // ELFCLASS64
+        image[5] = 1; // ELFDATA2LSB
+        image[6] = 1; // EV_CURRENT
+        image[16..18].copy_from_slice(&2u16.to_le_bytes()); // ET_EXEC
+        image[18..20].copy_from_slice(&62u16.to_le_bytes()); // EM_X86_64
+        image[20..24].copy_from_slice(&1u32.to_le_bytes());
+        image[32..40].copy_from_slice(&64u64.to_le_bytes()); // e_phoff
+        image[40..48].copy_from_slice(&120u64.to_le_bytes()); // e_shoff
+        image[54..56].copy_from_slice(&56u16.to_le_bytes()); // e_phentsize
+        image[56..58].copy_from_slice(&1u16.to_le_bytes()); // e_phnum
+        image[58..60].copy_from_slice(&64u16.to_le_bytes()); // e_shentsize
+        image[60..62].copy_from_slice(&1u16.to_le_bytes()); // e_shnum
+        // Section 0 stays a zeroed SHT_NULL entry.
+        image[72..80].copy_from_slice(&p_offset.to_le_bytes());
+        image[96..104].copy_from_slice(&p_filesz.to_le_bytes());
+        image
+    }
+
+    #[test]
+    fn elf64_program_header_bounds_are_validated_as_u64() {
+        assert!(parse_elf_header(ElfKind::X64, &minimal_elf64(0x80, 0x10)).is_some());
+        // 2^32 offsets must not truncate to a small valid-looking value.
+        assert!(parse_elf_header(ElfKind::X64, &minimal_elf64(0x1_0000_0000, 0x10)).is_none());
+        // A segment extending past the image must fail too.
+        assert!(parse_elf_header(ElfKind::X64, &minimal_elf64(0x80, 0x1000)).is_none());
+    }
+}
diff --git a/src/zucchini_pure/engine.rs b/src/zucchini_pure/engine.rs
index b982c24..a5f1bf4 100644
--- a/src/zucchini_pure/engine.rs
+++ b/src/zucchini_pure/engine.rs
@@ -103,7 +103,9 @@ pub(crate) fn preflight_element(
         .ok_or_else(|| apply_error("failed to create old disassembler"))?;
     let new_disasm = make_disassembler(exe_type, new_element)
         .ok_or_else(|| apply_error("failed to create new disassembler"))?;
-    if old_disasm.size() != old_element.len() as u32 {
+    if old_disasm.size() != old_element.len() as u32
+        || new_disasm.size() != new_element.len() as u32
+    {
         return Err(apply_error("disassembler and element size mismatch"));
     }
     let new_size = new_element.len() as u32;
@@ -450,7 +452,9 @@ fn apply_references_correction(
         }
     }
 
-    if deltas.next().is_some() {
+    // Match `ReferenceDeltaSource::Done()`: unconsumed malformed trailing bytes
+    // are a trailing-reference-delta error even if every needed delta decoded.
+    if deltas.next().is_some() || !element.reference_deltas_done {
         return Err(apply_error("found trailing reference delta"));
     }
     Ok(())
diff --git a/src/zucchini_pure/patch.rs b/src/zucchini_pure/patch.rs
index 16b5a12..874e1f3 100644
--- a/src/zucchini_pure/patch.rs
+++ b/src/zucchini_pure/patch.rs
@@ -134,16 +134,24 @@ impl<'a> Cursor<'a> {
         Some(value)
     }
 
-    /// Decodes a `uint32_t` base-128 varint, mirroring `DecodeVarUInt`.
+    /// Decodes a `uint32_t` base-128 varint, mirroring `DecodeVarUInt`. On
+    /// failure the cursor is left unchanged, matching `ParseVarUInt`, which only
+    /// consumes bytes when decoding succeeds.
     fn var_u32(&mut self) -> Option<u32> {
+        let start = self.pos;
         let mut value = 0u32;
         for shift in (0..32).step_by(7) {
-            let byte = self.u8()?;
+            let Some(&byte) = self.data.get(self.pos) else {
+                self.pos = start;
+                return None;
+            };
+            self.pos += 1;
             value |= u32::from(byte & 0x7F) << shift;
             if byte < 0x80 {
                 return Some(value);
             }
         }
+        self.pos = start;
         None
     }
 
diff --git a/tests/zucchini_pure.rs b/tests/zucchini_pure.rs
index b0e0e9a..aea954f 100644
--- a/tests/zucchini_pure.rs
+++ b/tests/zucchini_pure.rs
@@ -68,3 +68,91 @@ fn pure_rust_rejects_truncated_patch() {
     let error = zucchini_pure::apply(&old, &patch[..patch.len() - 1], 5).unwrap_err();
     assert_eq!(error.status(), Status::InvalidPatch);
 }
+
+fn var_u32(mut value: u32, out: &mut Vec<u8>) {
+    while value >= 0x80 {
+        out.push((value as u8) | 0x80);
+        value >>= 7;
+    }
+    out.push(value as u8);
+}
+
+fn var_i32(value: i32, out: &mut Vec<u8>) {
+    let encoded = if value < 0 { (((!value) as u32) << 1) | 1 } else { (value as u32) << 1 };
+    var_u32(encoded, out);
+}
+
+fn push_buffer(out: &mut Vec<u8>, data: &[u8]) {
+    out.extend_from_slice(&(data.len() as u32).to_le_bytes());
+    out.extend_from_slice(data);
+}
+
+fn crc32(data: &[u8]) -> u32 {
+    let mut table = [0u32; 256];
+    for (index, entry) in table.iter_mut().enumerate() {
+        let mut r = index as u32;
+        for _ in 0..8 {
+            r = (r >> 1) ^ (0xEDB8_8320 & (!((r & 1).wrapping_sub(1))));
+        }
+        *entry = r;
+    }
+    let mut crc = 0xFFFF_FFFFu32;
+    for &byte in data {
+        crc = table[((crc ^ u32::from(byte)) & 0xFF) as usize] ^ (crc >> 8);
+    }
+    crc ^ 0xFFFF_FFFF
+}
+
+/// Builds a single-element NoOp patch whose reference-delta stream is
+/// `reference_delta`.
+fn build_noop_patch(old: &[u8], new: &[u8], reference_delta: &[u8]) -> Vec<u8> {
+    let mut patch = Vec::new();
+    patch.extend_from_slice(b"Zucc");
+    patch.extend_from_slice(&1u16.to_le_bytes());
+    patch.extend_from_slice(&0u16.to_le_bytes());
+    patch.extend_from_slice(&(old.len() as u32).to_le_bytes());
+    patch.extend_from_slice(&crc32(old).to_le_bytes());
+    patch.extend_from_slice(&(new.len() as u32).to_le_bytes());
+    patch.extend_from_slice(&crc32(new).to_le_bytes());
+    patch.extend_from_slice(&1u32.to_le_bytes());
+
+    patch.extend_from_slice(&0u32.to_le_bytes());
+    patch.extend_from_slice(&(old.len() as u32).to_le_bytes());
+    patch.extend_from_slice(&0u32.to_le_bytes());
+    patch.extend_from_slice(&(new.len() as u32).to_le_bytes());
+    patch.extend_from_slice(&u32::from_le_bytes(*b"NoOp").to_le_bytes());
+    patch.extend_from_slice(&1u16.to_le_bytes());
+
+    let mut src_skip = Vec::new();
+    var_i32(0, &mut src_skip);
+    let mut dst_skip = Vec::new();
+    var_u32(0, &mut dst_skip);
+    let mut copy_count = Vec::new();
+    var_u32(old.len() as u32, &mut copy_count);
+    push_buffer(&mut patch, &src_skip);
+    push_buffer(&mut patch, &dst_skip);
+    push_buffer(&mut patch, &copy_count);
+
+    push_buffer(&mut patch, &new[old.len()..]);
+    push_buffer(&mut patch, &[]); // raw delta skip
+    push_buffer(&mut patch, &[]); // raw delta diff
+    push_buffer(&mut patch, reference_delta);
+    patch.extend_from_slice(&0u32.to_le_bytes());
+    patch
+}
+
+#[test]
+fn pure_rust_rejects_malformed_trailing_reference_delta() {
+    let old = b"ABCD";
+    let new = b"ABCDE";
+
+    // A well-formed empty stream applies cleanly for NoOp elements.
+    let valid = build_noop_patch(old, new, &[]);
+    assert_eq!(zucchini_pure::apply(old, &valid, new.len()).unwrap(), new.to_vec());
+
+    // An unterminated varint must be rejected like the native Done() semantics,
+    // even though a NoOp element needs no reference deltas at all.
+    let malformed = build_noop_patch(old, new, &[0x80]);
+    let error = zucchini_pure::apply(old, &malformed, new.len()).unwrap_err();
+    assert_eq!(error.status(), Status::ApplyError);
+}

From 04772a9316991cd75cbcfac61be181280a826a9d Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 17:54:56 +0530
Subject: [PATCH 21/42] zucchini: cooperative cancellation hook and fallible
 reservations

- add apply_with_cancel without changing apply(); poll between elements,
  pools, and equivalence units, returning Status::Cancelled
- use try_reserve for DEX code-item offsets and ELF section tables
- regression test for cancellation
---
 src/zucchini_pure/engine.rs | 24 ++++++++++++++++++++---
 src/zucchini_pure/mod.rs    | 39 +++++++++++++++++++++++++++++++++++--
 tests/zucchini_pure.rs      | 18 +++++++++++++++++
 3 files changed, 76 insertions(+), 5 deletions(-)

diff --git a/src/zucchini_pure/engine.rs b/src/zucchini_pure/engine.rs
index a5f1bf4..978becc 100644
--- a/src/zucchini_pure/engine.rs
+++ b/src/zucchini_pure/engine.rs
@@ -44,11 +44,21 @@ fn apply_error(message: impl Into<String>) -> Error {
     Error::new(Status::ApplyError, message)
 }
 
+fn check_not_cancelled(cancelled: &dyn Fn() -> bool) -> Result<()> {
+    if cancelled() {
+        Err(Error::new(Status::Cancelled, "Zucchini apply cancelled"))
+    } else {
+        Ok(())
+    }
+}
+
 pub(crate) fn apply_element(
     old: &[u8],
     element: &PatchElement,
     output: &mut [u8],
+    cancelled: &dyn Fn() -> bool,
 ) -> Result<()> {
+    check_not_cancelled(cancelled)?;
     let matching = &element.element_match;
     let old_end = (matching.old_offset as usize)
         .checked_add(matching.old_size as usize)
@@ -63,9 +73,9 @@ pub(crate) fn apply_element(
         .get_mut(matching.new_offset as usize..new_end)
         .ok_or_else(|| apply_error("new element out of bounds"))?;
 
-    apply_equivalence_and_extra_data(old_element, element, new_element)?;
+    apply_equivalence_and_extra_data(old_element, element, new_element, cancelled)?;
     apply_raw_delta(element, new_element)?;
-    apply_references_correction(matching.exe_type, old_element, element, new_element)?;
+    apply_references_correction(matching.exe_type, old_element, element, new_element, cancelled)?;
     Ok(())
 }
 
@@ -76,11 +86,13 @@ pub(crate) fn preflight_element(
     old: &[u8],
     element: &PatchElement,
     output: &mut [u8],
+    cancelled: &dyn Fn() -> bool,
 ) -> Result<()> {
     let exe_type = element.element_match.exe_type;
     if exe_type == EXE_TYPE_NOOP || !is_android_executable(exe_type) {
         return Ok(());
     }
+    check_not_cancelled(cancelled)?;
 
     let matching = &element.element_match;
     let old_end = (matching.old_offset as usize)
@@ -96,7 +108,7 @@ pub(crate) fn preflight_element(
         .get_mut(matching.new_offset as usize..new_end)
         .ok_or_else(|| apply_error("new element out of bounds"))?;
 
-    apply_equivalence_and_extra_data(old_element, element, new_element)?;
+    apply_equivalence_and_extra_data(old_element, element, new_element, cancelled)?;
     apply_raw_delta(element, new_element)?;
 
     let old_disasm = make_disassembler(exe_type, old_element)
@@ -270,11 +282,13 @@ fn apply_equivalence_and_extra_data(
     old_image: &[u8],
     element: &PatchElement,
     new_image: &mut [u8],
+    cancelled: &dyn Fn() -> bool,
 ) -> Result<()> {
     let mut extra_cursor = 0usize;
     let mut dst_it = 0usize;
 
     for equivalence in &element.equivalences {
+        check_not_cancelled(cancelled)?;
         let next_dst_it = equivalence.dst_offset as usize;
         if next_dst_it < dst_it {
             return Err(apply_error("overlapping equivalences"));
@@ -381,7 +395,9 @@ fn apply_references_correction(
     old_image: &[u8],
     element: &PatchElement,
     new_image: &mut [u8],
+    cancelled: &dyn Fn() -> bool,
 ) -> Result<()> {
+    check_not_cancelled(cancelled)?;
     let old_disasm = make_disassembler(exe_type, old_image)
         .ok_or_else(|| apply_error("failed to create old disassembler"))?;
     let new_disasm = make_disassembler(exe_type, new_image)
@@ -405,6 +421,7 @@ fn apply_references_correction(
 
     let mut deltas = element.reference_deltas.iter();
     for (pool_tag, sub_groups) in &pools {
+        check_not_cancelled(cancelled)?;
         let mut targets = TargetPool::default();
         for &group_index in sub_groups {
             let references = old_disasm.read(group_index, old_image, 0, old_image.len() as u32);
@@ -425,6 +442,7 @@ fn apply_references_correction(
                 return Err(apply_error("new reference group is missing"));
             }
             for equivalence in &element.equivalences {
+                check_not_cancelled(cancelled)?;
                 let references = old_disasm.read(
                     group_index,
                     old_image,
diff --git a/src/zucchini_pure/mod.rs b/src/zucchini_pure/mod.rs
index 5955242..5899831 100644
--- a/src/zucchini_pure/mod.rs
+++ b/src/zucchini_pure/mod.rs
@@ -50,6 +50,7 @@ pub enum Status {
     ApplyError,
     AllocationFailure,
     UnsupportedTarget,
+    Cancelled,
     Unknown(i32),
 }
 
@@ -104,6 +105,38 @@ pub trait Disassembler {
 
 /// Applies a Zucchini patch into a newly allocated, exact-size output buffer.
 pub fn apply(old: &[u8], patch_bytes: &[u8], output_size: usize) -> Result<Vec<u8>> {
+    apply_with_cancel(old, patch_bytes, output_size, || false)
+}
+
+/// Same as [`apply`], but polls `cancelled` between elements, pools, and
+/// equivalence units and returns [`Status::Cancelled`] if it becomes true.
+///
+/// This keeps the original [`apply`] signature intact while giving callers a
+/// cooperative stop hook (for example, a UI or signal-driven token).
+pub fn apply_with_cancel<F: Fn() -> bool>(
+    old: &[u8],
+    patch_bytes: &[u8],
+    output_size: usize,
+    cancelled: F,
+) -> Result<Vec<u8>> {
+    apply_inner(old, patch_bytes, output_size, &cancelled)
+}
+
+fn apply_inner(
+    old: &[u8],
+    patch_bytes: &[u8],
+    output_size: usize,
+    cancelled: &dyn Fn() -> bool,
+) -> Result<Vec<u8>> {
+    let check = || -> Result<()> {
+        if cancelled() {
+            Err(Error::new(Status::Cancelled, "Zucchini apply cancelled"))
+        } else {
+            Ok(())
+        }
+    };
+
+    check()?;
     if old.len() >= OFFSET_BOUND || output_size >= OFFSET_BOUND {
         return Err(Error::new(Status::InvalidArgument, "image exceeds Zucchini offset bound"));
     }
@@ -141,13 +174,15 @@ pub fn apply(old: &[u8], patch_bytes: &[u8], output_size: usize) -> Result<Vec<u
     // Android hardens upstream apply with an additional preflight. Mirror the
     // native FFI so unsafe patches are rejected before publication.
     for element in &patch.elements {
-        engine::preflight_element(old, element, &mut output).map_err(|_| {
+        check()?;
+        engine::preflight_element(old, element, &mut output, cancelled).map_err(|_| {
             Error::new(Status::ApplyError, "android executable preflight failed")
         })?;
     }
 
     for element in &patch.elements {
-        engine::apply_element(old, element, &mut output)?;
+        check()?;
+        engine::apply_element(old, element, &mut output, cancelled)?;
     }
 
     if !patch::check_new_file(&patch.header, &output) {
diff --git a/tests/zucchini_pure.rs b/tests/zucchini_pure.rs
index aea954f..b507f8d 100644
--- a/tests/zucchini_pure.rs
+++ b/tests/zucchini_pure.rs
@@ -156,3 +156,21 @@ fn pure_rust_rejects_malformed_trailing_reference_delta() {
     let error = zucchini_pure::apply(old, &malformed, new.len()).unwrap_err();
     assert_eq!(error.status(), Status::ApplyError);
 }
+
+#[test]
+fn pure_rust_honors_cancellation() {
+    use std::cell::Cell;
+
+    let fixtures = Path::new(FIXTURES);
+    let old = fs::read(fixtures.join("noop-old.bin")).unwrap();
+    let patch = fs::read(fixtures.join("noop.zuc")).unwrap();
+    let new_size = fs::metadata(fixtures.join("noop-new.bin")).unwrap().len() as usize;
+
+    let calls = Cell::new(0);
+    let error = zucchini_pure::apply_with_cancel(&old, &patch, new_size, || {
+        calls.set(calls.get() + 1);
+        calls.get() > 1
+    })
+    .unwrap_err();
+    assert_eq!(error.status(), Status::Cancelled);
+}

From cc36e94c853557bd6443007a0a222aa6dd6ca36e Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 17:56:45 +0530
Subject: [PATCH 22/42] zucchini: make pure Rust the only apply path; C++
 becomes opt-in

- src/zucchini.rs now delegates to zucchini_pure and maps status/message
- build.rs builds the vendored C++/libchrome only with
  OTADUMP_NATIVE_ZUCCHINI=1 (differential testing); the default build and
  full test suite no longer require C++
- align preflight/old-file and new-file messages with the native FFI
- add a cfg-gated native-vs-pure differential fixture test
---
 build.rs                 |  12 ++++-
 src/zucchini.rs          | 105 +++++++++++++++++++++++----------------
 src/zucchini_pure/mod.rs |  12 +++--
 tests/zucchini_pure.rs   |  37 ++++++++++++++
 4 files changed, 115 insertions(+), 51 deletions(-)

diff --git a/build.rs b/build.rs
index 80fedb8..a6a164d 100644
--- a/build.rs
+++ b/build.rs
@@ -51,15 +51,23 @@ const LZ4_SOURCES: &[&str] = &[
 fn main() {
     println!("cargo:rustc-check-cfg=cfg(otadump_lz4)");
     println!("cargo:rustc-check-cfg=cfg(otadump_zucchini)");
+    println!("cargo:rustc-check-cfg=cfg(otadump_native_zucchini)");
     println!("cargo:rerun-if-changed=src/protos/chromeos_update_engine/update_metadata.proto");
     if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("linux")
         && std::env::var("CARGO_CFG_TARGET_ARCH").as_deref() == Ok("x86_64")
         && std::env::var("CARGO_CFG_TARGET_ENV").as_deref() == Ok("gnu")
     {
         build_lz4();
-        build_zucchini();
         println!("cargo:rustc-cfg=otadump_lz4");
-        println!("cargo:rustc-cfg=otadump_zucchini");
+    }
+
+    // Zucchini is implemented in pure Rust (`src/zucchini_pure`). The vendored
+    // C++/libchrome implementation is retained only for differential testing,
+    // enabled explicitly with `OTADUMP_NATIVE_ZUCCHINI=1`.
+    println!("cargo:rustc-cfg=otadump_zucchini");
+    if std::env::var_os("OTADUMP_NATIVE_ZUCCHINI").is_some() {
+        build_zucchini();
+        println!("cargo:rustc-cfg=otadump_native_zucchini");
     }
 
     let protoc = protoc_bin_vendored::protoc_bin_path().expect("unable to find vendored protoc");
diff --git a/src/zucchini.rs b/src/zucchini.rs
index 579581f..f639b06 100644
--- a/src/zucchini.rs
+++ b/src/zucchini.rs
@@ -1,8 +1,10 @@
 use std::error;
 use std::fmt;
 
+use crate::zucchini_pure;
+
 /// Exclusive upper bound for buffers represented by Zucchini offsets.
-pub const OFFSET_BOUND: usize = (u32::MAX / 2) as usize;
+pub const OFFSET_BOUND: usize = zucchini_pure::OFFSET_BOUND;
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum Status {
@@ -13,6 +15,7 @@ pub enum Status {
     ApplyError,
     AllocationFailure,
     UnsupportedTarget,
+    Cancelled,
     Unknown(i32),
 }
 
@@ -38,50 +41,46 @@ impl error::Error for Error {}
 
 pub type Result<T> = std::result::Result<T, Error>;
 
-/// Applies a Zucchini patch into a newly allocated, exact-size output buffer.
-///
-/// The native boundary borrows `old` and `patch` only for this call. The output
-/// allocation is distinct from both inputs, as required by Zucchini.
-pub fn apply(old: &[u8], patch: &[u8], output_size: usize) -> Result<Vec<u8>> {
-    apply_impl(old, patch, output_size)
-}
-
-#[cfg(otadump_zucchini)]
-fn apply_impl(old: &[u8], patch: &[u8], output_size: usize) -> Result<Vec<u8>> {
-    if old.len() >= OFFSET_BOUND || output_size >= OFFSET_BOUND {
-        return Err(Error {
-            status: Status::InvalidArgument,
-            message: "image exceeds Zucchini offset bound".into(),
-        });
-    }
-    if patch.len() >= OFFSET_BOUND {
-        return Err(Error {
-            status: Status::InvalidArgument,
-            message: "patch exceeds Zucchini offset bound".into(),
-        });
+fn map_status(status: zucchini_pure::Status) -> Status {
+    match status {
+        zucchini_pure::Status::InvalidArgument => Status::InvalidArgument,
+        zucchini_pure::Status::InvalidPatch => Status::InvalidPatch,
+        zucchini_pure::Status::UnsupportedElement => Status::UnsupportedElement,
+        zucchini_pure::Status::WrongOutputSize => Status::WrongOutputSize,
+        zucchini_pure::Status::ApplyError => Status::ApplyError,
+        zucchini_pure::Status::AllocationFailure => Status::AllocationFailure,
+        zucchini_pure::Status::UnsupportedTarget => Status::UnsupportedTarget,
+        zucchini_pure::Status::Cancelled => Status::Cancelled,
+        zucchini_pure::Status::Unknown(code) => Status::Unknown(code),
     }
+}
 
-    let mut output = Vec::new();
-    output.try_reserve_exact(output_size).map_err(|error| Error {
-        status: Status::AllocationFailure,
-        message: format!("unable to allocate Zucchini output: {error}"),
-    })?;
-    output.resize(output_size, 0);
+fn map_error(error: zucchini_pure::Error) -> Error {
+    Error { status: map_status(error.status()), message: error.to_string() }
+}
 
-    apply_native(old, patch, &mut output)?;
-    Ok(output)
+/// Applies a Zucchini patch into a newly allocated, exact-size output buffer.
+///
+/// This is now backed entirely by the pure-Rust implementation in
+/// `zucchini_pure`; the vendored C++ Zucchini is no longer required.
+pub fn apply(old: &[u8], patch: &[u8], output_size: usize) -> Result<Vec<u8>> {
+    zucchini_pure::apply(old, patch, output_size).map_err(map_error)
 }
 
-#[cfg(not(otadump_zucchini))]
-fn apply_impl(_old: &[u8], _patch: &[u8], _output_size: usize) -> Result<Vec<u8>> {
-    Err(Error {
-        status: Status::UnsupportedTarget,
-        message: "Zucchini is supported only on Linux x86_64 GNU hosts".into(),
-    })
+/// Same as [`apply`], but cooperatively stops when `cancelled` returns true.
+pub fn apply_with_cancel<F: Fn() -> bool>(
+    old: &[u8],
+    patch: &[u8],
+    output_size: usize,
+    cancelled: F,
+) -> Result<Vec<u8>> {
+    zucchini_pure::apply_with_cancel(old, patch, output_size, cancelled).map_err(map_error)
 }
 
-#[cfg(otadump_zucchini)]
-fn apply_native(old: &[u8], patch: &[u8], output: &mut [u8]) -> Result<()> {
+/// The vendored C++ implementation, retained only for differential testing when
+/// `OTADUMP_NATIVE_ZUCCHINI=1` selects it at build time.
+#[cfg(otadump_native_zucchini)]
+pub fn apply_native(old: &[u8], patch: &[u8], output_size: usize) -> Result<Vec<u8>> {
     use std::ffi::{CStr, c_char};
 
     #[repr(C)]
@@ -101,9 +100,28 @@ fn apply_native(old: &[u8], patch: &[u8], output: &mut [u8]) -> Result<()> {
         ) -> NativeResult;
     }
 
+    if old.len() >= OFFSET_BOUND || output_size >= OFFSET_BOUND {
+        return Err(Error {
+            status: Status::InvalidArgument,
+            message: "image exceeds Zucchini offset bound".into(),
+        });
+    }
+    if patch.len() >= OFFSET_BOUND {
+        return Err(Error {
+            status: Status::InvalidArgument,
+            message: "patch exceeds Zucchini offset bound".into(),
+        });
+    }
+
+    let mut output = Vec::new();
+    output.try_reserve_exact(output_size).map_err(|error| Error {
+        status: Status::AllocationFailure,
+        message: format!("unable to allocate Zucchini output: {error}"),
+    })?;
+    output.resize(output_size, 0);
+
     // SAFETY: The slices remain alive for the call. `output` is a separate
-    // owned allocation and cannot overlap either borrowed input. The native
-    // function validates every length before it performs pointer arithmetic.
+    // owned allocation and cannot overlap either borrowed input.
     let result = unsafe {
         otadump_zucchini_apply(
             old.as_ptr(),
@@ -115,20 +133,19 @@ fn apply_native(old: &[u8], patch: &[u8], output: &mut [u8]) -> Result<()> {
         )
     };
     if result.status == 0 {
-        return Ok(());
+        return Ok(output);
     }
 
     let message = if result.error.is_null() {
         format!("Zucchini failed with status {}", result.status)
     } else {
-        // SAFETY: Native errors point to static NUL-terminated strings. Copy
-        // the message before returning so Rust does not retain the pointer.
+        // SAFETY: Native errors point to static NUL-terminated strings.
         unsafe { CStr::from_ptr(result.error) }.to_string_lossy().into_owned()
     };
     Err(Error { status: native_status(result.status), message })
 }
 
-#[cfg(otadump_zucchini)]
+#[cfg(otadump_native_zucchini)]
 fn native_status(status: i32) -> Status {
     match status {
         1 => Status::InvalidArgument,
diff --git a/src/zucchini_pure/mod.rs b/src/zucchini_pure/mod.rs
index 5899831..243d216 100644
--- a/src/zucchini_pure/mod.rs
+++ b/src/zucchini_pure/mod.rs
@@ -148,9 +148,6 @@ fn apply_inner(
     if patch.header.new_size as usize != output_size {
         return Err(Error::new(Status::WrongOutputSize, "output buffer size does not match patch"));
     }
-    if !patch::check_old_file(&patch.header, old) {
-        return Err(Error::new(Status::ApplyError, "invalid old image"));
-    }
 
     // Reject element formats that Android never emits, matching the native FFI
     // allow-list (NoOp plus Android executables).
@@ -172,7 +169,12 @@ fn apply_inner(
     output.resize(output_size, 0);
 
     // Android hardens upstream apply with an additional preflight. Mirror the
-    // native FFI so unsafe patches are rejected before publication.
+    // native FFI so unsafe patches are rejected before publication. The native
+    // `PreflightAndroidElements` performs the old-file check here too, hence the
+    // preflight-specific message.
+    if !patch::check_old_file(&patch.header, old) {
+        return Err(Error::new(Status::ApplyError, "android executable preflight failed"));
+    }
     for element in &patch.elements {
         check()?;
         engine::preflight_element(old, element, &mut output, cancelled).map_err(|_| {
@@ -186,7 +188,7 @@ fn apply_inner(
     }
 
     if !patch::check_new_file(&patch.header, &output) {
-        return Err(Error::new(Status::ApplyError, "invalid new image"));
+        return Err(Error::new(Status::ApplyError, "zucchini apply failed"));
     }
     Ok(output)
 }
diff --git a/tests/zucchini_pure.rs b/tests/zucchini_pure.rs
index b507f8d..0fc1392 100644
--- a/tests/zucchini_pure.rs
+++ b/tests/zucchini_pure.rs
@@ -174,3 +174,40 @@ fn pure_rust_honors_cancellation() {
     .unwrap_err();
     assert_eq!(error.status(), Status::Cancelled);
 }
+
+/// Differential check against the vendored C++ implementation. Only compiled
+/// when `OTADUMP_NATIVE_ZUCCHINI=1` selected the native build.
+#[cfg(otadump_native_zucchini)]
+#[test]
+fn native_and_pure_agree_on_all_fixtures() {
+    let cases: &[(&str, &str, &str)] = &[
+        ("noop-old.bin", "noop.zuc", "noop-new.bin"),
+        ("elf-x86-old", "elf-x86.zuc", "elf-x86-new"),
+        ("elf-old", "elf.zuc", "elf-new"),
+        ("elf-arm32-old", "elf-arm32.zuc", "elf-arm32-new"),
+        ("elf-arm64-old", "elf-arm64.zuc", "elf-arm64-new"),
+        ("dex-old.dex", "dex.zuc", "dex-new.dex"),
+        ("dex-large-old.dex", "dex-large.zuc", "dex-large-new.dex"),
+        ("dex-large-old.dex", "dex-large-unsafe16.zuc", "dex-large-new.dex"),
+    ];
+    let fixtures = Path::new(FIXTURES);
+    for (old_name, patch_name, new_name) in cases {
+        let old = fs::read(fixtures.join(old_name)).unwrap();
+        let patch = fs::read(fixtures.join(patch_name)).unwrap();
+        let size = fs::metadata(fixtures.join(new_name)).unwrap().len() as usize;
+
+        let pure = zucchini_pure::apply(&old, &patch, size);
+        let native = otadump::zucchini::apply_native(&old, &patch, size);
+        match (pure, native) {
+            (Ok(a), Ok(b)) => assert_eq!(a, b, "output mismatch for {patch_name}"),
+            (Err(a), Err(b)) => assert_eq!(
+                format!("{:?}", a.status()),
+                format!("{:?}", b.status()),
+                "status mismatch for {patch_name}"
+            ),
+            (a, b) => panic!(
+                "pure {a:?} and native {b:?} disagree for {patch_name}"
+            ),
+        }
+    }
+}

From 755c9bca552a6e81af8cb7fd2c6b551d4b56a1a7 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 17:57:09 +0530
Subject: [PATCH 23/42] zucchini: document audit fixes, cancellation, size
 delta, and wiring

---
 docs/zucchini-rust-port.md | 146 ++++++++++++++++++++-----------------
 1 file changed, 81 insertions(+), 65 deletions(-)

diff --git a/docs/zucchini-rust-port.md b/docs/zucchini-rust-port.md
index ba5919a..d6eea36 100644
--- a/docs/zucchini-rust-port.md
+++ b/docs/zucchini-rust-port.md
@@ -1,18 +1,17 @@
 # Pure-Rust Zucchini apply port
 
-Status: prototype, verified byte-exact against every committed Zucchini fixture.
+Status: implemented and verified byte-exact against every committed Zucchini
+fixture. This is now the only apply path; the vendored C++/libchrome build is
+opt-in for differential testing.
 Scope: **apply only**, Android delta OTA element formats (`NoOp`, ELF
 x86/x86-64/AArch32/AArch64, DEX).
 
 ## Motivation
 
-The current PR vendors AOSP `external/zucchini` plus `external/libchrome` and
-compiles them from `build.rs` (`src/zucchini.rs` calls the
-`otadump_zucchini_apply` C ABI). That boundary is large: ~5,200 lines of
-disassembler/generator C++ and a vendored libchrome slice. otadump only ever
-*applies* patches, so almost all of that surface is unnecessary.
-
-This port reimplements the apply path in safe Rust under
+The original PR vendored AOSP `external/zucchini` plus `external/libchrome` and
+compiled them from `build.rs` (`src/zucchini.rs` called the
+`otadump_zucchini_apply` C ABI). otadump only ever *applies* patches, so almost
+all of that surface was unnecessary. The apply path is now safe Rust under
 `src/zucchini_pure/`, with no C++ and no libchrome.
 
 ## What is implemented
@@ -29,9 +28,9 @@ This port reimplements the apply path in safe Rust under
 | Android preflight hardening | `native/zucchini/src/zucchini_ffi.cc` | `engine.rs` |
 | Little-endian helpers and bit fields | `buffer_view.h`, `algorithm.h` | `bytes.rs` |
 
-The `Disassembler` trait in `mod.rs` is the only abstraction the engine needs:
-size, reference groups, ranged reads, and single-reference writes. Both ELF and
-DEX implement it; `make_disassembler` rejects non-Android formats
+`Disassembler` (in `mod.rs`) is the only abstraction the engine needs: size,
+reference groups, ranged reads, and single-reference writes. ELF and DEX
+implement it; `make_disassembler` rejects non-Android formats
 (`UnsupportedElement`), matching the native FFI allow-list.
 
 ## Verification
@@ -42,64 +41,81 @@ DEX implement it; `make_disassembler` rejects non-Android formats
 - `elf-x86.zuc`, `elf.zuc`, `elf-arm32.zuc`, `elf-arm64.zuc`
 - `dex.zuc`, `dex-large.zuc` (65,537 strings, 16-bit and 32-bit code refs)
 
-Negative cases check that garbage and truncated patches return
-`Status::InvalidPatch`, a mismatched output size returns
-`Status::WrongOutputSize`, and `dex-large-unsafe16.zuc` is rejected by the
-ported Android preflight with `"android executable preflight failed"`,
-matching the native test exactly.
+Negative/edge cases: garbage and truncated patches (`InvalidPatch`), a
+mismatched output size (`WrongOutputSize`), a malformed trailing reference-delta
+varint, cancellation, and `dex-large-unsafe16.zuc` (rejected by the ported
+Android preflight with `"android executable preflight failed"`).
+
+Unit regressions cover the DEX opcode table boundary, DEX payload bounds, the
+THUMB2 instruction-size advance, and ELF64 program-header bounds.
 
-Run with:
+The native `tests/delta_extraction.rs` suite (which exercises extraction through
+`zucchini::apply`) now runs against the pure implementation. The full suite
+passes with no C++ configured:
 
 ```sh
-cargo test --test zucchini_pure
+cargo test
+cargo clippy --all-targets --all-features -- -D warnings
 ```
 
-The fixtures were already portable; no new goldens were required. This makes an
-incremental landing possible: each format/architecture can be merged and
-validated independently.
-
-## Fixture coverage caveat
-
-The fixtures exercise only a subset of each format's reference types (for
-example `elf-x86`/`elf` only hit rel32, `elf-arm32` only A24, `elf-arm64` only
-Immd26). Passing them is necessary but not sufficient. This port implements
-every reference type the native disassemblers emit, so it is deliberately
-broader than the fixtures. The committed `dex-large-unsafe16.zuc` fixture
-exercises the Android-only preflight path end to end.
-
-## Blockers and the smallest C++ boundary
-
-A complete pure-Rust apply rewrite is realized for Android element formats. The
-remaining work is engineering hardening and wiring, not missing format support:
-
-1. **Android preflight hardening — ported.** The native FFI's extra validations
-   (`ValidateReferenceBoundaries`, `ValidateDexWriterWidths`,
-   `ValidateDexReferenceTargets`) now live in the Rust engine and run before the
-   apply pass, reproducing the native `"android executable preflight failed"`
-   rejection.
-
-2. **Smallest C++ boundary: zero for apply-only builds.** With the preflight
-   ported, nothing on the apply path needs C++. The `native/` tree, vendored
-   libchrome, `cc` build dependency, and the `otadump_zucchini` cfg can be
-   removed for apply-only builds. The remaining C++ is only useful if patch
-   *generation* is ever added.
-
-3. **Non-Android formats (Win32, ZTF).** Not emitted by Android payloads and
-   intentionally rejected. Porting them would only matter for non-Android use.
-
-4. **Performance parity.** The C++ readers are lazy state machines; the Rust
+## Audit fixes applied
+
+1. **Trailing reference-delta varints.** `Cursor::var_u32` no longer consumes
+   bytes on decode failure (mirroring `DecodeVarUInt`/`ParseVarUInt`), and
+   `apply_references_correction` now honors `reference_deltas_done` like native
+   `ReferenceDeltaSource::Done()`.
+2. **DEX opcode 0xFF.** The opcode-table range check widened to `u16`, so
+   `0xFF + 1` no longer wraps to 0. `const-method-type` now parses and its proto
+   reference is corrected.
+3. **THUMB2 advancement.** The scanner returns the decoded instruction size (4
+   for an unmatched 32-bit instruction) and the parser advances by it instead of
+   always stepping 2; it also avoids fetching past the region.
+4. **ELF64 program headers.** `p_offset`/`p_filesz` are summed and bounds-checked
+   as `u64` before narrowing to `offset_t`, so 2^32 offsets cannot truncate into
+   a small valid-looking segment.
+5. **DEX payload offsets.** The payload bound is measured against remaining
+   instruction units, not the whole code item.
+6. **Preflight sizes.** The preflight checks both the old and new disassembler
+   sizes.
+7. **Checked DEX map sizing.** Map-array sizes use checked multiplication, and
+   attacker-sized parser vectors use `try_reserve` instead of infallible
+   `with_capacity`.
+
+## Cancellation and allocation
+
+`apply()` keeps its signature. `apply_with_cancel(old, patch, size, cancelled)`
+polls a `Fn() -> bool` between elements, pools, and equivalence units and returns
+`Status::Cancelled`. `src/zucchini.rs` exposes the same hook. Parser allocations
+derived from attacker-controlled counts use `try_reserve`.
+
+## Intentional behavioural and size deltas
+
+- **Stricter than upstream Zucchini by design.** The ported Android preflight
+  (`ValidateReferenceBoundaries`, `ValidateDexWriterWidths`,
+  `ValidateDexReferenceTargets`) rejects patches upstream would accept. This
+  matches the AndroidDumps native FFI exactly; `dex-large-unsafe16.zuc` is the
+  canonical case.
+- **Message alignment.** An old-file failure reports
+  `"android executable preflight failed"` and a final new-file mismatch reports
+  `"zucchini apply failed"`, matching the native FFI's ordering.
+- **Size.** The vendored C++ boundary is 2.4 MB of source (37 C/C++ files) and
+  produces a 14,559,914-byte debug static archive including the libchrome slice.
+  The pure-Rust module compiles to a 244,312-byte object (≈127 KB of text) at
+  `-C opt-level=2`. The default `build.rs` now builds only protobuf and the
+  small C lz4 library.
+
+## Remaining work
+
+1. **Performance parity.** The C++ readers are lazy state machines; the Rust
    `read` recomputes each group's references per range query, so DEX apply is
    `O(groups × equivalences × items)`. Correct but slower on real partitions.
-   Before production cutover, cache each group's full reference list once per
-   parsed image (the engine already asks for it once per pool).
-
-5. **Wiring.** `zucchini_pure` is exposed alongside `zucchini::apply` rather
-   than replacing it, so the native path and tests remain intact. The final
-   step is to route `zucchini::apply` to the pure implementation and drop the
-   `otadump_zucchini` cfg/build once item 4 is addressed.
-
-## Reproducing the measurement
-
-The mini C++ diagnostic used to confirm which reference types each fixture
-touches lives outside the repo; the equivalent information is available from
-`tests/fixtures/zucchini/README.md` and the group tables in `dex.rs`/`elf.rs`.
+   Cache each group's full reference list once per parsed image before
+   production cutover.
+2. **Differential testing.** Building the native path
+   (`OTADUMP_NATIVE_ZUCCHINI=1 cargo test`) enables
+   `native_and_pure_agree_on_all_fixtures`. That build currently fails to link in
+   this environment on pre-existing libchrome symbols
+   (`base::Histogram::FactoryGet` from `activity_tracker.cc`), unrelated to the
+   Rust port; the default, pure build is unaffected.
+3. **Non-Android formats (Win32, ZTF).** Not emitted by Android payloads and
+   intentionally rejected.

From 192b1556dc81db585f7bfd404390dc681ae1bf4e Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 17:57:41 +0530
Subject: [PATCH 24/42] zucchini: rerun build script when the native
 differential toggle changes

---
 build.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/build.rs b/build.rs
index a6a164d..095e20a 100644
--- a/build.rs
+++ b/build.rs
@@ -53,6 +53,7 @@ fn main() {
     println!("cargo:rustc-check-cfg=cfg(otadump_zucchini)");
     println!("cargo:rustc-check-cfg=cfg(otadump_native_zucchini)");
     println!("cargo:rerun-if-changed=src/protos/chromeos_update_engine/update_metadata.proto");
+    println!("cargo:rerun-if-env-changed=OTADUMP_NATIVE_ZUCCHINI");
     if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("linux")
         && std::env::var("CARGO_CFG_TARGET_ARCH").as_deref() == Ok("x86_64")
         && std::env::var("CARGO_CFG_TARGET_ENV").as_deref() == Ok("gnu")

From 7909945ebe9bf260bc6037ba07178cb347e14487 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 17:57:47 +0530
Subject: [PATCH 25/42] zucchini: read TypeId descriptor string indices with
 32-bit width in DEX apply

Differential testing against C++ Zucchini found a divergence in DEX TypeId
string reference reading: group 0 (TypeIdItem::descriptor_idx -> StringId) was
reading the index using string_index(2) instead of string_index(4). This truncated
32-bit descriptor string IDs to 16 bits, ignoring corrupted upper bytes.
---
 src/zucchini_pure/dex.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
index 1499af2..cb80c07 100644
--- a/src/zucchini_pure/dex.rs
+++ b/src/zucchini_pure/dex.rs
@@ -997,7 +997,7 @@ impl Disassembler for DexDisassembler {
         };
         let proto_index = ItemMapper::TargetIndex { map: self.proto_map, item_size: 12, width: 2 };
         match group {
-            0 => item_reader(image, lo, hi, self.type_map, 4, 0, string_index(2), false),
+            0 => item_reader(image, lo, hi, self.type_map, 4, 0, string_index(4), false),
             1 => item_reader(image, lo, hi, self.proto_map, 12, 0, string_index(4), false),
             2 => item_reader(image, lo, hi, self.field_map, 8, 4, string_index(4), false),
             3 => item_reader(image, lo, hi, self.method_map, 8, 4, string_index(4), false),

From 1d40d4c0a09cf393cdfead88dfcda7876395cf7f Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 17:59:29 +0530
Subject: [PATCH 26/42] zucchini: derive DEX index read width from the group
 width

Builds on the group-0 (TypeId::descriptor_idx) differential fix: every
index-based DEX mapper's read width equals its group's declared reference
width, so derive it centrally instead of hardcoding per group. This fixes
the annotations-directory 32-bit ids (groups 19/22/23), which were still
being read as 16-bit and could silently truncate.

Adds a unit test showing 16-bit vs 32-bit index reads.
---
 src/zucchini_pure/dex.rs | 70 ++++++++++++++++++++++++----------------
 1 file changed, 43 insertions(+), 27 deletions(-)

diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
index cb80c07..e39884e 100644
--- a/src/zucchini_pure/dex.rs
+++ b/src/zucchini_pure/dex.rs
@@ -569,7 +569,7 @@ enum ItemMapper {
 
 #[derive(Clone, Copy)]
 enum ListMapper {
-    TargetIndex { map: MapItem, item_size: u32 },
+    TargetIndex { map: MapItem, item_size: u32, width: u8 },
     TargetOffset32,
 }
 
@@ -660,8 +660,8 @@ fn run_item_mapper(mapper: ItemMapper, image: &[u8], input: u32) -> u32 {
 
 fn run_list_mapper(mapper: ListMapper, image: &[u8], location: u32) -> u32 {
     match mapper {
-        ListMapper::TargetIndex { map, item_size } => {
-            read_target_index(image, map, item_size, location, 2)
+        ListMapper::TargetIndex { map, item_size, width } => {
+            read_target_index(image, map, item_size, location, width)
         }
         ListMapper::TargetOffset32 => read_target_offset32(image, location),
     }
@@ -985,6 +985,10 @@ impl Disassembler for DexDisassembler {
 
     #[allow(clippy::too_many_lines)]
     fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Vec<Reference> {
+        // The index field width equals the group's declared reference width for
+        // every index-based mapper (e.g. annotations-directory ids are 32-bit),
+        // so derive it instead of hardcoding per group.
+        let width = self.groups[group].width as u8;
         let string_index = |width: u8| ItemMapper::TargetIndex {
             map: self.string_map,
             item_size: 4,
@@ -995,20 +999,20 @@ impl Disassembler for DexDisassembler {
             item_size: 4,
             width,
         };
-        let proto_index = ItemMapper::TargetIndex { map: self.proto_map, item_size: 12, width: 2 };
+        let proto_index = ItemMapper::TargetIndex { map: self.proto_map, item_size: 12, width };
         match group {
-            0 => item_reader(image, lo, hi, self.type_map, 4, 0, string_index(4), false),
-            1 => item_reader(image, lo, hi, self.proto_map, 12, 0, string_index(4), false),
-            2 => item_reader(image, lo, hi, self.field_map, 8, 4, string_index(4), false),
-            3 => item_reader(image, lo, hi, self.method_map, 8, 4, string_index(4), false),
-            4 => item_reader(image, lo, hi, self.class_def_map, 32, 16, string_index(4), false),
+            0 => item_reader(image, lo, hi, self.type_map, 4, 0, string_index(width), false),
+            1 => item_reader(image, lo, hi, self.proto_map, 12, 0, string_index(width), false),
+            2 => item_reader(image, lo, hi, self.field_map, 8, 4, string_index(width), false),
+            3 => item_reader(image, lo, hi, self.method_map, 8, 4, string_index(width), false),
+            4 => item_reader(image, lo, hi, self.class_def_map, 32, 16, string_index(width), false),
             5 => instruction_reader(
                 image,
                 lo,
                 hi,
                 &self.code_item_offsets,
                 CodeFilter::String16,
-                InstrMapper::TargetIndex { map: self.string_map, item_size: 4, width: 2 },
+                InstrMapper::TargetIndex { map: self.string_map, item_size: 4, width },
             ),
             6 => instruction_reader(
                 image,
@@ -1016,21 +1020,21 @@ impl Disassembler for DexDisassembler {
                 hi,
                 &self.code_item_offsets,
                 CodeFilter::String32,
-                InstrMapper::TargetIndex { map: self.string_map, item_size: 4, width: 4 },
+                InstrMapper::TargetIndex { map: self.string_map, item_size: 4, width },
             ),
-            7 => item_reader(image, lo, hi, self.proto_map, 12, 4, type_index(4), false),
-            8 => item_reader(image, lo, hi, self.field_map, 8, 0, type_index(2), false),
-            9 => item_reader(image, lo, hi, self.field_map, 8, 2, type_index(2), false),
-            10 => item_reader(image, lo, hi, self.method_map, 8, 0, type_index(2), false),
-            11 => item_reader(image, lo, hi, self.class_def_map, 32, 0, type_index(4), false),
-            12 => item_reader(image, lo, hi, self.class_def_map, 32, 8, type_index(4), false),
+            7 => item_reader(image, lo, hi, self.proto_map, 12, 4, type_index(width), false),
+            8 => item_reader(image, lo, hi, self.field_map, 8, 0, type_index(width), false),
+            9 => item_reader(image, lo, hi, self.field_map, 8, 2, type_index(width), false),
+            10 => item_reader(image, lo, hi, self.method_map, 8, 0, type_index(width), false),
+            11 => item_reader(image, lo, hi, self.class_def_map, 32, 0, type_index(width), false),
+            12 => item_reader(image, lo, hi, self.class_def_map, 32, 8, type_index(width), false),
             13 => cached_item_list_reader(
                 image,
                 lo,
                 hi,
                 0,
                 &self.type_list_offsets,
-                ListMapper::TargetIndex { map: self.type_map, item_size: 4 },
+                ListMapper::TargetIndex { map: self.type_map, item_size: 4, width },
             ),
             14 => instruction_reader(
                 image,
@@ -1038,7 +1042,7 @@ impl Disassembler for DexDisassembler {
                 hi,
                 &self.code_item_offsets,
                 CodeFilter::Type,
-                InstrMapper::TargetIndex { map: self.type_map, item_size: 4, width: 2 },
+                InstrMapper::TargetIndex { map: self.type_map, item_size: 4, width },
             ),
             15 => instruction_reader(
                 image,
@@ -1046,7 +1050,7 @@ impl Disassembler for DexDisassembler {
                 hi,
                 &self.code_item_offsets,
                 CodeFilter::Proto,
-                InstrMapper::TargetIndex { map: self.proto_map, item_size: 12, width: 2 },
+                InstrMapper::TargetIndex { map: self.proto_map, item_size: 12, width },
             ),
             16 => item_reader(image, lo, hi, self.method_map, 8, 2, proto_index, false),
             17 => instruction_reader(
@@ -1055,7 +1059,7 @@ impl Disassembler for DexDisassembler {
                 hi,
                 &self.code_item_offsets,
                 CodeFilter::Field,
-                InstrMapper::TargetIndex { map: self.field_map, item_size: 8, width: 2 },
+                InstrMapper::TargetIndex { map: self.field_map, item_size: 8, width },
             ),
             18 => item_reader(
                 image,
@@ -1078,7 +1082,7 @@ impl Disassembler for DexDisassembler {
                 hi,
                 0,
                 &self.field_annotation_offsets,
-                ListMapper::TargetIndex { map: self.field_map, item_size: 8 },
+                ListMapper::TargetIndex { map: self.field_map, item_size: 8, width },
             ),
             20 => instruction_reader(
                 image,
@@ -1086,7 +1090,7 @@ impl Disassembler for DexDisassembler {
                 hi,
                 &self.code_item_offsets,
                 CodeFilter::Method,
-                InstrMapper::TargetIndex { map: self.method_map, item_size: 8, width: 2 },
+                InstrMapper::TargetIndex { map: self.method_map, item_size: 8, width },
             ),
             21 => item_reader(
                 image,
@@ -1109,7 +1113,7 @@ impl Disassembler for DexDisassembler {
                 hi,
                 0,
                 &self.method_annotation_offsets,
-                ListMapper::TargetIndex { map: self.method_map, item_size: 8 },
+                ListMapper::TargetIndex { map: self.method_map, item_size: 8, width },
             ),
             23 => cached_item_list_reader(
                 image,
@@ -1117,7 +1121,7 @@ impl Disassembler for DexDisassembler {
                 hi,
                 0,
                 &self.parameter_annotation_offsets,
-                ListMapper::TargetIndex { map: self.method_map, item_size: 8 },
+                ListMapper::TargetIndex { map: self.method_map, item_size: 8, width },
             ),
             24 => instruction_reader(
                 image,
@@ -1125,7 +1129,7 @@ impl Disassembler for DexDisassembler {
                 hi,
                 &self.code_item_offsets,
                 CodeFilter::CallSite,
-                InstrMapper::TargetIndex { map: self.call_site_map, item_size: 4, width: 2 },
+                InstrMapper::TargetIndex { map: self.call_site_map, item_size: 4, width },
             ),
             25 => instruction_reader(
                 image,
@@ -1133,7 +1137,7 @@ impl Disassembler for DexDisassembler {
                 hi,
                 &self.code_item_offsets,
                 CodeFilter::MethodHandle,
-                InstrMapper::TargetIndex { map: self.method_handle_map, item_size: 8, width: 2 },
+                InstrMapper::TargetIndex { map: self.method_handle_map, item_size: 8, width },
             ),
             26 => item_reader(image, lo, hi, self.proto_map, 12, 8, ItemMapper::TargetOffset32, false),
             27 => item_reader(
@@ -1367,4 +1371,16 @@ mod tests {
         assert_eq!(instructions.len(), 1);
         assert_eq!(instructions[0].opcode, 0x00);
     }
+
+    #[test]
+    fn target_index_width_controls_truncation() {
+        // Native reads `TypeIdItem::descriptor_idx` (group 0) and the
+        // annotations-directory ids (groups 19/22/23) as 32-bit indices; a
+        // hardcoded 16-bit read would silently truncate the high bytes.
+        let map = MapItem { size: 3, offset: 100 };
+        let mut image = vec![0u8; 120];
+        image[10..14].copy_from_slice(&0x0001_0002u32.to_le_bytes());
+        assert_eq!(read_target_index(&image, map, 4, 10, 4), K_INVALID_OFFSET);
+        assert_eq!(read_target_index(&image, map, 4, 10, 2), 108);
+    }
 }

From d4aa25ef4685f09d76f63ebd67aec9bcb10f946a Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 17:59:39 +0530
Subject: [PATCH 27/42] zucchini: document DEX index-width derivation

---
 docs/zucchini-rust-port.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/docs/zucchini-rust-port.md b/docs/zucchini-rust-port.md
index d6eea36..10e5c6c 100644
--- a/docs/zucchini-rust-port.md
+++ b/docs/zucchini-rust-port.md
@@ -80,6 +80,10 @@ cargo clippy --all-targets --all-features -- -D warnings
 7. **Checked DEX map sizing.** Map-array sizes use checked multiplication, and
    attacker-sized parser vectors use `try_reserve` instead of infallible
    `with_capacity`.
+8. **DEX index read widths.** Index-based mappers derive their read width from
+   the group's declared reference width (differential testing against native
+   caught group 0; this also fixes the 32-bit annotations-directory ids in
+   groups 19/22/23, which were being read as 16-bit).
 
 ## Cancellation and allocation
 

From aa05cc4bd8698bb328da4b8e09c07584b4e19605 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 18:08:13 +0530
Subject: [PATCH 28/42] zucchini: preserve cooperative cancellation end to end

- preflight no longer folds Status::Cancelled into the preflight ApplyError
- route extraction's run_op_zucchini through apply_with_cancel using the
  extraction token and surface typed cancellation for clean unwinding
- poll cancellation in the old/new CRC chunk loops, raw-delta application,
  boundary validation, DEX target validation, and per-reference correction
- Disassembler::read is now fallible so allocation failures can surface
- OTADUMP_NATIVE_ZUCCHINI now requires the exact value "1"
- add cancellation-through-preflight and CRC-chunk regression tests
---
 build.rs                    |  4 +-
 src/lib.rs                  | 18 ++++++++-
 src/zucchini_pure/crc32.rs  | 45 +++++++++++++++++++++
 src/zucchini_pure/dex.rs    |  8 ++--
 src/zucchini_pure/elf.rs    | 14 ++++---
 src/zucchini_pure/engine.rs | 81 ++++++++++++++++++++++++-------------
 src/zucchini_pure/mod.rs    | 18 ++++++---
 src/zucchini_pure/patch.rs  | 24 +++++++++++
 tests/zucchini_pure.rs      | 66 ++++++++++++++++++++++++++++++
 9 files changed, 230 insertions(+), 48 deletions(-)

diff --git a/build.rs b/build.rs
index 095e20a..0a5a4fb 100644
--- a/build.rs
+++ b/build.rs
@@ -64,9 +64,9 @@ fn main() {
 
     // Zucchini is implemented in pure Rust (`src/zucchini_pure`). The vendored
     // C++/libchrome implementation is retained only for differential testing,
-    // enabled explicitly with `OTADUMP_NATIVE_ZUCCHINI=1`.
+    // enabled explicitly with `OTADUMP_NATIVE_ZUCCHINI=1` (exact value only).
     println!("cargo:rustc-cfg=otadump_zucchini");
-    if std::env::var_os("OTADUMP_NATIVE_ZUCCHINI").is_some() {
+    if std::env::var("OTADUMP_NATIVE_ZUCCHINI").as_deref() == Ok("1") {
         build_zucchini();
         println!("cargo:rustc-cfg=otadump_native_zucchini");
     }
diff --git a/src/lib.rs b/src/lib.rs
index 4e28bed..1b082ed 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -990,8 +990,22 @@ impl Task<'_> {
         self.cancellation_token.check()?;
         let patch = decode_zucchini_patch(compressed_patch, self.cancellation_token)?;
         self.cancellation_token.check()?;
-        let output = zucchini::apply(&source, &patch, expected_output_len)
-            .map_err(|error| anyhow::anyhow!("ZUCCHINI apply failed: {error}"))?;
+        let output = zucchini::apply_with_cancel(
+            &source,
+            &patch,
+            expected_output_len,
+            || self.cancellation_token.is_cancelled(),
+        )
+        .map_err(|error| {
+            // Preserve cooperative cancellation as a typed error so the
+            // extraction layer can unwind cleanly; anything else is a patch
+            // failure.
+            if error.status() == zucchini::Status::Cancelled {
+                anyhow::Error::new(ExtractionCancelled)
+            } else {
+                anyhow::anyhow!("ZUCCHINI apply failed: {error}")
+            }
+        })?;
         self.cancellation_token.check()?;
         self.write_exact(&output, dst_extents)
     }
diff --git a/src/zucchini_pure/crc32.rs b/src/zucchini_pure/crc32.rs
index 9d88a24..5197852 100644
--- a/src/zucchini_pure/crc32.rs
+++ b/src/zucchini_pure/crc32.rs
@@ -22,6 +22,37 @@ pub fn calculate_crc32(data: &[u8]) -> u32 {
     ret ^ 0xFFFF_FFFF
 }
 
+/// Number of bytes between cancellation polls while hashing.
+pub const CRC_POLL_CHUNK: usize = 1 << 20;
+
+/// Same as [`calculate_crc32`], but polls `cancelled` between chunks and
+/// returns `Status::Cancelled` instead of running to completion.
+pub fn calculate_crc32_cancel(
+    data: &[u8],
+    cancelled: &dyn Fn() -> bool,
+) -> super::Result<u32> {
+    if cancelled() {
+        return Err(super::Error::new(
+            super::Status::Cancelled,
+            "Zucchini apply cancelled",
+        ));
+    }
+    let table = make_crc32_table();
+    let mut ret = 0xFFFF_FFFFu32;
+    for chunk in data.chunks(CRC_POLL_CHUNK) {
+        if cancelled() {
+            return Err(super::Error::new(
+                super::Status::Cancelled,
+                "Zucchini apply cancelled",
+            ));
+        }
+        for &byte in chunk {
+            ret = table[((ret ^ byte as u32) & 0xFF) as usize] ^ (ret >> 8);
+        }
+    }
+    Ok(ret ^ 0xFFFF_FFFF)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -31,4 +62,18 @@ mod tests {
         assert_eq!(calculate_crc32(b""), 0x0000_0000);
         assert_eq!(calculate_crc32(b"123456789"), 0xCBF4_3926);
     }
+
+    #[test]
+    fn cancellation_polls_between_chunks() {
+        let data = vec![0u8; CRC_POLL_CHUNK + 17];
+        assert_eq!(calculate_crc32_cancel(&data, &|| false).unwrap(), calculate_crc32(&data));
+
+        let calls = std::cell::Cell::new(0u32);
+        let error = calculate_crc32_cancel(&data, &|| {
+            calls.set(calls.get() + 1);
+            calls.get() >= 2
+        })
+        .unwrap_err();
+        assert_eq!(error.status(), super::super::Status::Cancelled);
+    }
 }
diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
index e39884e..90cdec9 100644
--- a/src/zucchini_pure/dex.rs
+++ b/src/zucchini_pure/dex.rs
@@ -3,7 +3,7 @@
 use std::collections::BTreeMap;
 
 use super::bytes::{align_ceil, read_i16, read_i32, read_i8, read_u16, read_u32, write_u16, write_u32};
-use super::{Disassembler, GroupTraits, Reference, K_INVALID_OFFSET, OFFSET_BOUND};
+use super::{Disassembler, GroupTraits, Reference, Result, K_INVALID_OFFSET, OFFSET_BOUND};
 
 const HEADER_SIZE: usize = 112;
 const CODE_ITEM_HEADER: usize = 16;
@@ -984,7 +984,7 @@ impl Disassembler for DexDisassembler {
     }
 
     #[allow(clippy::too_many_lines)]
-    fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Vec<Reference> {
+    fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Result<Vec<Reference>> {
         // The index field width equals the group's declared reference width for
         // every index-based mapper (e.g. annotations-directory ids are 32-bit),
         // so derive it instead of hardcoding per group.
@@ -1000,7 +1000,7 @@ impl Disassembler for DexDisassembler {
             width,
         };
         let proto_index = ItemMapper::TargetIndex { map: self.proto_map, item_size: 12, width };
-        match group {
+        Ok(match group {
             0 => item_reader(image, lo, hi, self.type_map, 4, 0, string_index(width), false),
             1 => item_reader(image, lo, hi, self.proto_map, 12, 0, string_index(width), false),
             2 => item_reader(image, lo, hi, self.field_map, 8, 4, string_index(width), false),
@@ -1264,7 +1264,7 @@ impl Disassembler for DexDisassembler {
                 false,
             ),
             _ => Vec::new(),
-        }
+        })
     }
 
     fn write(&self, group: usize, image: &mut [u8], reference: Reference) {
diff --git a/src/zucchini_pure/elf.rs b/src/zucchini_pure/elf.rs
index f9fe797..a47580f 100644
--- a/src/zucchini_pure/elf.rs
+++ b/src/zucchini_pure/elf.rs
@@ -6,7 +6,9 @@ use super::bytes::{
     align_ceil, increment_for_align_ceil2, increment_for_align_ceil4, range_covers,
     range_is_bounded, read_i32, read_u16, read_u32, read_u64, write_u16, write_u32, write_u64,
 };
-use super::{Disassembler, GroupTraits, Reference, K_INVALID_OFFSET, K_INVALID_RVA, OFFSET_BOUND};
+use super::{
+    Disassembler, GroupTraits, Reference, Result, K_INVALID_OFFSET, K_INVALID_RVA, OFFSET_BOUND,
+};
 
 const K_RVA_BOUND: u32 = 0x7FFF_FFFF;
 const K_SIZE_BOUND: u64 = 0x7FFF_0000;
@@ -767,14 +769,14 @@ impl Disassembler for ElfDisassembler {
         &self.groups
     }
 
-    fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Vec<Reference> {
+    fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Result<Vec<Reference>> {
         if group == 0 {
-            return self.read_relocs(image, lo, hi);
+            return Ok(self.read_relocs(image, lo, hi));
         }
         if group == 1 {
-            return self.read_abs32(image, lo, hi);
+            return Ok(self.read_abs32(image, lo, hi));
         }
-        match self.kind {
+        Ok(match self.kind {
             ElfKind::X86 | ElfKind::X64 => self.read_rel32_intel(image, lo, hi),
             ElfKind::AArch32 | ElfKind::AArch64 => {
                 // Group index == address type index + 2 for ARM.
@@ -785,7 +787,7 @@ impl Disassembler for ElfDisassembler {
                     Vec::new()
                 }
             }
-        }
+        })
     }
 
     fn write(&self, group: usize, image: &mut [u8], reference: Reference) {
diff --git a/src/zucchini_pure/engine.rs b/src/zucchini_pure/engine.rs
index 978becc..d57c707 100644
--- a/src/zucchini_pure/engine.rs
+++ b/src/zucchini_pure/engine.rs
@@ -33,8 +33,8 @@ impl Disassembler for NoOpDisassembler {
         &[]
     }
 
-    fn read(&self, _group: usize, _image: &[u8], _lo: u32, _hi: u32) -> Vec<Reference> {
-        Vec::new()
+    fn read(&self, _group: usize, _image: &[u8], _lo: u32, _hi: u32) -> Result<Vec<Reference>> {
+        Ok(Vec::new())
     }
 
     fn write(&self, _group: usize, _image: &mut [u8], _reference: Reference) {}
@@ -74,7 +74,7 @@ pub(crate) fn apply_element(
         .ok_or_else(|| apply_error("new element out of bounds"))?;
 
     apply_equivalence_and_extra_data(old_element, element, new_element, cancelled)?;
-    apply_raw_delta(element, new_element)?;
+    apply_raw_delta(element, new_element, cancelled)?;
     apply_references_correction(matching.exe_type, old_element, element, new_element, cancelled)?;
     Ok(())
 }
@@ -109,7 +109,7 @@ pub(crate) fn preflight_element(
         .ok_or_else(|| apply_error("new element out of bounds"))?;
 
     apply_equivalence_and_extra_data(old_element, element, new_element, cancelled)?;
-    apply_raw_delta(element, new_element)?;
+    apply_raw_delta(element, new_element, cancelled)?;
 
     let old_disasm = make_disassembler(exe_type, old_element)
         .ok_or_else(|| apply_error("failed to create old disassembler"))?;
@@ -121,7 +121,14 @@ pub(crate) fn preflight_element(
         return Err(apply_error("disassembler and element size mismatch"));
     }
     let new_size = new_element.len() as u32;
-    if !validate_reference_boundaries(&*old_disasm, exe_type, element, old_element, new_size) {
+    if !validate_reference_boundaries(
+        &*old_disasm,
+        exe_type,
+        element,
+        old_element,
+        new_size,
+        cancelled,
+    )? {
         return Err(apply_error("reference boundary violation"));
     }
     if exe_type == EXE_TYPE_DEX {
@@ -134,21 +141,25 @@ pub(crate) fn preflight_element(
             element,
             old_element,
             new_element,
-        ) {
+            cancelled,
+        )? {
             return Err(apply_error("dex reference target violation"));
         }
     }
     Ok(())
 }
 
-/// Mirrors the FFI's `ValidateReferenceBoundaries`.
+/// Mirrors the FFI's `ValidateReferenceBoundaries`. Returns `Ok(true)` when the
+/// element is safe, `Ok(false)` on a boundary violation, and `Err(Cancelled)`
+/// if the caller cancels.
 fn validate_reference_boundaries(
     old_disasm: &dyn Disassembler,
     exe_type: u32,
     element: &PatchElement,
     old_image: &[u8],
     new_size: u32,
-) -> bool {
+    cancelled: &dyn Fn() -> bool,
+) -> Result<bool> {
     let mut boundaries: Vec<u32> = Vec::new();
     for equivalence in &element.equivalences {
         boundaries.push(equivalence.src_offset);
@@ -158,6 +169,7 @@ fn validate_reference_boundaries(
 
     let old_size = old_image.len() as u32;
     for (group_index, group) in old_disasm.groups().iter().enumerate() {
+        check_not_cancelled(cancelled)?;
         let mut writer_width = group.width;
         if group.type_tag == 0 {
             match exe_type {
@@ -167,49 +179,52 @@ fn validate_reference_boundaries(
             }
         }
 
-        for reference in old_disasm.read(group_index, old_image, 0, old_size) {
+        for reference in old_disasm.read(group_index, old_image, 0, old_size)? {
             let boundary = boundaries.partition_point(|value| *value <= reference.location);
             if boundary < boundaries.len()
                 && boundaries[boundary] < reference.location.wrapping_add(group.width)
             {
-                return false;
+                return Ok(false);
             }
         }
 
         for equivalence in &element.equivalences {
+            check_not_cancelled(cancelled)?;
             for reference in old_disasm.read(
                 group_index,
                 old_image,
                 equivalence.src_offset,
                 equivalence.src_end(),
-            ) {
+            )? {
                 if reference.location < equivalence.src_offset
                     || reference.location > equivalence.src_end()
                     || group.width > equivalence.src_end() - reference.location
                 {
-                    return false;
+                    return Ok(false);
                 }
                 let projected = equivalence.dst_offset.wrapping_add(
                     reference.location.wrapping_sub(equivalence.src_offset),
                 );
                 if projected > new_size || writer_width > new_size - projected {
-                    return false;
+                    return Ok(false);
                 }
             }
         }
     }
-    true
+    Ok(true)
 }
 
-/// Mirrors the FFI's `ValidateDexReferenceTargets`.
+/// Mirrors the FFI's `ValidateDexReferenceTargets`. Returns `Ok(true)` when the
+/// targets are safe, `Ok(false)` on violation, and `Err(Cancelled)` otherwise.
 fn validate_dex_reference_targets(
     old_disasm: &dyn Disassembler,
     new_disasm: &dyn Disassembler,
     element: &PatchElement,
     old_image: &[u8],
     new_image: &[u8],
-) -> bool {
-    let Some(string_ids) = dex::string_ids(new_image) else { return false };
+    cancelled: &dyn Fn() -> bool,
+) -> Result<bool> {
+    let Some(string_ids) = dex::string_ids(new_image) else { return Ok(false) };
 
     let mut pools: BTreeMap<u8, Vec<usize>> = BTreeMap::new();
     for (index, group) in old_disasm.groups().iter().enumerate() {
@@ -225,40 +240,42 @@ fn validate_dex_reference_targets(
     );
 
     for (pool_tag, sub_groups) in &pools {
+        check_not_cancelled(cancelled)?;
         let mut targets = TargetPool::default();
         for &group_index in sub_groups {
-            targets.insert_references(&old_disasm.read(group_index, old_image, 0, old_size));
+            targets.insert_references(&old_disasm.read(group_index, old_image, 0, old_size)?);
         }
         targets.filter_and_project(&mapper);
         if let Some(extra) = element.extra_targets.get(pool_tag) {
             targets.insert_targets(&extra.targets);
             if !extra.done {
-                return false;
+                return Ok(false);
             }
         }
 
         for &group_index in sub_groups {
             let type_tag = old_disasm.groups()[group_index].type_tag;
             if usize::from(type_tag) >= new_disasm.groups().len() {
-                return false;
+                return Ok(false);
             }
             for equivalence in &element.equivalences {
+                check_not_cancelled(cancelled)?;
                 for reference in old_disasm.read(
                     group_index,
                     old_image,
                     equivalence.src_offset,
                     equivalence.src_end(),
-                ) {
+                )? {
                     let projected = mapper.extended_forward_project(reference.target);
                     let expected = targets.key_for_nearest_offset(projected);
-                    let Some(delta) = deltas.next() else { return false };
+                    let Some(delta) = deltas.next() else { return Ok(false) };
                     let key = i64::from(expected) + i64::from(*delta);
                     if !(0..=i64::from(u32::MAX)).contains(&key) {
-                        return false;
+                        return Ok(false);
                     }
                     let key = key as u32;
                     if !targets.key_is_valid(key) {
-                        return false;
+                        return Ok(false);
                     }
                     if type_tag == 5 {
                         let target = targets.offset_for_key(key);
@@ -266,7 +283,7 @@ fn validate_dex_reference_targets(
                             || (target - string_ids.offset) % 4 != 0
                             || (target - string_ids.offset) / 4 > u32::from(u16::MAX)
                         {
-                            return false;
+                            return Ok(false);
                         }
                     }
                 }
@@ -274,7 +291,7 @@ fn validate_dex_reference_targets(
         }
     }
 
-    deltas.next().is_none() && element.reference_deltas_done
+    Ok(deltas.next().is_none() && element.reference_deltas_done)
 }
 
 /// Mirrors `ApplyEquivalenceAndExtraData`.
@@ -343,11 +360,16 @@ fn take_extra<'a>(extra: &'a [u8], cursor: &mut usize, size: usize) -> Result<&'
 }
 
 /// Mirrors `ApplyRawDelta`.
-fn apply_raw_delta(element: &PatchElement, new_image: &mut [u8]) -> Result<()> {
+fn apply_raw_delta(
+    element: &PatchElement,
+    new_image: &mut [u8],
+    cancelled: &dyn Fn() -> bool,
+) -> Result<()> {
     let mut base_copy_offset: u32 = 0;
     let mut equivalence_index = 0usize;
 
     for delta in &element.raw_deltas {
+        check_not_cancelled(cancelled)?;
         while equivalence_index < element.equivalences.len() {
             let equivalence = element.equivalences[equivalence_index];
             let end = base_copy_offset
@@ -424,7 +446,7 @@ fn apply_references_correction(
         check_not_cancelled(cancelled)?;
         let mut targets = TargetPool::default();
         for &group_index in sub_groups {
-            let references = old_disasm.read(group_index, old_image, 0, old_image.len() as u32);
+            let references = old_disasm.read(group_index, old_image, 0, old_image.len() as u32)?;
             targets.insert_references(&references);
         }
         targets.filter_and_project(&mapper);
@@ -448,8 +470,9 @@ fn apply_references_correction(
                     old_image,
                     equivalence.src_offset,
                     equivalence.src_end(),
-                );
+                )?;
                 for mut reference in references {
+                    check_not_cancelled(cancelled)?;
                     let projected = mapper.extended_forward_project(reference.target);
                     let expected_key = targets.key_for_nearest_offset(projected);
                     let delta = deltas
diff --git a/src/zucchini_pure/mod.rs b/src/zucchini_pure/mod.rs
index 243d216..01a982a 100644
--- a/src/zucchini_pure/mod.rs
+++ b/src/zucchini_pure/mod.rs
@@ -97,7 +97,10 @@ pub trait Disassembler {
     fn groups(&self) -> &[GroupTraits];
 
     /// Emits references of `group` whose bodies lie in `[lo, hi)`.
-    fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Vec<Reference>;
+    ///
+    /// Fallible so that reference vectors derived from attacker-controlled
+    /// counts can fail with `Status::AllocationFailure` instead of aborting.
+    fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Result<Vec<Reference>>;
 
     /// Writes a single corrected reference into the new image.
     fn write(&self, group: usize, image: &mut [u8], reference: Reference);
@@ -172,13 +175,18 @@ fn apply_inner(
     // native FFI so unsafe patches are rejected before publication. The native
     // `PreflightAndroidElements` performs the old-file check here too, hence the
     // preflight-specific message.
-    if !patch::check_old_file(&patch.header, old) {
+    if !patch::check_old_file_cancel(&patch.header, old, cancelled)? {
         return Err(Error::new(Status::ApplyError, "android executable preflight failed"));
     }
     for element in &patch.elements {
         check()?;
-        engine::preflight_element(old, element, &mut output, cancelled).map_err(|_| {
-            Error::new(Status::ApplyError, "android executable preflight failed")
+        engine::preflight_element(old, element, &mut output, cancelled).map_err(|error| {
+            // Preserve cooperative cancellation; everything else is a
+            // preflight validation failure.
+            match error.status() {
+                Status::Cancelled => error,
+                _ => Error::new(Status::ApplyError, "android executable preflight failed"),
+            }
         })?;
     }
 
@@ -187,7 +195,7 @@ fn apply_inner(
         engine::apply_element(old, element, &mut output, cancelled)?;
     }
 
-    if !patch::check_new_file(&patch.header, &output) {
+    if !patch::check_new_file_cancel(&patch.header, &output, cancelled)? {
         return Err(Error::new(Status::ApplyError, "zucchini apply failed"));
     }
     Ok(output)
diff --git a/src/zucchini_pure/patch.rs b/src/zucchini_pure/patch.rs
index 874e1f3..178218e 100644
--- a/src/zucchini_pure/patch.rs
+++ b/src/zucchini_pure/patch.rs
@@ -480,3 +480,27 @@ pub fn check_new_file(header: &PatchHeader, new_image: &[u8]) -> bool {
     new_image.len() == header.new_size as usize
         && super::crc32::calculate_crc32(new_image) == header.new_crc
 }
+
+/// Cancellable variant of [`check_old_file`].
+pub(crate) fn check_old_file_cancel(
+    header: &PatchHeader,
+    old_image: &[u8],
+    cancelled: &dyn Fn() -> bool,
+) -> Result<bool> {
+    if old_image.len() != header.old_size as usize {
+        return Ok(false);
+    }
+    Ok(super::crc32::calculate_crc32_cancel(old_image, cancelled)? == header.old_crc)
+}
+
+/// Cancellable variant of [`check_new_file`].
+pub(crate) fn check_new_file_cancel(
+    header: &PatchHeader,
+    new_image: &[u8],
+    cancelled: &dyn Fn() -> bool,
+) -> Result<bool> {
+    if new_image.len() != header.new_size as usize {
+        return Ok(false);
+    }
+    Ok(super::crc32::calculate_crc32_cancel(new_image, cancelled)? == header.new_crc)
+}
diff --git a/tests/zucchini_pure.rs b/tests/zucchini_pure.rs
index 0fc1392..54bd877 100644
--- a/tests/zucchini_pure.rs
+++ b/tests/zucchini_pure.rs
@@ -211,3 +211,69 @@ fn native_and_pure_agree_on_all_fixtures() {
         }
     }
 }
+
+/// Cancellation occurring while the Android preflight is running must surface
+/// as `Status::Cancelled`, not be folded into the preflight `ApplyError`.
+#[test]
+fn pure_rust_preserves_cancellation_through_preflight() {
+    use std::cell::Cell;
+
+    let fixtures = Path::new(FIXTURES);
+    for (old_name, patch_name, new_name) in
+        [("elf-old", "elf.zuc", "elf-new"), ("dex-old.dex", "dex.zuc", "dex-new.dex")]
+    {
+        let old = fs::read(fixtures.join(old_name)).unwrap();
+        let patch = fs::read(fixtures.join(patch_name)).unwrap();
+        let size = fs::metadata(fixtures.join(new_name)).unwrap().len() as usize;
+
+        // Every early poll site (CRC chunks, per-element, per-group, per
+        // equivalence, and DEX target validation) must preserve Cancelled.
+        for threshold in 1..=20u32 {
+            let calls = Cell::new(0u32);
+            let error = zucchini_pure::apply_with_cancel(&old, &patch, size, || {
+                calls.set(calls.get() + 1);
+                calls.get() >= threshold
+            })
+            .unwrap_err();
+            assert_eq!(
+                error.status(),
+                Status::Cancelled,
+                "{patch_name} threshold {threshold} lost cancellation: {error}"
+            );
+        }
+    }
+}
+
+/// A declared stream length larger than the patch must be rejected during
+/// parsing without attempting the allocation.
+#[test]
+fn pure_rust_rejects_absurd_declared_stream_length() {
+    let old = b"ABCD";
+    let new = b"ABCDE";
+    let mut patch = Vec::new();
+    patch.extend_from_slice(b"Zucc");
+    patch.extend_from_slice(&1u16.to_le_bytes());
+    patch.extend_from_slice(&0u16.to_le_bytes());
+    patch.extend_from_slice(&(old.len() as u32).to_le_bytes());
+    patch.extend_from_slice(&crc32(old).to_le_bytes());
+    patch.extend_from_slice(&(new.len() as u32).to_le_bytes());
+    patch.extend_from_slice(&crc32(new).to_le_bytes());
+    patch.extend_from_slice(&1u32.to_le_bytes());
+
+    patch.extend_from_slice(&0u32.to_le_bytes());
+    patch.extend_from_slice(&(old.len() as u32).to_le_bytes());
+    patch.extend_from_slice(&0u32.to_le_bytes());
+    patch.extend_from_slice(&(new.len() as u32).to_le_bytes());
+    patch.extend_from_slice(&u32::from_le_bytes(*b"NoOp").to_le_bytes());
+    patch.extend_from_slice(&1u16.to_le_bytes());
+
+    patch.extend_from_slice(&1u32.to_le_bytes());
+    patch.push(0); // src_skip
+    patch.extend_from_slice(&1u32.to_le_bytes());
+    patch.push(0); // dst_skip
+    // copy_count claims 4 GiB while the patch ends here.
+    patch.extend_from_slice(&u32::MAX.to_le_bytes());
+
+    let error = zucchini_pure::apply(old, &patch, new.len()).unwrap_err();
+    assert_eq!(error.status(), Status::InvalidPatch);
+}

From 2658c8d751ada69e4551dced913cfd72aa55825c Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 18:14:14 +0530
Subject: [PATCH 29/42] zucchini: fallible reservations for attacker-controlled
 vectors

- patch streams (equivalences, raw deltas, reference deltas, extra targets,
  extra data, elements) reserve with try_reserve; bound pool/element counts
- DEX item, code-reference, annotation and instruction vectors use
  try_reserve; Disassembler::read is fallible end to end
- ELF section/reloc/abs32/rel32/gap vectors and address-translator units use
  try_reserve instead of infallible clone/with_capacity
- preflight boundary vector reserves fallibly; OffsetMapper clone and
  TargetPool inserts are fallible
- add absurd stream/element/pool count regression tests
---
 src/zucchini_pure/dex.rs    |  50 +++++++----
 src/zucchini_pure/elf.rs    | 164 ++++++++++++++++++++++--------------
 src/zucchini_pure/engine.rs |  44 +++++++---
 src/zucchini_pure/mod.rs    |   5 ++
 src/zucchini_pure/patch.rs  |  59 +++++++++----
 tests/zucchini_pure.rs      |  21 +++++
 6 files changed, 232 insertions(+), 111 deletions(-)

diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
index 90cdec9..8616fae 100644
--- a/src/zucchini_pure/dex.rs
+++ b/src/zucchini_pure/dex.rs
@@ -345,6 +345,8 @@ fn parse_item_offsets(
         return None;
     }
     let mut offsets = Vec::new();
+    let upper = image.len().saturating_sub(map_item.offset as usize) / item_width;
+    offsets.try_reserve(upper).ok()?;
     let mut pos = map_item.offset as usize;
     for _ in 0..map_item.size {
         // AlignOn(image, 4).
@@ -377,12 +379,14 @@ fn parse_annotations_directory_items(
     let mut field_offsets = Vec::new();
     let mut method_offsets = Vec::new();
     let mut parameter_offsets = Vec::new();
+    directory_offsets.try_reserve(map_item.size as usize).ok()?;
     let mut pos = map_item.offset as usize;
 
     let parse_list = |pos: &mut usize, count: u32, width: usize, out: &mut Vec<u32>| -> Option<()> {
         if (image.len() - *pos) / width < count as usize {
             return None;
         }
+        out.try_reserve(count as usize).ok()?;
         for _ in 0..count {
             out.push(*pos as u32);
             *pos += width;
@@ -676,7 +680,7 @@ fn item_reader(
     rel_location: u32,
     mapper: ItemMapper,
     wants_item: bool,
-) -> Vec<Reference> {
+) -> Result<Vec<Reference>> {
     let item_base_offset = map.offset;
     let num_items = map.size;
     let mapper_input_delta = if wants_item { 0 } else { rel_location };
@@ -697,6 +701,9 @@ fn item_reader(
     }
 
     let mut result = Vec::new();
+    result
+        .try_reserve(num_items.saturating_sub(cur_idx) as usize)
+        .map_err(|_| super::allocation_error("DEX item references"))?;
     while cur_idx < num_items {
         let item_offset = offset_of_index(cur_idx);
         let location = item_offset.wrapping_add(rel_location);
@@ -716,7 +723,7 @@ fn item_reader(
             result.push(Reference { location, target });
         }
     }
-    result
+    Ok(result)
 }
 
 fn cached_item_list_reader(
@@ -726,12 +733,15 @@ fn cached_item_list_reader(
     rel_location: u32,
     offsets: &[u32],
     mapper: ListMapper,
-) -> Vec<Reference> {
+) -> Result<Vec<Reference>> {
     let mut index = offsets.partition_point(|offset| *offset <= lo);
     if index != 0 && offsets[index - 1].wrapping_add(rel_location) >= lo {
         index -= 1;
     }
     let mut result = Vec::new();
+    result
+        .try_reserve(offsets.len().saturating_sub(index))
+        .map_err(|_| super::allocation_error("DEX annotation references"))?;
     while index < offsets.len() {
         let location = offsets[index].wrapping_add(rel_location);
         if location >= hi {
@@ -747,7 +757,7 @@ fn cached_item_list_reader(
         }
         result.push(Reference { location, target });
     }
-    result
+    Ok(result)
 }
 
 #[derive(Clone, Copy)]
@@ -771,13 +781,16 @@ fn code_item_insns(image: &[u8], base_offset: u32) -> Option<(usize, usize)> {
     Some((start, end))
 }
 
-fn parse_instructions(image: &[u8], base_offset: u32) -> Vec<InstructionValue> {
+fn parse_instructions(image: &[u8], base_offset: u32) -> Result<Vec<InstructionValue>> {
     let Some((insns_start, insns_end)) = code_item_insns(image, base_offset) else {
-        return Vec::new();
+        return Ok(Vec::new());
     };
     let mut pos = insns_start;
     let mut boundary = insns_end;
     let mut result = Vec::new();
+    result
+        .try_reserve((insns_end - insns_start) / 2)
+        .map_err(|_| super::allocation_error("DEX instructions"))?;
     while pos < boundary {
         let opcode = image[pos];
         let Some(instruction) = find_instruction(opcode) else { break };
@@ -804,7 +817,7 @@ fn parse_instructions(image: &[u8], base_offset: u32) -> Vec<InstructionValue> {
         });
         pos += length_bytes;
     }
-    result
+    Ok(result)
 }
 
 fn filter_location(filter: CodeFilter, value: InstructionValue) -> Option<u32> {
@@ -879,26 +892,29 @@ fn instruction_reader(
     code_item_offsets: &[u32],
     filter: CodeFilter,
     mapper: InstrMapper,
-) -> Vec<Reference> {
+) -> Result<Vec<Reference>> {
     if code_item_offsets.is_empty() {
-        return Vec::new();
+        return Ok(Vec::new());
     }
     let mut index = code_item_offsets.partition_point(|offset| *offset <= lo);
     if index != 0 {
         index -= 1;
     }
     let mut result = Vec::new();
+    result
+        .try_reserve((hi.saturating_sub(lo) / 2) as usize)
+        .map_err(|_| super::allocation_error("DEX code references"))?;
     loop {
-        for value in parse_instructions(image, code_item_offsets[index]) {
+        for value in parse_instructions(image, code_item_offsets[index])? {
             if value.instr_offset >= hi {
-                return result;
+                return Ok(result);
             }
             let Some(location) = filter_location(filter, value) else { continue };
             if location == K_INVALID_OFFSET || location < lo {
                 continue;
             }
             if location >= hi {
-                return result;
+                return Ok(result);
             }
             let target = run_instr_mapper(mapper, image, location);
             if target != K_INVALID_OFFSET {
@@ -907,7 +923,7 @@ fn instruction_reader(
         }
         index += 1;
         if index >= code_item_offsets.len() {
-            return result;
+            return Ok(result);
         }
     }
 }
@@ -1000,7 +1016,7 @@ impl Disassembler for DexDisassembler {
             width,
         };
         let proto_index = ItemMapper::TargetIndex { map: self.proto_map, item_size: 12, width };
-        Ok(match group {
+        match group {
             0 => item_reader(image, lo, hi, self.type_map, 4, 0, string_index(width), false),
             1 => item_reader(image, lo, hi, self.proto_map, 12, 0, string_index(width), false),
             2 => item_reader(image, lo, hi, self.field_map, 8, 4, string_index(width), false),
@@ -1263,8 +1279,8 @@ impl Disassembler for DexDisassembler {
                 ItemMapper::TargetOffset32,
                 false,
             ),
-            _ => Vec::new(),
-        })
+            _ => Ok(Vec::new()),
+        }
     }
 
     fn write(&self, group: usize, image: &mut [u8], reference: Reference) {
@@ -1367,7 +1383,7 @@ mod tests {
         image[19] = 0x00; // vAA
         image[20..24].copy_from_slice(&9i32.to_le_bytes()); // payload offset
 
-        let instructions = parse_instructions(&image, 0);
+        let instructions = parse_instructions(&image, 0).unwrap();
         assert_eq!(instructions.len(), 1);
         assert_eq!(instructions[0].opcode, 0x00);
     }
diff --git a/src/zucchini_pure/elf.rs b/src/zucchini_pure/elf.rs
index a47580f..5f9ee61 100644
--- a/src/zucchini_pure/elf.rs
+++ b/src/zucchini_pure/elf.rs
@@ -13,6 +13,15 @@ use super::{
 const K_RVA_BOUND: u32 = 0x7FFF_FFFF;
 const K_SIZE_BOUND: u64 = 0x7FFF_0000;
 
+/// Fallible push: only grows the vector through `try_reserve`.
+fn push_checked<T>(vec: &mut Vec<T>, value: T) -> Option<()> {
+    if vec.len() == vec.capacity() {
+        vec.try_reserve(1).ok()?;
+    }
+    vec.push(value);
+    Some(())
+}
+
 const SHT_PROGBITS: u32 = 1;
 const SHT_RELA: u32 = 4;
 const SHT_NOBITS: u32 = 8;
@@ -246,7 +255,11 @@ impl AddressTranslator {
             return false;
         }
 
-        self.by_offset = units.clone();
+        self.by_offset = Vec::new();
+        if self.by_offset.try_reserve_exact(units.len()).is_err() {
+            return false;
+        }
+        self.by_offset.extend_from_slice(&units);
         units.sort_by_key(|unit| unit.rva_begin);
         self.by_rva = units;
         self.fake_offset_begin = offset_bound;
@@ -304,7 +317,10 @@ impl ElfDisassembler {
         let (sections, offset_bound) = parse_elf_header(kind, image)?;
 
         let mut units = Vec::new();
-        let mut judgements = vec![0i32; sections.len()];
+        units.try_reserve_exact(sections.len()).ok()?;
+        let mut judgements = Vec::new();
+        judgements.try_reserve_exact(sections.len()).ok()?;
+        judgements.resize(sections.len(), 0i32);
         let mut offset_bound = offset_bound;
 
         for (index, section) in sections.iter().enumerate() {
@@ -346,9 +362,9 @@ impl ElfDisassembler {
             rel32_locations: vec![Vec::new(); rel32_type_count(kind)],
         };
 
-        disassembler.extract_interesting_section_headers(&sections, &judgements);
+        disassembler.extract_interesting_section_headers(&sections, &judgements)?;
         disassembler.get_abs32_from_reloc_sections(image)?;
-        disassembler.get_rel32_from_code_sections(image);
+        disassembler.get_rel32_from_code_sections(image)?;
         Some(disassembler)
     }
 
@@ -356,7 +372,9 @@ impl ElfDisassembler {
         &mut self,
         sections: &[SectionHeader],
         judgements: &[i32],
-    ) {
+    ) -> Option<()> {
+        self.reloc_sections.try_reserve(sections.len()).ok()?;
+        self.exec_headers.try_reserve(sections.len()).ok()?;
         for (index, section) in sections.iter().enumerate() {
             if judgements[index] & (1 << 3) == 0 {
                 continue;
@@ -377,15 +395,19 @@ impl ElfDisassembler {
         }
         self.reloc_sections.sort_by_key(|section| section.offset);
         self.exec_headers.sort_by_key(|header| header.offset);
+        Some(())
     }
 
     fn get_abs32_from_reloc_sections(&mut self, image: &[u8]) -> Option<()> {
-        let relocs = self.read_relocs(image, 0, self.size);
-        let mut locations: Vec<u32> = relocs.iter().map(|reference| reference.target).collect();
+        let relocs = self.read_relocs(image, 0, self.size).ok()?;
+        let mut locations: Vec<u32> = Vec::new();
+        locations.try_reserve_exact(relocs.len()).ok()?;
+        locations.extend(relocs.iter().map(|reference| reference.target));
         locations.sort_unstable();
 
         // RemoveUntranslatableAbs32.
-        let mut kept = Vec::with_capacity(locations.len());
+        let mut kept = Vec::new();
+        kept.try_reserve_exact(locations.len()).ok()?;
         for location in locations {
             let value = self.read_absolute(location, image);
             let Some(value) = value else { continue };
@@ -413,27 +435,29 @@ impl ElfDisassembler {
         }
     }
 
-    fn get_rel32_from_code_sections(&mut self, image: &[u8]) {
-        let headers = self.exec_headers.clone();
-        for section in headers {
+    fn get_rel32_from_code_sections(&mut self, image: &[u8]) -> Option<()> {
+        let count = self.exec_headers.len();
+        for index in 0..count {
+            let section = self.exec_headers[index];
             if !self.kind.is_arm() {
-                self.parse_exec_section_intel(&section, image);
+                self.parse_exec_section_intel(&section, image)?;
             } else {
-                self.parse_exec_section_arm(&section, image);
+                self.parse_exec_section_arm(&section, image)?;
             }
         }
         for locations in self.rel32_locations.iter_mut() {
             locations.sort_unstable();
         }
+        Some(())
     }
 
-    fn parse_exec_section_intel(&mut self, section: &ExecHeader, image: &[u8]) {
+    fn parse_exec_section_intel(&mut self, section: &ExecHeader, image: &[u8]) -> Option<()> {
         let start_rva = section.addr;
         let end_rva = start_rva.wrapping_add(section.size);
-        let Some(region) = image.get(section.offset as usize..) else { return };
+        let Some(region) = image.get(section.offset as usize..) else { return Some(()) };
         let region = &region[..section.size.min(region.len() as u32) as usize];
         for (gap_start, gap_end) in
-            self.abs32_gaps(section.offset, section.offset.wrapping_add(section.size))
+            self.abs32_gaps(section.offset, section.offset.wrapping_add(section.size))?
         {
             let mut cursor = gap_start as usize;
             let gap_end = gap_end as usize;
@@ -447,7 +471,7 @@ impl ElfDisassembler {
                             && (can_point_outside
                                 || (start_rva <= target_rva && target_rva < end_rva))
                         {
-                            self.rel32_locations[0].push(location as u32);
+                            push_checked(&mut self.rel32_locations[0], location as u32)?;
                             cursor = location + 4;
                             continue;
                         }
@@ -457,15 +481,16 @@ impl ElfDisassembler {
             }
         }
         let _ = region;
+        Some(())
     }
 
-    fn parse_exec_section_arm(&mut self, section: &ExecHeader, image: &[u8]) {
+    fn parse_exec_section_arm(&mut self, section: &ExecHeader, image: &[u8]) -> Option<()> {
         let is_thumb2 = if self.kind == ElfKind::AArch32 {
             is_exec_section_thumb2(image, section)
         } else {
             false
         };
-        let gaps = self.abs32_gaps(section.offset, section.offset.wrapping_add(section.size));
+        let gaps = self.abs32_gaps(section.offset, section.offset.wrapping_add(section.size))?;
         for (gap_start, gap_end) in gaps {
             match self.kind {
                 ElfKind::AArch32 => {
@@ -481,14 +506,14 @@ impl ElfDisassembler {
                             let (found, size) =
                                 scan_thumb2(image, instr_rva, location, gap_end - cursor);
                             if let Some((addr_type, target_rva)) = found {
-                                self.record_arm_rel32(addr_type, target_rva, location);
+                                self.record_arm_rel32(addr_type, target_rva, location)?;
                             }
                             size
                         } else {
                             if let Some((addr_type, target_rva, _)) =
                                 scan_arm32(image, instr_rva, location)
                             {
-                                self.record_arm_rel32(addr_type, target_rva, location);
+                                self.record_arm_rel32(addr_type, target_rva, location)?;
                             }
                             4
                         };
@@ -510,8 +535,10 @@ impl ElfDisassembler {
                                     self.translator.rva_to_offset(target_rva)
                                 {
                                     if self.is_target_in_exec_section(target_offset) {
-                                        self.rel32_locations[addr_type as usize]
-                                            .push(location);
+                                        push_checked(
+                                            &mut self.rel32_locations[addr_type as usize],
+                                            location,
+                                        )?;
                                     }
                                 }
                             }
@@ -522,14 +549,16 @@ impl ElfDisassembler {
                 _ => unreachable!(),
             }
         }
+        Some(())
     }
 
-    fn record_arm_rel32(&mut self, addr_type: u8, target_rva: u32, location: u32) {
+    fn record_arm_rel32(&mut self, addr_type: u8, target_rva: u32, location: u32) -> Option<()> {
         if let Some(target_offset) = self.translator.rva_to_offset(target_rva) {
             if self.is_target_in_exec_section(target_offset) {
-                self.rel32_locations[addr_type as usize].push(location);
+                push_checked(&mut self.rel32_locations[addr_type as usize], location)?;
             }
         }
+        Some(())
     }
 
     fn is_target_in_exec_section(&self, offset: u32) -> bool {
@@ -543,9 +572,10 @@ impl ElfDisassembler {
 
     /// Mirrors `Abs32GapFinder`: non-empty gaps in `[region_start, region_end)`
     /// that do not overlap an abs32 body.
-    fn abs32_gaps(&self, region_start: u32, region_end: u32) -> Vec<(usize, usize)> {
+    fn abs32_gaps(&self, region_start: u32, region_end: u32) -> Option<Vec<(usize, usize)>> {
         let width = self.kind.va_width();
         let mut gaps = Vec::new();
+        gaps.try_reserve(self.abs32_locations.len().saturating_add(1)).ok()?;
         let mut current = self
             .abs32_locations
             .partition_point(|location| *location < region_start);
@@ -567,14 +597,19 @@ impl ElfDisassembler {
         if cur_lo < region_end {
             gaps.push((cur_lo as usize, region_end as usize));
         }
-        gaps
+        Some(gaps)
     }
 
-    fn read_relocs(&self, image: &[u8], lo: u32, hi: u32) -> Vec<Reference> {
+    fn read_relocs(&self, image: &[u8], lo: u32, hi: u32) -> Result<Vec<Reference>> {
         if self.reloc_sections.is_empty() {
-            return Vec::new();
+            return Ok(Vec::new());
         }
         let mut result = Vec::new();
+        // Upper bound: one reference per relocation entry in the range.
+        let upper = ((hi.saturating_sub(lo)) as usize) / 4 + 1;
+        result
+            .try_reserve(upper)
+            .map_err(|_| super::allocation_error("ELF relocation references"))?;
         let bitness = self.kind.bitness();
         let rel_type = self.kind.rel_type();
 
@@ -606,19 +641,19 @@ impl ElfDisassembler {
             {
                 current += 1;
                 if current == self.reloc_sections.len() {
-                    return result;
+                    return Ok(result);
                 }
                 cursor = self.reloc_sections[current].offset;
                 if cursor + self.reloc_sections[current].entry_size > hi {
-                    return result;
+                    return Ok(result);
                 }
             }
             if current >= self.reloc_sections.len() {
-                return result;
+                return Ok(result);
             }
             let entry_size = self.reloc_sections[current].entry_size;
             if cursor + entry_size > hi {
-                return result;
+                return Ok(result);
             }
 
             let (r_offset, r_info) = if bitness == 4 {
@@ -654,15 +689,14 @@ impl ElfDisassembler {
         }
     }
 
-    fn read_abs32(&self, image: &[u8], lo: u32, hi: u32) -> Vec<Reference> {
+    fn read_abs32(&self, image: &[u8], lo: u32, hi: u32) -> Result<Vec<Reference>> {
         let mut result = Vec::new();
-        for &location in &self.abs32_locations {
-            if location < lo {
-                continue;
-            }
-            if location >= hi {
-                break;
-            }
+        let start = self.abs32_locations.partition_point(|location| *location < lo);
+        let end = self.abs32_locations.partition_point(|location| *location < hi);
+        result
+            .try_reserve(end.saturating_sub(start))
+            .map_err(|_| super::allocation_error("ELF abs32 references"))?;
+        for &location in &self.abs32_locations[start..end] {
             let Some(value) = self.read_absolute(location, image) else { continue };
             if value >= u64::from(K_RVA_BOUND) {
                 continue;
@@ -671,18 +705,18 @@ impl ElfDisassembler {
                 result.push(Reference { location, target });
             }
         }
-        result
+        Ok(result)
     }
 
-    fn read_rel32_intel(&self, image: &[u8], lo: u32, hi: u32) -> Vec<Reference> {
+    fn read_rel32_intel(&self, image: &[u8], lo: u32, hi: u32) -> Result<Vec<Reference>> {
         let mut result = Vec::new();
-        for &location in &self.rel32_locations[0] {
-            if location < lo {
-                continue;
-            }
-            if location >= hi {
-                break;
-            }
+        let locations = &self.rel32_locations[0];
+        let start = locations.partition_point(|location| *location < lo);
+        let end = locations.partition_point(|location| *location < hi);
+        result
+            .try_reserve(end.saturating_sub(start))
+            .map_err(|_| super::allocation_error("ELF rel32 references"))?;
+        for &location in &locations[start..end] {
             let Some(location_rva) = self.translator.offset_to_rva(location) else { continue };
             let disp = read_i32(image, location as usize).unwrap_or(0);
             let target_rva = location_rva.wrapping_add(4).wrapping_add(disp as u32);
@@ -690,7 +724,7 @@ impl ElfDisassembler {
                 result.push(Reference { location, target });
             }
         }
-        result
+        Ok(result)
     }
 
     fn read_rel32_arm(
@@ -699,15 +733,15 @@ impl ElfDisassembler {
         addr_type: usize,
         lo: u32,
         hi: u32,
-    ) -> Vec<Reference> {
+    ) -> Result<Vec<Reference>> {
         let mut result = Vec::new();
-        for &location in &self.rel32_locations[addr_type] {
-            if location < lo {
-                continue;
-            }
-            if location >= hi {
-                break;
-            }
+        let locations = &self.rel32_locations[addr_type];
+        let start = locations.partition_point(|location| *location < lo);
+        let end = locations.partition_point(|location| *location < hi);
+        result
+            .try_reserve(end.saturating_sub(start))
+            .map_err(|_| super::allocation_error("ELF ARM rel32 references"))?;
+        for &location in &locations[start..end] {
             let Some(instr_rva) = self.translator.offset_to_rva(location) else { continue };
             let target_rva = if self.kind == ElfKind::AArch32 {
                 fetch_and_read_a32(image, addr_type, location, instr_rva)
@@ -720,7 +754,7 @@ impl ElfDisassembler {
                 }
             }
         }
-        result
+        Ok(result)
     }
 
     fn write_reloc(&self, image: &mut [u8], reference: Reference) {
@@ -771,12 +805,12 @@ impl Disassembler for ElfDisassembler {
 
     fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Result<Vec<Reference>> {
         if group == 0 {
-            return Ok(self.read_relocs(image, lo, hi));
+            return self.read_relocs(image, lo, hi);
         }
         if group == 1 {
-            return Ok(self.read_abs32(image, lo, hi));
+            return self.read_abs32(image, lo, hi);
         }
-        Ok(match self.kind {
+        match self.kind {
             ElfKind::X86 | ElfKind::X64 => self.read_rel32_intel(image, lo, hi),
             ElfKind::AArch32 | ElfKind::AArch64 => {
                 // Group index == address type index + 2 for ARM.
@@ -784,10 +818,10 @@ impl Disassembler for ElfDisassembler {
                 if addr_type < self.rel32_locations.len() {
                     self.read_rel32_arm(image, addr_type, lo, hi)
                 } else {
-                    Vec::new()
+                    Ok(Vec::new())
                 }
             }
-        })
+        }
     }
 
     fn write(&self, group: usize, image: &mut [u8], reference: Reference) {
diff --git a/src/zucchini_pure/engine.rs b/src/zucchini_pure/engine.rs
index d57c707..3fd4deb 100644
--- a/src/zucchini_pure/engine.rs
+++ b/src/zucchini_pure/engine.rs
@@ -161,6 +161,9 @@ fn validate_reference_boundaries(
     cancelled: &dyn Fn() -> bool,
 ) -> Result<bool> {
     let mut boundaries: Vec<u32> = Vec::new();
+    boundaries
+        .try_reserve(element.equivalences.len().saturating_mul(2))
+        .map_err(|_| super::allocation_error("Zucchini equivalence boundaries"))?;
     for equivalence in &element.equivalences {
         boundaries.push(equivalence.src_offset);
         boundaries.push(equivalence.src_end());
@@ -237,17 +240,17 @@ fn validate_dex_reference_targets(
         &element.equivalences,
         old_size,
         new_image.len() as u32,
-    );
+    )?;
 
     for (pool_tag, sub_groups) in &pools {
         check_not_cancelled(cancelled)?;
         let mut targets = TargetPool::default();
         for &group_index in sub_groups {
-            targets.insert_references(&old_disasm.read(group_index, old_image, 0, old_size)?);
+            targets.insert_references(&old_disasm.read(group_index, old_image, 0, old_size)?)?;
         }
-        targets.filter_and_project(&mapper);
+        targets.filter_and_project(&mapper)?;
         if let Some(extra) = element.extra_targets.get(pool_tag) {
-            targets.insert_targets(&extra.targets);
+            targets.insert_targets(&extra.targets)?;
             if !extra.done {
                 return Ok(false);
             }
@@ -434,7 +437,7 @@ fn apply_references_correction(
         &element.equivalences,
         old_image.len() as u32,
         new_image.len() as u32,
-    );
+    )?;
 
     let mut pools: BTreeMap<u8, Vec<usize>> = BTreeMap::new();
     for (index, group) in old_groups.iter().enumerate() {
@@ -447,12 +450,12 @@ fn apply_references_correction(
         let mut targets = TargetPool::default();
         for &group_index in sub_groups {
             let references = old_disasm.read(group_index, old_image, 0, old_image.len() as u32)?;
-            targets.insert_references(&references);
+            targets.insert_references(&references)?;
         }
-        targets.filter_and_project(&mapper);
+        targets.filter_and_project(&mapper)?;
 
         if let Some(extra) = element.extra_targets.get(pool_tag) {
-            targets.insert_targets(&extra.targets);
+            targets.insert_targets(&extra.targets)?;
             if !extra.done {
                 return Err(apply_error("found trailing extra targets"));
             }
@@ -509,10 +512,14 @@ struct OffsetMapper {
 }
 
 impl OffsetMapper {
-    fn new(source: &[Equivalence], old_image_size: u32, new_image_size: u32) -> Self {
-        let mut equivalences = source.to_vec();
+    fn new(source: &[Equivalence], old_image_size: u32, new_image_size: u32) -> Result<Self> {
+        let mut equivalences = Vec::new();
+        equivalences
+            .try_reserve_exact(source.len())
+            .map_err(|_| super::allocation_error("Zucchini equivalences"))?;
+        equivalences.extend_from_slice(source);
         PruneEquivalencesAndSortBySource::prune(&mut equivalences);
-        Self { equivalences, old_image_size, new_image_size }
+        Ok(Self { equivalences, old_image_size, new_image_size })
     }
 
     fn naive_extended_forward_project(&self, unit: &Equivalence, offset: u32) -> u32 {
@@ -627,19 +634,28 @@ impl TargetPool {
         self.targets.dedup();
     }
 
-    fn insert_references(&mut self, references: &[Reference]) {
+    fn insert_references(&mut self, references: &[Reference]) -> Result<()> {
+        self.targets
+            .try_reserve(references.len())
+            .map_err(|_| super::allocation_error("Zucchini target pool"))?;
         self.targets.extend(references.iter().map(|reference| reference.target));
         self.sort_and_uniquify();
+        Ok(())
     }
 
-    fn insert_targets(&mut self, targets: &[u32]) {
+    fn insert_targets(&mut self, targets: &[u32]) -> Result<()> {
+        self.targets
+            .try_reserve(targets.len())
+            .map_err(|_| super::allocation_error("Zucchini target pool"))?;
         self.targets.extend_from_slice(targets);
         self.sort_and_uniquify();
+        Ok(())
     }
 
-    fn filter_and_project(&mut self, mapper: &OffsetMapper) {
+    fn filter_and_project(&mut self, mapper: &OffsetMapper) -> Result<()> {
         mapper.forward_project_all(&mut self.targets);
         self.targets.sort_unstable();
+        Ok(())
     }
 
     /// Mirrors `KeyForNearestOffset`, including its lower-key tie-breaking.
diff --git a/src/zucchini_pure/mod.rs b/src/zucchini_pure/mod.rs
index 01a982a..1064efa 100644
--- a/src/zucchini_pure/mod.rs
+++ b/src/zucchini_pure/mod.rs
@@ -80,6 +80,11 @@ impl error::Error for Error {}
 
 pub type Result<T> = std::result::Result<T, Error>;
 
+/// Builds an `AllocationFailure` for a named attacker-influenced allocation.
+pub(crate) fn allocation_error(context: &str) -> Error {
+    Error::new(Status::AllocationFailure, format!("unable to allocate {context}"))
+}
+
 /// A parsed reference type within an executable element.
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct GroupTraits {
diff --git a/src/zucchini_pure/patch.rs b/src/zucchini_pure/patch.rs
index 178218e..831c3c8 100644
--- a/src/zucchini_pure/patch.rs
+++ b/src/zucchini_pure/patch.rs
@@ -211,11 +211,16 @@ fn parse_equivalences(
     src_skip: &[u8],
     dst_skip: &[u8],
     copy_count: &[u8],
-) -> (Vec<Equivalence>, bool) {
+) -> Result<(Vec<Equivalence>, bool)> {
     let mut src = Cursor::new(src_skip);
     let mut dst = Cursor::new(dst_skip);
     let mut count = Cursor::new(copy_count);
     let mut result = Vec::new();
+    // Each decoded equivalence consumes at least one byte from every stream.
+    let upper = src_skip.len().min(dst_skip.len()).min(copy_count.len());
+    result
+        .try_reserve(upper)
+        .map_err(|_| super::allocation_error("Zucchini equivalence stream"))?;
     let mut previous_src: u32 = 0;
     let mut previous_dst: u32 = 0;
     while !src.empty() && !dst.empty() && !count.empty() {
@@ -250,13 +255,17 @@ fn parse_equivalences(
         result.push(Equivalence { src_offset, dst_offset, length });
     }
     let done = src.empty() && dst.empty() && count.empty();
-    (result, done)
+    Ok((result, done))
 }
 
-fn parse_raw_deltas(skip: &[u8], diffs: &[u8]) -> (Vec<RawDeltaUnit>, bool) {
+fn parse_raw_deltas(skip: &[u8], diffs: &[u8]) -> Result<(Vec<RawDeltaUnit>, bool)> {
     let mut skip = Cursor::new(skip);
     let mut diffs = Cursor::new(diffs);
     let mut result = Vec::new();
+    let upper = skip.data.len().min(diffs.data.len());
+    result
+        .try_reserve(upper)
+        .map_err(|_| super::allocation_error("Zucchini raw delta stream"))?;
     let mut compensation: u32 = 0;
     while !skip.empty() && !diffs.empty() {
         let diff = match skip.var_u32() {
@@ -282,24 +291,30 @@ fn parse_raw_deltas(skip: &[u8], diffs: &[u8]) -> (Vec<RawDeltaUnit>, bool) {
         result.push(RawDeltaUnit { copy_offset, diff: byte_diff });
     }
     let done = skip.empty() && diffs.empty();
-    (result, done)
+    Ok((result, done))
 }
 
-fn parse_reference_deltas(source: &[u8]) -> (Vec<i32>, bool) {
+fn parse_reference_deltas(source: &[u8]) -> Result<(Vec<i32>, bool)> {
     let mut cursor = Cursor::new(source);
     let mut result = Vec::new();
+    result
+        .try_reserve(source.len())
+        .map_err(|_| super::allocation_error("Zucchini reference delta stream"))?;
     while !cursor.empty() {
         match cursor.var_i32() {
             Some(value) => result.push(value),
             None => break,
         }
     }
-    (result, cursor.empty())
+    Ok((result, cursor.empty()))
 }
 
-fn parse_extra_targets(source: &[u8]) -> ExtraTargets {
+fn parse_extra_targets(source: &[u8]) -> Result<ExtraTargets> {
     let mut cursor = Cursor::new(source);
     let mut targets = Vec::new();
+    targets
+        .try_reserve(source.len())
+        .map_err(|_| super::allocation_error("Zucchini extra target stream"))?;
     let mut compensation: u32 = 0;
     while !cursor.empty() {
         let diff = match cursor.var_u32() {
@@ -316,7 +331,7 @@ fn parse_extra_targets(source: &[u8]) -> ExtraTargets {
         };
         targets.push(target);
     }
-    ExtraTargets { targets, done: cursor.empty() }
+    Ok(ExtraTargets { targets, done: cursor.empty() })
 }
 
 impl PatchElement {
@@ -334,11 +349,15 @@ impl PatchElement {
             .buffer()
             .ok_or_else(|| invalid_patch("invalid equivalence source"))?;
         let (equivalences, equivalences_done) =
-            parse_equivalences(src_skip, dst_skip, copy_count);
-        let extra_data = cursor
+            parse_equivalences(src_skip, dst_skip, copy_count)?;
+        let extra_slice = cursor
             .buffer()
-            .ok_or_else(|| invalid_patch("invalid extra data"))?
-            .to_vec();
+            .ok_or_else(|| invalid_patch("invalid extra data"))?;
+        let mut extra_data = Vec::new();
+        extra_data
+            .try_reserve_exact(extra_slice.len())
+            .map_err(|_| super::allocation_error("Zucchini extra data"))?;
+        extra_data.extend_from_slice(extra_slice);
 
         // Mirrors ValidateEquivalencesAndExtraData().
         let old_region_size = u64::from(element_match.old_size);
@@ -375,17 +394,21 @@ impl PatchElement {
         let raw_diff = cursor
             .buffer()
             .ok_or_else(|| invalid_patch("invalid raw delta source"))?;
-        let (raw_deltas, raw_deltas_done) = parse_raw_deltas(raw_skip, raw_diff);
+        let (raw_deltas, raw_deltas_done) = parse_raw_deltas(raw_skip, raw_diff)?;
 
         let reference_source = cursor
             .buffer()
             .ok_or_else(|| invalid_patch("invalid reference delta source"))?;
         let (reference_deltas, reference_deltas_done) =
-            parse_reference_deltas(reference_source);
+            parse_reference_deltas(reference_source)?;
 
         let pool_count = cursor
             .u32()
             .ok_or_else(|| invalid_patch("invalid extra target list"))?;
+        // Each pool costs at least a tag byte plus a 4-byte length prefix.
+        if pool_count as usize > cursor.remaining() / 5 {
+            return Err(invalid_patch("invalid extra target list"));
+        }
         let mut extra_targets = BTreeMap::new();
         for _ in 0..pool_count {
             let pool_tag = cursor
@@ -397,7 +420,7 @@ impl PatchElement {
             let source = cursor
                 .buffer()
                 .ok_or_else(|| invalid_patch("invalid extra target list"))?;
-            if extra_targets.insert(pool_tag, parse_extra_targets(source)).is_some() {
+            if extra_targets.insert(pool_tag, parse_extra_targets(source)?).is_some() {
                 return Err(invalid_patch("duplicate pool tag"));
             }
         }
@@ -435,6 +458,12 @@ impl Patch {
             .u32()
             .ok_or_else(|| invalid_patch("invalid ensemble patch"))?;
         let mut elements = Vec::new();
+        // Each element header is 22 bytes, so this bounds the reservation even
+        // if `element_count` is absurd.
+        let upper = (data.len() / 22).min(element_count as usize);
+        elements
+            .try_reserve(upper)
+            .map_err(|_| super::allocation_error("Zucchini patch elements"))?;
         let mut current_dst_offset: u32 = 0;
         for _ in 0..element_count {
             let element = PatchElement::parse(&mut cursor)?;
diff --git a/tests/zucchini_pure.rs b/tests/zucchini_pure.rs
index 54bd877..809f816 100644
--- a/tests/zucchini_pure.rs
+++ b/tests/zucchini_pure.rs
@@ -277,3 +277,24 @@ fn pure_rust_rejects_absurd_declared_stream_length() {
     let error = zucchini_pure::apply(old, &patch, new.len()).unwrap_err();
     assert_eq!(error.status(), Status::InvalidPatch);
 }
+
+#[test]
+fn pure_rust_rejects_absurd_pool_count() {
+    let old = b"ABCD";
+    let new = b"ABCDE";
+    let mut patch = build_noop_patch(old, new, &[]);
+    let len = patch.len();
+    patch[len - 4..].copy_from_slice(&u32::MAX.to_le_bytes());
+    let error = zucchini_pure::apply(old, &patch, new.len()).unwrap_err();
+    assert_eq!(error.status(), Status::InvalidPatch);
+}
+
+#[test]
+fn pure_rust_rejects_absurd_element_count() {
+    let old = b"ABCD";
+    let new = b"ABCDE";
+    let mut patch = build_noop_patch(old, new, &[]);
+    patch[24..28].copy_from_slice(&u32::MAX.to_le_bytes());
+    let error = zucchini_pure::apply(old, &patch, new.len()).unwrap_err();
+    assert_eq!(error.status(), Status::InvalidPatch);
+}

From 5d4f66f0ca2210742ca183a44089c5dee56fb136 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 18:19:58 +0530
Subject: [PATCH 30/42] zucchini: cache DEX instructions and per-group
 references

- decode each DEX code item's instructions once at parse time into a flat,
  location-sorted list; all 42 groups filter it instead of re-decoding
- analyze_element materialises each reference group once and shares it
  between preflight and apply via GroupRefCache, removing repeated
  groups x equivalences x items scans
- add group_ref_cache_matches_ranged_reads equivalence test
- document measured before/after (~30% on dex, ~6% on dex-large)
---
 docs/zucchini-rust-port.md  |  49 +++++++--
 src/zucchini_pure/dex.rs    |  77 ++++++++++----
 src/zucchini_pure/engine.rs | 194 +++++++++++++++++++++++++-----------
 src/zucchini_pure/mod.rs    |  23 +++--
 4 files changed, 242 insertions(+), 101 deletions(-)

diff --git a/docs/zucchini-rust-port.md b/docs/zucchini-rust-port.md
index 10e5c6c..b58557a 100644
--- a/docs/zucchini-rust-port.md
+++ b/docs/zucchini-rust-port.md
@@ -88,9 +88,41 @@ cargo clippy --all-targets --all-features -- -D warnings
 ## Cancellation and allocation
 
 `apply()` keeps its signature. `apply_with_cancel(old, patch, size, cancelled)`
-polls a `Fn() -> bool` between elements, pools, and equivalence units and returns
-`Status::Cancelled`. `src/zucchini.rs` exposes the same hook. Parser allocations
-derived from attacker-controlled counts use `try_reserve`.
+polls a `Fn() -> bool` and returns `Status::Cancelled`. Poll sites cover the
+old/new CRC chunk loops, element boundaries, raw-delta application, reference
+correction (per reference), and both preflight validators (per group and per
+equivalence). `src/zucchini.rs` exposes the same hook, and
+`run_op_zucchini` passes the extraction token and converts a cancelled apply
+back into the typed `ExtractionCancelled` error so the extraction layer unwinds
+cleanly. Cancellation is never folded into the preflight `ApplyError`.
+
+Every vector derived from attacker-controlled counts reserves with
+`try_reserve` (fallible) and surfaces `Status::AllocationFailure`; the patch
+parser also bounds `element_count` and `pool_count` by the remaining patch
+bytes before allocating. `Disassembler::read` is fallible end to end.
+
+## Performance
+
+DEX instructions are decoded once at parse time into a flat, location-sorted
+list. `analyze_element` then materialises each reference group once, and both
+preflight and apply binary-search that snapshot (`GroupRefCache`) instead of
+re-running `groups × equivalences × items` scans; preflight and apply share the
+same analysis for an element.
+
+Measured with a standalone harness on this machine (`-C opt-level=3`), five
+runs each, comparing the commit before the cache with the current tree:
+
+| Fixture | Before | After |
+| --- | --- | --- |
+| `dex` | ~0.013 ms/iter | ~0.009 ms/iter |
+| `dex-large` | ~6.4 ms/iter | ~6.0 ms/iter |
+| `elf` | ~0.019 ms/iter | ~0.018 ms/iter |
+
+The large DEX fixture has a single equivalence and is dominated by its 65k
+item-list walks, so the structural scan reduction mostly shows on the small
+fixture; many-equivalence partitions benefit more. `group_ref_cache_matches_ranged_reads`
+asserts the cached snapshot is byte-identical to fresh ranged reads for every
+group and range on the ELF/DEX fixtures.
 
 ## Intentional behavioural and size deltas
 
@@ -110,16 +142,11 @@ derived from attacker-controlled counts use `try_reserve`.
 
 ## Remaining work
 
-1. **Performance parity.** The C++ readers are lazy state machines; the Rust
-   `read` recomputes each group's references per range query, so DEX apply is
-   `O(groups × equivalences × items)`. Correct but slower on real partitions.
-   Cache each group's full reference list once per parsed image before
-   production cutover.
-2. **Differential testing.** Building the native path
-   (`OTADUMP_NATIVE_ZUCCHINI=1 cargo test`) enables
+1. **Differential testing.** Building the native path
+   (`OTADUMP_NATIVE_ZUCCHINI=1 cargo test`, exact value `1` required) enables
    `native_and_pure_agree_on_all_fixtures`. That build currently fails to link in
    this environment on pre-existing libchrome symbols
    (`base::Histogram::FactoryGet` from `activity_tracker.cc`), unrelated to the
    Rust port; the default, pure build is unaffected.
-3. **Non-Android formats (Win32, ZTF).** Not emitted by Android payloads and
+2. **Non-Android formats (Win32, ZTF).** Not emitted by Android payloads and
    intentionally rejected.
diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
index 8616fae..a167967 100644
--- a/src/zucchini_pure/dex.rs
+++ b/src/zucchini_pure/dex.rs
@@ -147,6 +147,8 @@ pub struct DexDisassembler {
     call_site_map: MapItem,
     method_handle_map: MapItem,
     code_item_offsets: Vec<u32>,
+    code_item_instruction_start: Vec<usize>,
+    instructions: Vec<InstructionValue>,
     type_list_offsets: Vec<u32>,
     annotation_set_ref_list_offsets: Vec<u32>,
     annotation_set_offsets: Vec<u32>,
@@ -237,6 +239,19 @@ impl DexDisassembler {
             return None;
         }
 
+        // Parse every code item's instruction stream once. All 42 reference
+        // groups then filter this flat, location-sorted list instead of
+        // re-decoding instructions for every group and equivalence range.
+        let mut code_item_instruction_start = Vec::new();
+        code_item_instruction_start.try_reserve_exact(code_item_offsets.len()).ok()?;
+        let mut instructions = Vec::new();
+        for &offset in &code_item_offsets {
+            code_item_instruction_start.push(instructions.len());
+            let parsed = parse_instructions(image, offset).ok()?;
+            instructions.try_reserve(parsed.len()).ok()?;
+            instructions.extend_from_slice(&parsed);
+        }
+
         Some(DexDisassembler {
             size: file_size,
             groups: build_groups(),
@@ -249,6 +264,8 @@ impl DexDisassembler {
             call_site_map: get(T_CALL_SITE_ID),
             method_handle_map: get(T_METHOD_HANDLE),
             code_item_offsets,
+            code_item_instruction_start,
+            instructions,
             type_list_offsets,
             annotation_set_ref_list_offsets,
             annotation_set_offsets,
@@ -760,7 +777,7 @@ fn cached_item_list_reader(
     Ok(result)
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 struct InstructionValue {
     instr_offset: u32,
     opcode: u8,
@@ -890,6 +907,8 @@ fn instruction_reader(
     lo: u32,
     hi: u32,
     code_item_offsets: &[u32],
+    code_item_instruction_start: &[usize],
+    instructions: &[InstructionValue],
     filter: CodeFilter,
     mapper: InstrMapper,
 ) -> Result<Vec<Reference>> {
@@ -900,32 +919,28 @@ fn instruction_reader(
     if index != 0 {
         index -= 1;
     }
+    let start = code_item_instruction_start[index];
     let mut result = Vec::new();
     result
         .try_reserve((hi.saturating_sub(lo) / 2) as usize)
         .map_err(|_| super::allocation_error("DEX code references"))?;
-    loop {
-        for value in parse_instructions(image, code_item_offsets[index])? {
-            if value.instr_offset >= hi {
-                return Ok(result);
-            }
-            let Some(location) = filter_location(filter, value) else { continue };
-            if location == K_INVALID_OFFSET || location < lo {
-                continue;
-            }
-            if location >= hi {
-                return Ok(result);
-            }
-            let target = run_instr_mapper(mapper, image, location);
-            if target != K_INVALID_OFFSET {
-                result.push(Reference { location, target });
-            }
+    for value in &instructions[start..] {
+        if value.instr_offset >= hi {
+            break;
         }
-        index += 1;
-        if index >= code_item_offsets.len() {
-            return Ok(result);
+        let Some(location) = filter_location(filter, *value) else { continue };
+        if location == K_INVALID_OFFSET || location < lo {
+            continue;
+        }
+        if location >= hi {
+            break;
+        }
+        let target = run_instr_mapper(mapper, image, location);
+        if target != K_INVALID_OFFSET {
+            result.push(Reference { location, target });
         }
     }
+    Ok(result)
 }
 
 // Writers.
@@ -1027,6 +1042,8 @@ impl Disassembler for DexDisassembler {
                 lo,
                 hi,
                 &self.code_item_offsets,
+                &self.code_item_instruction_start,
+                &self.instructions,
                 CodeFilter::String16,
                 InstrMapper::TargetIndex { map: self.string_map, item_size: 4, width },
             ),
@@ -1035,6 +1052,8 @@ impl Disassembler for DexDisassembler {
                 lo,
                 hi,
                 &self.code_item_offsets,
+                &self.code_item_instruction_start,
+                &self.instructions,
                 CodeFilter::String32,
                 InstrMapper::TargetIndex { map: self.string_map, item_size: 4, width },
             ),
@@ -1057,6 +1076,8 @@ impl Disassembler for DexDisassembler {
                 lo,
                 hi,
                 &self.code_item_offsets,
+                &self.code_item_instruction_start,
+                &self.instructions,
                 CodeFilter::Type,
                 InstrMapper::TargetIndex { map: self.type_map, item_size: 4, width },
             ),
@@ -1065,6 +1086,8 @@ impl Disassembler for DexDisassembler {
                 lo,
                 hi,
                 &self.code_item_offsets,
+                &self.code_item_instruction_start,
+                &self.instructions,
                 CodeFilter::Proto,
                 InstrMapper::TargetIndex { map: self.proto_map, item_size: 12, width },
             ),
@@ -1074,6 +1097,8 @@ impl Disassembler for DexDisassembler {
                 lo,
                 hi,
                 &self.code_item_offsets,
+                &self.code_item_instruction_start,
+                &self.instructions,
                 CodeFilter::Field,
                 InstrMapper::TargetIndex { map: self.field_map, item_size: 8, width },
             ),
@@ -1105,6 +1130,8 @@ impl Disassembler for DexDisassembler {
                 lo,
                 hi,
                 &self.code_item_offsets,
+                &self.code_item_instruction_start,
+                &self.instructions,
                 CodeFilter::Method,
                 InstrMapper::TargetIndex { map: self.method_map, item_size: 8, width },
             ),
@@ -1144,6 +1171,8 @@ impl Disassembler for DexDisassembler {
                 lo,
                 hi,
                 &self.code_item_offsets,
+                &self.code_item_instruction_start,
+                &self.instructions,
                 CodeFilter::CallSite,
                 InstrMapper::TargetIndex { map: self.call_site_map, item_size: 4, width },
             ),
@@ -1152,6 +1181,8 @@ impl Disassembler for DexDisassembler {
                 lo,
                 hi,
                 &self.code_item_offsets,
+                &self.code_item_instruction_start,
+                &self.instructions,
                 CodeFilter::MethodHandle,
                 InstrMapper::TargetIndex { map: self.method_handle_map, item_size: 8, width },
             ),
@@ -1221,6 +1252,8 @@ impl Disassembler for DexDisassembler {
                 lo,
                 hi,
                 &self.code_item_offsets,
+                &self.code_item_instruction_start,
+                &self.instructions,
                 CodeFilter::Rel8,
                 InstrMapper::RelCode8,
             ),
@@ -1229,6 +1262,8 @@ impl Disassembler for DexDisassembler {
                 lo,
                 hi,
                 &self.code_item_offsets,
+                &self.code_item_instruction_start,
+                &self.instructions,
                 CodeFilter::Rel16,
                 InstrMapper::RelCode16,
             ),
@@ -1237,6 +1272,8 @@ impl Disassembler for DexDisassembler {
                 lo,
                 hi,
                 &self.code_item_offsets,
+                &self.code_item_instruction_start,
+                &self.instructions,
                 CodeFilter::Rel32,
                 InstrMapper::RelCode32,
             ),
diff --git a/src/zucchini_pure/engine.rs b/src/zucchini_pure/engine.rs
index 3fd4deb..e8ee031 100644
--- a/src/zucchini_pure/engine.rs
+++ b/src/zucchini_pure/engine.rs
@@ -52,13 +52,58 @@ fn check_not_cancelled(cancelled: &dyn Fn() -> bool) -> Result<()> {
     }
 }
 
-pub(crate) fn apply_element(
-    old: &[u8],
+/// Old-image analysis shared by preflight and apply for one element.
+pub(crate) struct ElementAnalysis {
+    disasm: Box<dyn Disassembler>,
+    refs: GroupRefCache,
+}
+
+/// Per-group references for one parsed image, computed once. Ranged queries
+/// binary-search the location-sorted list instead of re-scanning the
+/// disassembler for every equivalence.
+struct GroupRefCache {
+    refs: Vec<Vec<Reference>>,
+}
+
+impl GroupRefCache {
+    fn build(disasm: &dyn Disassembler, image: &[u8]) -> Result<Self> {
+        let groups = disasm.groups();
+        let size = disasm.size();
+        let mut refs = Vec::new();
+        refs.try_reserve_exact(groups.len())
+            .map_err(|_| super::allocation_error("Zucchini reference groups"))?;
+        for group in 0..groups.len() {
+            refs.push(disasm.read(group, image, 0, size)?);
+        }
+        Ok(Self { refs })
+    }
+
+    fn full(&self, group: usize) -> &[Reference] {
+        &self.refs[group]
+    }
+
+    fn range(&self, group: usize, lo: u32, hi: u32) -> &[Reference] {
+        let refs = &self.refs[group];
+        let start = refs.partition_point(|reference| reference.location < lo);
+        let end = refs.partition_point(|reference| reference.location < hi);
+        &refs[start..end]
+    }
+}
+
+/// Parses the old element and caches its per-group references once.
+pub(crate) fn analyze_element(exe_type: u32, old_element: &[u8]) -> Result<ElementAnalysis> {
+    let disasm = make_disassembler(exe_type, old_element)
+        .ok_or_else(|| apply_error("failed to create old disassembler"))?;
+    let refs = GroupRefCache::build(&*disasm, old_element)?;
+    Ok(ElementAnalysis { disasm, refs })
+}
+
+/// Splits the element's old and new regions out of the images.
+pub(crate) fn element_regions<'a>(
+    old: &'a [u8],
     element: &PatchElement,
-    output: &mut [u8],
-    cancelled: &dyn Fn() -> bool,
-) -> Result<()> {
-    check_not_cancelled(cancelled)?;
+    output: &'a mut [u8],
+) -> Result<(&'a [u8], &'a mut [u8])> {
     let matching = &element.element_match;
     let old_end = (matching.old_offset as usize)
         .checked_add(matching.old_size as usize)
@@ -72,10 +117,28 @@ pub(crate) fn apply_element(
     let new_element = output
         .get_mut(matching.new_offset as usize..new_end)
         .ok_or_else(|| apply_error("new element out of bounds"))?;
+    Ok((old_element, new_element))
+}
 
+pub(crate) fn apply_element(
+    element: &PatchElement,
+    old_element: &[u8],
+    new_element: &mut [u8],
+    analysis: &ElementAnalysis,
+    cancelled: &dyn Fn() -> bool,
+) -> Result<()> {
+    check_not_cancelled(cancelled)?;
     apply_equivalence_and_extra_data(old_element, element, new_element, cancelled)?;
     apply_raw_delta(element, new_element, cancelled)?;
-    apply_references_correction(matching.exe_type, old_element, element, new_element, cancelled)?;
+    apply_references_correction(
+        element.element_match.exe_type,
+        old_element,
+        element,
+        new_element,
+        &*analysis.disasm,
+        &analysis.refs,
+        cancelled,
+    )?;
     Ok(())
 }
 
@@ -83,9 +146,10 @@ pub(crate) fn apply_element(
 /// equivalence/extra/raw data to a scratch output, then run the Android
 /// boundary and DEX-target validations that upstream Zucchini does not.
 pub(crate) fn preflight_element(
-    old: &[u8],
     element: &PatchElement,
-    output: &mut [u8],
+    old_element: &[u8],
+    new_element: &mut [u8],
+    analysis: &ElementAnalysis,
     cancelled: &dyn Fn() -> bool,
 ) -> Result<()> {
     let exe_type = element.element_match.exe_type;
@@ -94,25 +158,10 @@ pub(crate) fn preflight_element(
     }
     check_not_cancelled(cancelled)?;
 
-    let matching = &element.element_match;
-    let old_end = (matching.old_offset as usize)
-        .checked_add(matching.old_size as usize)
-        .ok_or_else(|| apply_error("old element range overflow"))?;
-    let new_end = (matching.new_offset as usize)
-        .checked_add(matching.new_size as usize)
-        .ok_or_else(|| apply_error("new element range overflow"))?;
-    let old_element = old
-        .get(matching.old_offset as usize..old_end)
-        .ok_or_else(|| apply_error("old element out of bounds"))?;
-    let new_element = output
-        .get_mut(matching.new_offset as usize..new_end)
-        .ok_or_else(|| apply_error("new element out of bounds"))?;
-
     apply_equivalence_and_extra_data(old_element, element, new_element, cancelled)?;
     apply_raw_delta(element, new_element, cancelled)?;
 
-    let old_disasm = make_disassembler(exe_type, old_element)
-        .ok_or_else(|| apply_error("failed to create old disassembler"))?;
+    let old_disasm = &*analysis.disasm;
     let new_disasm = make_disassembler(exe_type, new_element)
         .ok_or_else(|| apply_error("failed to create new disassembler"))?;
     if old_disasm.size() != old_element.len() as u32
@@ -122,10 +171,10 @@ pub(crate) fn preflight_element(
     }
     let new_size = new_element.len() as u32;
     if !validate_reference_boundaries(
-        &*old_disasm,
+        old_disasm,
+        &analysis.refs,
         exe_type,
         element,
-        old_element,
         new_size,
         cancelled,
     )? {
@@ -136,10 +185,10 @@ pub(crate) fn preflight_element(
             return Err(apply_error("dex writer width violation"));
         }
         if !validate_dex_reference_targets(
-            &*old_disasm,
+            old_disasm,
             &*new_disasm,
+            &analysis.refs,
             element,
-            old_element,
             new_element,
             cancelled,
         )? {
@@ -154,9 +203,9 @@ pub(crate) fn preflight_element(
 /// if the caller cancels.
 fn validate_reference_boundaries(
     old_disasm: &dyn Disassembler,
+    cache: &GroupRefCache,
     exe_type: u32,
     element: &PatchElement,
-    old_image: &[u8],
     new_size: u32,
     cancelled: &dyn Fn() -> bool,
 ) -> Result<bool> {
@@ -170,7 +219,6 @@ fn validate_reference_boundaries(
     }
     boundaries.sort_unstable();
 
-    let old_size = old_image.len() as u32;
     for (group_index, group) in old_disasm.groups().iter().enumerate() {
         check_not_cancelled(cancelled)?;
         let mut writer_width = group.width;
@@ -182,7 +230,7 @@ fn validate_reference_boundaries(
             }
         }
 
-        for reference in old_disasm.read(group_index, old_image, 0, old_size)? {
+        for reference in cache.full(group_index) {
             let boundary = boundaries.partition_point(|value| *value <= reference.location);
             if boundary < boundaries.len()
                 && boundaries[boundary] < reference.location.wrapping_add(group.width)
@@ -193,12 +241,8 @@ fn validate_reference_boundaries(
 
         for equivalence in &element.equivalences {
             check_not_cancelled(cancelled)?;
-            for reference in old_disasm.read(
-                group_index,
-                old_image,
-                equivalence.src_offset,
-                equivalence.src_end(),
-            )? {
+            for reference in cache.range(group_index, equivalence.src_offset, equivalence.src_end())
+            {
                 if reference.location < equivalence.src_offset
                     || reference.location > equivalence.src_end()
                     || group.width > equivalence.src_end() - reference.location
@@ -222,8 +266,8 @@ fn validate_reference_boundaries(
 fn validate_dex_reference_targets(
     old_disasm: &dyn Disassembler,
     new_disasm: &dyn Disassembler,
+    cache: &GroupRefCache,
     element: &PatchElement,
-    old_image: &[u8],
     new_image: &[u8],
     cancelled: &dyn Fn() -> bool,
 ) -> Result<bool> {
@@ -235,10 +279,9 @@ fn validate_dex_reference_targets(
     }
 
     let mut deltas = element.reference_deltas.iter();
-    let old_size = old_image.len() as u32;
     let mapper = OffsetMapper::new(
         &element.equivalences,
-        old_size,
+        old_disasm.size(),
         new_image.len() as u32,
     )?;
 
@@ -246,7 +289,7 @@ fn validate_dex_reference_targets(
         check_not_cancelled(cancelled)?;
         let mut targets = TargetPool::default();
         for &group_index in sub_groups {
-            targets.insert_references(&old_disasm.read(group_index, old_image, 0, old_size)?)?;
+            targets.insert_references(cache.full(group_index))?;
         }
         targets.filter_and_project(&mapper)?;
         if let Some(extra) = element.extra_targets.get(pool_tag) {
@@ -263,12 +306,9 @@ fn validate_dex_reference_targets(
             }
             for equivalence in &element.equivalences {
                 check_not_cancelled(cancelled)?;
-                for reference in old_disasm.read(
-                    group_index,
-                    old_image,
-                    equivalence.src_offset,
-                    equivalence.src_end(),
-                )? {
+                for reference in
+                    cache.range(group_index, equivalence.src_offset, equivalence.src_end())
+                {
                     let projected = mapper.extended_forward_project(reference.target);
                     let expected = targets.key_for_nearest_offset(projected);
                     let Some(delta) = deltas.next() else { return Ok(false) };
@@ -420,11 +460,11 @@ fn apply_references_correction(
     old_image: &[u8],
     element: &PatchElement,
     new_image: &mut [u8],
+    old_disasm: &dyn Disassembler,
+    cache: &GroupRefCache,
     cancelled: &dyn Fn() -> bool,
 ) -> Result<()> {
     check_not_cancelled(cancelled)?;
-    let old_disasm = make_disassembler(exe_type, old_image)
-        .ok_or_else(|| apply_error("failed to create old disassembler"))?;
     let new_disasm = make_disassembler(exe_type, new_image)
         .ok_or_else(|| apply_error("failed to create new disassembler"))?;
     if old_disasm.size() != old_image.len() as u32 || new_disasm.size() != new_image.len() as u32 {
@@ -449,8 +489,7 @@ fn apply_references_correction(
         check_not_cancelled(cancelled)?;
         let mut targets = TargetPool::default();
         for &group_index in sub_groups {
-            let references = old_disasm.read(group_index, old_image, 0, old_image.len() as u32)?;
-            targets.insert_references(&references)?;
+            targets.insert_references(cache.full(group_index))?;
         }
         targets.filter_and_project(&mapper)?;
 
@@ -468,14 +507,11 @@ fn apply_references_correction(
             }
             for equivalence in &element.equivalences {
                 check_not_cancelled(cancelled)?;
-                let references = old_disasm.read(
-                    group_index,
-                    old_image,
-                    equivalence.src_offset,
-                    equivalence.src_end(),
-                )?;
-                for mut reference in references {
+                for &reference in
+                    cache.range(group_index, equivalence.src_offset, equivalence.src_end())
+                {
                     check_not_cancelled(cancelled)?;
+                    let mut reference = reference;
                     let projected = mapper.extended_forward_project(reference.target);
                     let expected_key = targets.key_for_nearest_offset(projected);
                     let delta = deltas
@@ -686,3 +722,43 @@ fn _range_helpers() {
     let _ = range_covers;
     let _ = range_is_bounded;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    /// The cached per-group references must equal what a fresh ranged read
+    /// returns for every group and range.
+    #[test]
+    fn group_ref_cache_matches_ranged_reads() {
+        let fixtures = "tests/fixtures/zucchini";
+        for (name, exe_type) in [
+            ("elf-old", EXE_TYPE_ELF_X64),
+            ("elf-arm32-old", EXE_TYPE_ELF_AARCH32),
+            ("elf-arm64-old", EXE_TYPE_ELF_AARCH64),
+            ("dex-old.dex", EXE_TYPE_DEX),
+            ("dex-large-old.dex", EXE_TYPE_DEX),
+        ] {
+            let Ok(image) = fs::read(format!("{fixtures}/{name}")) else { continue };
+            let disasm = make_disassembler(exe_type, &image).unwrap();
+            let cache = GroupRefCache::build(&*disasm, &image).unwrap();
+            let size = disasm.size();
+            let ranges =
+                [(0, size), (0, size / 3), (size / 3, size * 2 / 3), (size * 2 / 3, size)];
+            for group in 0..disasm.groups().len() {
+                for &(lo, hi) in &ranges {
+                    if lo > hi || hi > size {
+                        continue;
+                    }
+                    let expected = disasm.read(group, &image, lo, hi).unwrap();
+                    assert_eq!(
+                        cache.range(group, lo, hi),
+                        expected.as_slice(),
+                        "{name} group {group} range {lo}..{hi}"
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/src/zucchini_pure/mod.rs b/src/zucchini_pure/mod.rs
index 1064efa..20103b2 100644
--- a/src/zucchini_pure/mod.rs
+++ b/src/zucchini_pure/mod.rs
@@ -185,19 +185,20 @@ fn apply_inner(
     }
     for element in &patch.elements {
         check()?;
-        engine::preflight_element(old, element, &mut output, cancelled).map_err(|error| {
-            // Preserve cooperative cancellation; everything else is a
-            // preflight validation failure.
-            match error.status() {
+        let exe_type = element.element_match.exe_type;
+        // Parse and cache the old element's per-group references once, then
+        // share them between preflight and apply (the native FFI re-reads them
+        // for every equivalence in both phases).
+        let (old_element, new_element) = engine::element_regions(old, element, &mut output)?;
+        let analysis = engine::analyze_element(exe_type, old_element)?;
+        engine::preflight_element(element, old_element, new_element, &analysis, cancelled).map_err(
+            |error| match error.status() {
                 Status::Cancelled => error,
                 _ => Error::new(Status::ApplyError, "android executable preflight failed"),
-            }
-        })?;
-    }
-
-    for element in &patch.elements {
-        check()?;
-        engine::apply_element(old, element, &mut output, cancelled)?;
+            },
+        )?;
+        let (old_element, new_element) = engine::element_regions(old, element, &mut output)?;
+        engine::apply_element(element, old_element, new_element, &analysis, cancelled)?;
     }
 
     if !patch::check_new_file_cancel(&patch.header, &output, cancelled)? {

From 83e0d3c7b5910b56cac0ccdc0e7e206ed24db0e4 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 18:21:58 +0530
Subject: [PATCH 31/42] zucchini: test public cancellation mapping

Add unit tests for zucchini::apply_with_cancel preserving Status::Cancelled
and for the non-cancelled malformed-patch path.
---
 src/zucchini.rs | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/src/zucchini.rs b/src/zucchini.rs
index f639b06..4a28b58 100644
--- a/src/zucchini.rs
+++ b/src/zucchini.rs
@@ -156,3 +156,20 @@ fn native_status(status: i32) -> Status {
         status => Status::Unknown(status),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn apply_with_cancel_reports_cancelled() {
+        let error = apply_with_cancel(b"abcd", b"not a patch", 5, || true).unwrap_err();
+        assert_eq!(error.status(), Status::Cancelled);
+    }
+
+    #[test]
+    fn apply_reports_invalid_patch_when_not_cancelled() {
+        let error = apply_with_cancel(b"abcd", b"not a patch", 5, || false).unwrap_err();
+        assert_eq!(error.status(), Status::InvalidPatch);
+    }
+}

From 496a8214f06d2394ecaedbd8ff23322ac62901fc Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 18:33:16 +0530
Subject: [PATCH 32/42] zucchini: match native DEX opcode families and pruning
 order

Rebased onto the GroupRefCache work. Two divergences from the C++
reference broke real, generator-produced patches (collection-jvm,
kotlin-stdlib, material-icons DEX and x86-64 ELF); the committed
fixtures did not exercise either.

1. DEX instruction filters compared the raw opcode byte. Native
   dex::Instruction::opcode is the canonical range-start opcode, so a
   family entry like {0x52, 2, c, 14} matches every iget/iput opcode
   0x52..=0x5F. The port under-emitted groups 17 (CodeToFieldId), 20
   (CodeToMethodId) and 35 (CodeToRelCode16). find_instruction now
   carries the start opcode and parse_instructions stores it; the
   GroupRefCache therefore caches the full stream too.

2. PruneEquivalencesAndSortBySource calls std::sort, which is not
   stable; equivalences sharing a src_offset are reordered by
   libstdc++ introsort, and the resulting order determines which
   equivalence a projection picks. A stable Rust sort produced different
   target pools, so validate_dex_reference_targets rejected valid
   patches and ELF reference deltas misaligned. Port libstdc++ std::sort
   exactly (introsort + final insertion sort, with the __partial_sort
   heap fallback).

Verified byte-exact against the C++ FFI, and reference streams are
identical, for collection-jvm (6,757 equivalences), kotlin-stdlib
(16,793), material-icons (138,880) and x86-64 ELF (1,930). Adds a
compact real-world differential fixture (annotation-jvm 1.8.1 ->
1.10.0, 161 equivalences) that requires both fixes, plus unit tests for
the opcode families and the native sort permutation. Full cargo test
(25+37+13) and cargo clippy --all-targets --all-features -- -D warnings
pass.
---
 src/zucchini_pure/dex.rs                      |  36 ++-
 src/zucchini_pure/engine.rs                   | 229 +++++++++++++++++-
 tests/fixtures/zucchini/README.md             |  21 ++
 tests/fixtures/zucchini/SHA256SUMS            |   3 +
 .../fixtures/zucchini/annotation-jvm-new.dex  | Bin 0 -> 29516 bytes
 .../fixtures/zucchini/annotation-jvm-old.dex  | Bin 0 -> 28568 bytes
 tests/fixtures/zucchini/annotation-jvm.zuc    | Bin 0 -> 8286 bytes
 tests/zucchini_pure.rs                        |   8 +
 8 files changed, 293 insertions(+), 4 deletions(-)
 create mode 100644 tests/fixtures/zucchini/annotation-jvm-new.dex
 create mode 100644 tests/fixtures/zucchini/annotation-jvm-old.dex
 create mode 100644 tests/fixtures/zucchini/annotation-jvm.zuc

diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
index a167967..140b133 100644
--- a/src/zucchini_pure/dex.rs
+++ b/src/zucchini_pure/dex.rs
@@ -49,6 +49,8 @@ enum Format {
 
 #[derive(Clone, Copy, Debug)]
 struct Bytecode {
+    /// Canonical range-start opcode, mirroring `dex::Instruction::opcode`.
+    opcode: u8,
     layout: u8,
     format: Format,
 }
@@ -131,7 +133,7 @@ fn find_instruction(opcode: u8) -> Option<Bytecode> {
         .find(|(start, _, _, variant)| {
             opcode >= u16::from(*start) && opcode < u16::from(*start) + u16::from(*variant)
         })
-        .map(|(_, layout, format, _)| Bytecode { layout: *layout, format: *format })
+        .map(|(start, layout, format, _)| Bytecode { opcode: *start, layout: *layout, format: *format })
 }
 
 #[derive(Clone, Debug)]
@@ -809,12 +811,15 @@ fn parse_instructions(image: &[u8], base_offset: u32) -> Result<Vec<InstructionV
         .try_reserve((insns_end - insns_start) / 2)
         .map_err(|_| super::allocation_error("DEX instructions"))?;
     while pos < boundary {
-        let opcode = image[pos];
-        let Some(instruction) = find_instruction(opcode) else { break };
+        let raw_opcode = image[pos];
+        let Some(instruction) = find_instruction(raw_opcode) else { break };
         let length_bytes = instruction.layout as usize * 2;
         if insns_end - pos < length_bytes {
             break;
         }
+        // Filters compare the canonical range-start opcode
+        // (native `value.instr->opcode`), not the raw byte.
+        let opcode = instruction.opcode;
         if opcode == 0x26 || opcode == 0x2B || opcode == 0x2C {
             let payload_rel = read_i32(image, pos + 2).unwrap_or(0);
             // The native bound is relative to the remaining instruction bytes
@@ -1437,3 +1442,28 @@ mod tests {
         assert_eq!(read_target_index(&image, map, 4, 10, 2), 108);
     }
 }
+
+#[cfg(test)]
+mod opcode_family_tests {
+    use super::*;
+
+    #[test]
+    fn ranged_opcode_families_use_canonical_start() {
+        let insns = [
+            0x54u8, 0x00, 0x00, 0x00, // iget-object (family 0x52)
+            0x70, 0x00, 0x00, 0x00, 0x00, 0x00, // invoke-direct (family 0x6E)
+            0x33, 0x00, 0x00, 0x00, // cmpg-float (family 0x32)
+            0x39, 0x00, 0x00, 0x00, // if-ne (family 0x38)
+        ];
+        let mut image = vec![0u8; CODE_ITEM_HEADER + insns.len()];
+        image[12..16].copy_from_slice(&((insns.len() / 2) as u32).to_le_bytes());
+        image[CODE_ITEM_HEADER..].copy_from_slice(&insns);
+        let values = parse_instructions(&image, 0).unwrap();
+        let opcodes: Vec<u8> = values.iter().map(|v| v.opcode).collect();
+        assert_eq!(opcodes, vec![0x52, 0x6E, 0x32, 0x38]);
+        assert!(filter_location(CodeFilter::Field, values[0]).is_some());
+        assert!(filter_location(CodeFilter::Method, values[1]).is_some());
+        assert!(filter_location(CodeFilter::Rel16, values[2]).is_some());
+        assert!(filter_location(CodeFilter::Rel16, values[3]).is_some());
+    }
+}
diff --git a/src/zucchini_pure/engine.rs b/src/zucchini_pure/engine.rs
index e8ee031..0a0d957 100644
--- a/src/zucchini_pure/engine.rs
+++ b/src/zucchini_pure/engine.rs
@@ -611,12 +611,208 @@ impl OffsetMapper {
     }
 }
 
+/// Reproduces the permutation produced by libstdc++'s `std::sort` when the
+/// comparator only orders by `src_offset`.
+///
+/// Zucchini's reference-delta stream is generated with the native OffsetMapper,
+/// whose `PruneEquivalencesAndSortBySource` calls `std::sort`. `std::sort` is
+/// not stable, and the pruning is order-sensitive for equivalences that share a
+/// `src_offset` (their post-prune order determines which one a projection
+/// picks). A stable Rust sort produces a different projection and diverges from
+/// native output, so the exact native permutation must be reproduced. This is
+/// a direct port of libstdc++ `__introsort_loop` / `__final_insertion_sort`
+/// with the `__partial_sort` heap fallback.
+#[allow(clippy::many_single_char_names)]
+mod stdcpp {
+    use super::Equivalence;
+
+    const THRESHOLD: usize = 16;
+
+    #[inline]
+    fn comp(a: &Equivalence, b: &Equivalence) -> bool {
+        a.src_offset < b.src_offset
+    }
+
+    fn lg(n: usize) -> u32 {
+        (usize::BITS - 1) - n.leading_zeros()
+    }
+
+    fn move_median_to_first(v: &mut [Equivalence], result: usize, a: usize, b: usize, c: usize) {
+        if comp(&v[a], &v[b]) {
+            if comp(&v[b], &v[c]) {
+                v.swap(result, b);
+            } else if comp(&v[a], &v[c]) {
+                v.swap(result, c);
+            } else {
+                v.swap(result, a);
+            }
+        } else if comp(&v[a], &v[c]) {
+            v.swap(result, a);
+        } else if comp(&v[b], &v[c]) {
+            v.swap(result, c);
+        } else {
+            v.swap(result, b);
+        }
+    }
+
+    fn unguarded_partition(
+        v: &mut [Equivalence],
+        mut first: usize,
+        mut last: usize,
+        pivot: usize,
+    ) -> usize {
+        loop {
+            while comp(&v[first], &v[pivot]) {
+                first += 1;
+            }
+            last -= 1;
+            while comp(&v[pivot], &v[last]) {
+                last -= 1;
+            }
+            if first >= last {
+                return first;
+            }
+            v.swap(first, last);
+            first += 1;
+        }
+    }
+
+    fn unguarded_partition_pivot(v: &mut [Equivalence], first: usize, last: usize) -> usize {
+        let mid = first + (last - first) / 2;
+        move_median_to_first(v, first, first + 1, mid, last - 1);
+        unguarded_partition(v, first + 1, last, first)
+    }
+
+    fn unguarded_linear_insert(v: &mut [Equivalence], mut last: usize) {
+        let value = v[last];
+        let mut next = last - 1;
+        while comp(&value, &v[next]) {
+            v[last] = v[next];
+            last = next;
+            next -= 1;
+        }
+        v[last] = value;
+    }
+
+    fn insertion_sort(v: &mut [Equivalence], first: usize, last: usize) {
+        if first == last {
+            return;
+        }
+        for i in (first + 1)..last {
+            if comp(&v[i], &v[first]) {
+                let value = v[i];
+                let mut j = i;
+                while j > first {
+                    v[j] = v[j - 1];
+                    j -= 1;
+                }
+                v[first] = value;
+            } else {
+                unguarded_linear_insert(v, i);
+            }
+        }
+    }
+
+    fn unguarded_insertion_sort(v: &mut [Equivalence], first: usize, last: usize) {
+        for i in first..last {
+            unguarded_linear_insert(v, i);
+        }
+    }
+
+    fn final_insertion_sort(v: &mut [Equivalence], first: usize, last: usize) {
+        if last - first > THRESHOLD {
+            insertion_sort(v, first, first + THRESHOLD);
+            unguarded_insertion_sort(v, first + THRESHOLD, last);
+        } else {
+            insertion_sort(v, first, last);
+        }
+    }
+
+    fn push_heap(v: &mut [Equivalence], mut hole: usize, top: usize, value: Equivalence) {
+        let mut parent = (hole - 1) / 2;
+        while hole > top && comp(&v[parent], &value) {
+            v[hole] = v[parent];
+            hole = parent;
+            parent = (hole - 1) / 2;
+        }
+        v[hole] = value;
+    }
+
+    fn adjust_heap(v: &mut [Equivalence], mut hole: usize, len: usize, value: Equivalence) {
+        let top = hole;
+        let mut second = hole;
+        while second < (len - 1) / 2 {
+            second = 2 * (second + 1);
+            if comp(&v[second], &v[second - 1]) {
+                second -= 1;
+            }
+            v[hole] = v[second];
+            hole = second;
+        }
+        if len & 1 == 0 && second == (len - 2) / 2 {
+            second = 2 * (second + 1);
+            v[hole] = v[second - 1];
+            hole = second - 1;
+        }
+        push_heap(v, hole, top, value);
+    }
+
+    fn pop_heap(v: &mut [Equivalence], last: usize) {
+        // [0, last) is the heap; `last` is the element being removed.
+        let value = v[last];
+        v[last] = v[0];
+        adjust_heap(&mut v[..last], 0, last, value);
+    }
+
+    fn heapsort(v: &mut [Equivalence]) {
+        if v.len() < 2 {
+            return;
+        }
+        let len = v.len();
+        let mut parent = (len - 2) / 2;
+        loop {
+            let value = v[parent];
+            adjust_heap(v, parent, len, value);
+            if parent == 0 {
+                break;
+            }
+            parent -= 1;
+        }
+        let mut last = len;
+        while last > 1 {
+            last -= 1;
+            pop_heap(v, last);
+        }
+    }
+
+    fn introsort_loop(v: &mut [Equivalence], first: usize, mut last: usize, mut depth: u32) {
+        while last - first > THRESHOLD {
+            if depth == 0 {
+                heapsort(&mut v[first..last]);
+                return;
+            }
+            depth -= 1;
+            let cut = unguarded_partition_pivot(v, first, last);
+            introsort_loop(v, cut, last, depth);
+            last = cut;
+        }
+    }
+
+    pub(super) fn sort_by_src(v: &mut [Equivalence]) {
+        let n = v.len();
+        if n > 1 {
+            introsort_loop(v, 0, n, lg(n) * 2);
+            final_insertion_sort(v, 0, n);
+        }
+    }
+}
+
 /// Mirrors `OffsetMapper::PruneEquivalencesAndSortBySource`.
 struct PruneEquivalencesAndSortBySource;
 
 impl PruneEquivalencesAndSortBySource {
     fn prune(equivalences: &mut Vec<Equivalence>) {
-        equivalences.sort_by_key(|equivalence| equivalence.src_offset);
+        stdcpp::sort_by_src(equivalences);
 
         let mut current = 0usize;
         while current < equivalences.len() {
@@ -762,3 +958,34 @@ mod tests {
         }
     }
 }
+
+#[cfg(test)]
+mod native_sort_tests {
+    use super::*;
+
+    /// Guards the libstdc++ `std::sort` port: the native permutation of
+    /// equal-`src_offset` equivalences is what the reference-delta stream
+    /// depends on, so the expected order below was produced by compiling
+    /// `PruneEquivalencesAndSortBySource`'s `std::sort` comparator with
+    /// libstdc++ on this 48-element tie-heavy input.
+    #[test]
+    fn sort_reproduces_native_tie_order() {
+        let input: [(u32, u32, u32); 48] = [(0, 1000, 1), (5, 1001, 2), (10, 1002, 3), (15, 1003, 4), (6, 1004, 5), (11, 1005, 1), (16, 1006, 2), (4, 1007, 3), (12, 1008, 4), (0, 1009, 5), (5, 1010, 1), (10, 1011, 2), (1, 1012, 3), (6, 1013, 4), (11, 1014, 5), (16, 1015, 1), (7, 1016, 2), (12, 1017, 3), (0, 1018, 4), (5, 1019, 5), (13, 1020, 1), (1, 1021, 2), (6, 1022, 3), (11, 1023, 4), (2, 1024, 5), (7, 1025, 1), (12, 1026, 2), (0, 1027, 3), (8, 1028, 4), (13, 1029, 5), (1, 1030, 1), (6, 1031, 2), (14, 1032, 3), (2, 1033, 4), (7, 1034, 5), (12, 1035, 1), (3, 1036, 2), (8, 1037, 3), (13, 1038, 4), (1, 1039, 5), (9, 1040, 1), (14, 1041, 2), (2, 1042, 3), (7, 1043, 4), (15, 1044, 5), (3, 1045, 1), (8, 1046, 2), (13, 1047, 3)];
+        let expected: [(u32, u32, u32); 48] = [(0, 1000, 1), (0, 1009, 5), (0, 1027, 3), (0, 1018, 4), (1, 1039, 5), (1, 1030, 1), (1, 1012, 3), (1, 1021, 2), (2, 1042, 3), (2, 1033, 4), (2, 1024, 5), (3, 1045, 1), (3, 1036, 2), (4, 1007, 3), (5, 1001, 2), (5, 1019, 5), (5, 1010, 1), (6, 1004, 5), (6, 1031, 2), (6, 1022, 3), (6, 1013, 4), (7, 1025, 1), (7, 1016, 2), (7, 1043, 4), (7, 1034, 5), (8, 1037, 3), (8, 1028, 4), (8, 1046, 2), (9, 1040, 1), (10, 1011, 2), (10, 1002, 3), (11, 1014, 5), (11, 1023, 4), (11, 1005, 1), (12, 1008, 4), (12, 1035, 1), (12, 1017, 3), (12, 1026, 2), (13, 1047, 3), (13, 1038, 4), (13, 1029, 5), (13, 1020, 1), (14, 1041, 2), (14, 1032, 3), (15, 1003, 4), (15, 1044, 5), (16, 1006, 2), (16, 1015, 1)];
+        let mut values: Vec<Equivalence> = input
+            .iter()
+            .map(|&(src_offset, dst_offset, length)| Equivalence {
+                src_offset,
+                dst_offset,
+                length,
+            })
+            .collect();
+        stdcpp::sort_by_src(&mut values);
+        let got: Vec<(u32, u32, u32)> = values
+            .iter()
+            .map(|e| (e.src_offset, e.dst_offset, e.length))
+            .collect();
+        assert_eq!(got, expected);
+    }
+}
+
diff --git a/tests/fixtures/zucchini/README.md b/tests/fixtures/zucchini/README.md
index 95c804f..65b768f 100644
--- a/tests/fixtures/zucchini/README.md
+++ b/tests/fixtures/zucchini/README.md
@@ -30,3 +30,24 @@ brotli --quality=9 --lgwin=20 --stdout input.zuc > input.zuc.br
 
 `malformed-zucchini.zuc.br` is the same Brotli encoding of the ASCII bytes `not a zucchini patch`.
 `malformed-brotli.zuc.br` contains the ASCII bytes `not a Brotli stream` followed by a newline and is intentionally not a Brotli stream.
+
+## Realistic DEX differential fixture
+
+`annotation-jvm-{old,new}.dex` + `annotation-jvm.zuc` are a small but complete
+real-world differential case: AndroidX `annotation-jvm` 1.8.1 -> 1.10.0
+`classes.dex` (28,568 -> 29,516 bytes), patched with the AOSP
+`external/zucchini` generator from the same pinned commits listed above.
+
+It is deliberately kept because it exercises two apply-path behaviours that the
+hand-built fixtures do not:
+
+- ranged Dalvik opcode families (`iget`/`iput`, `invoke-kind`, `cmp`/`if`),
+  whose native filters match the canonical range-start opcode rather than the
+  raw byte; and
+- the libstdc++ `std::sort` tie order inside
+  `PruneEquivalencesAndSortBySource`, on which the reference-delta stream
+  depends for equivalences that share a `src_offset`.
+
+The pure-Rust engine failed to apply this patch until both behaviours were
+ported, so it is a compact regression guard (161 equivalences, 2,044 reference
+deltas) that runs in milliseconds.
diff --git a/tests/fixtures/zucchini/SHA256SUMS b/tests/fixtures/zucchini/SHA256SUMS
index 9a14671..e65d434 100644
--- a/tests/fixtures/zucchini/SHA256SUMS
+++ b/tests/fixtures/zucchini/SHA256SUMS
@@ -1,3 +1,6 @@
+193b1caac682a40ad87657e87e387e1b030013c700e79733bf56a8115324972f  annotation-jvm-new.dex
+2e49e0ab01d4a3f253d16bd305848b38aeec102ea7982dc4f641dcfa85bc7c25  annotation-jvm-old.dex
+764358162ba84969bd6ba9c6bdd7f67df8b6ee6a555e2529d9084cfe057b79e8  annotation-jvm.zuc
 bdf755e070b6cba4f0ea478130c261906c12c0f1fcd0a665effb24dda6db18b5  dex-large-new.dex
 c837542fb547d892cbc597a39951bc6b3b0398ec89ff76a472a5c0d720e05ae3  dex-large-old.dex
 ebad167e527b375967bef5932e7af4dd7317c4d905b4227f1ab5da6fdb2d4515  dex-large-unsafe16.zuc
diff --git a/tests/fixtures/zucchini/annotation-jvm-new.dex b/tests/fixtures/zucchini/annotation-jvm-new.dex
new file mode 100644
index 0000000000000000000000000000000000000000..41134fb95ab6354da994b6bde001468c3b41177c
GIT binary patch
literal 29516
zcmchA3w&KgwfF3ub57oAlBPXr(?>{?KA?~D%sFXF+oVa_l%x$w8VXd)dF)e8n-?c1
zrA34wh+M_TRY2r|BA|d&d03<hXhl#yE-HEv<%6qoMfAJE)vH_|SCsF+X3v~6XJ_xU
z+~4>6PWWeL&04c&&6=4tv*(nZq;aIo7i?ppU%z(!e=oe@^G_~#zw7CL`{rv`m3Q4*
z^UR|^?wew4k}-B<Bvgxpe=g53wnsC|FGb0dZpOSwZ!czSBhup~j13~ari`(Eq;-{y
z-MkOw3mMBUX6!I<Gw@5GwSlo2;1!^A31fExXD>w=@D$LrjIjg2kARWo&;cxNWbDU4
z`x%Tq3WS?L1Lv(^>{Z~BX6S8UtZyY_dx1D`2)Gou7WgRe3E*bnHsB86MZmp^u?C<K
zXaUXw{6HG`EbuJw3*fJSdo^Q~Kn<`02mxKdUf=*Q4O|P{1biC!GVm?n8Q=%NPl4Bg
zw}5$T&=wE{dVuqQI4}lW1zZDM2iyr92fhuw0K5TcXEL?`Xa+U_t-vOr2RIkF2$%$}
z0X__T68Hje0(b`aF7RXE72r3(Uw{Q?!3V%PU@Nc}xDdD)I0R&YtAS4ew*hwm4*@>_
z-UMpbG8P1efDCXG@G$TK@E4$A9qa>Azz2Z4foFg>fx7jKZ2>L<t_JP}o&|mj)NFuW
zU=WxFJ_(!vUIhLKoaIA3;6~si@KfOLK%<|r?LY#!2DlS=3V0PL4KTJE=mSQ9j|0bn
z?*Xp^^MZ^800a04@G$TqP!hs;0de4iz%k%^z`q0KVaC=1eZVAeBk&dA1)#JQ`hXE2
z3tS6)5%>Y{pFmv%eFS=dy}&`>3gF|w!@y5~w}9nQ#yWsBa2;?P@Br{4@HWuW##lFy
z1ZIF+ffK+BfVL5H7YG0wfnMNzU_USoydSs)xDWU`@EzbMz%PK;fxiJ&?Tjq~mI6MY
z9oPY!3tR-GfXjdffG2^U0>1}}H(^Z!VW11>0|tP7Kmr&AE(5LyZUY_yz6yK;_!00c
z;7!1LHsSzq7T^QgfpdWrFa}%>TnStad;oYH_ye$JGv+05Iq*^7F5p4n1n@NQJn$0m
zbKni&P2lf9`4-FtU_Q_YtOGUzJ;1rZc|a042pk3858McR8u%=5FK|C_9C#df0(cg9
z4tN208Tb|Od*H7?(N_2hr~?)QX8>mcVc=|_2iOTb2=p=d4j2Ot1D66vfTO@=z<Yqp
zf%gJe09OJtz*WHefUALPfcFE}0v`ab1O5T{An+mJdf>yrM}Ut49|Qgo_&D$h;0EAE
z;3nXcz|Fv?fLnln0&WFv13nFW2DlygEN};KCvX?=IpFia-M~G-y}%cM`+#G>7lAJU
z_X7_A4+0MXUj~i?4+CET9sy1OUj@DfJPJGpJPv#v_y%wi_$KfK@FegQ@NM8bz|+A0
z0-gb$1-=V>5BNUt9Pk6+hrqu8&jUXKUI2a!`~-Lr_}{=wz{|kD0zU(O4*VNXt6@xm
z24D%W6j%l<2O5DhfF@uCKw~REG{z|69~x_2<R_4}i2Rhu4=-kn%C{=z9mrF87U>AE
zPsp4nWJrFmlD}BwNhjr#kSE(mMR}dbkD{FVLpITe^o;YInJ1b)luq)TnZHEIXOuj(
zM<0?WTj@jj!#s!m2|o?UFMv1tMfwMkx?smbaC$*66nsjFPbu+R(3>ToTUdrI<!KA|
zQwvJoE$F034Uwiq`kF}ph_plK>424_rvpFxMN0i7n)*m7^^a0F+NZPvX&-*5AAPWk
z^iukUNPjER-y`h@hx*em<R~RMN=c4VlDiN;*kX9vAyOJ!DxVhVFGTvfNdH5mm9XdC
z_}K!Q(m#o`2<377YywRw(Fy#7KvPQclu~<?QhSurJfie`ky86a|4yX;Dbo4SSHViz
z4y2Vx`;k_mKWlhe%GL@xB+|1*x*h3!AvYiOwt`*&O@8R5G=OxWplRIu!1oF{8v6+7
zC1@$iQ^Zn1pM$hf*s%g>7w8qJPj)pU-ON+7oakQAEwH2!I$K10E$9ig-@?jR8|S;&
zE+IF7bS3JY$<rDZ;At&u<!Ke$$Wv4QN>;>ngI)zY!y@hG={#=FYD56)2c=~HIw40X
z$*p76TrP@!1VKmPk#?kQXrKH`DfMe3tK(@qX!0|q=OW#NdOneoAI=tj+05Krev3%A
zLT?NBl&<D!6<fzsb38jRBIF;;dOkiK!ap6tKOM}&{X=r(pH8G?R~P!VMWh`f?G!2T
zyG1{{(Js+_LO-SC|9(N!`se|FM6^4?ig|nI3AyuF2|Ek?G%II*q(!K!t;C*=v=6bZ
z6=_xmH{@LwegyP23g2zvM?v49@I4lO8|b?fezAqW5%h6|Ut;06gML!sms<E|gMMD&
zms$9mLBFc-%Pss)&~GaI3JZT5Xcq$h-7#eFsRUI2b%Cw}|9-)*vhce>H-rC(;Lo%0
zdq9W4m!E26RQ=mQcPacD3x5abVTE67;hzIKsqp7p_`5)7!T-Lnug=2X4f-0T{sPcs
z1I-`$3;;KP{}Sr|3pVkEpjG>ce;4>~3clCEKNs|4;Frab!KWTj>koo{R%w5cg+B!P
zWrdF^T~L1*^y><r_9RvR9?)+oe2Skc|3c6e6F3_P`)Dsz`TIaG0bhQWA*1r&1$wQ*
zUvA-F1bUOgZ?y1fSo*+UDcV27!l&YWO8q7a{{ZMwg}=hWr?b!H;I9|@n{D{lgTGPm
z=`2>W)jVS%%g;`?g1=Mn5n2lRPx>DN|HFd6%EC{Beir<D1%I`Le-QM`;D1%{*I4+6
zK)(*Y{G5r5>VG=Vy`}KavhZo>D<<(veAXgW>wgRM5{19c!hZ$yTJWC|_N}+@Uj@BM
zslUO(|0U=?h3~WQe+7D<!lyHUYTvIxk1BlH8&v-P0e!i`4_f&D4*Gh9PiG&s{%=6v
zs_?@W{+pnWDSX;b)cXGg`Z0x1`-#f`Gw5d(KJ6ze|Gz=M4E~RVe`!Ba`EP-K9sE}W
zpY{`#|2NQYf&Yf!(|%&*S6sr_e+m933;*w+mw>M!w$X?78@2x1px1(5DfqPCsC;bC
zY!mnk1fR~7R(>D&O9g+c4Syf_ErQ<xzPkQ2=pO~YP4GJ{^@)E2_(uePn}x4~e;4@j
zL;IO(UorT{!JiTJX+Kl>CEz~^{tbdp`<cow1^;<PKka8KzYP3W75)wjza0EG6@IUU
zUj@D^gF^AyiB#1;5BxfXPy3<DuLi$a;rD@G1IYbtA^0KiZ%6-L0{SiWiQfhOqk_N7
z!uNu|Ptm{I!e0dbsKN(HQ-*&^@Vg1;#mVY2<S0_o(*ymW92=br>0~u&r1Jd7jVw*)
zG$g8!>fq{vU5a!GPVbjA?!pPWf-Og$`dchOV)KDGo5$i>1&iyIEM8Q_;;u3lcbBuc
zr<%1Clff0do@y`Yj^i9XUOmA1%kgALx>ehXxJ(Hzr#xXL`a=G0f-Q@+*I2DS>08XI
z^)zfS%aW|NR+d$WGK1AN$+AjOmSVL5Sym;=wzAqzSym>>-py(UWm&l>`y=*vSyqi_
zTRMqUz=x&0Ps{O?c}exTqO64bwFuUe{eC$XzJ6F;W#ex=E9d;(!TV0<WCDH2M{zu-
z#I*(R_d@u4KKxw|e|uSrCkw8VuWJ=wXB~W9Q{d|;Y^6EegeR88+9db&X71}cQFaOU
zwOO`6lx4WD&9a4}Y(Mw4SvFskRcPdEv#ef}xi#{&S>}abDZ-LpYtiRg%s<tyH3fd{
zu=rJ-Yv$VM!~CZepJt2r8Zg(!c3IDHZ7f2KWvI~vT&=OHyTACw`|i7sU8U*E8>`@-
zsxN%$*xmQB9h^K9LVOO>^FG<I7ohdD2RWjr1#MD`PtKH;>GgV<Ufoc3a;D^o59swL
zX9BuU>pVI0#62FJb)B545E9j8dP!-?6W2a*6&EV0b=B&=lQWPlEzzI2!{aK^tBVfm
zB`&}Xcz|M{1So~FGPa{oS=s+o85EX5VL5}9wTk`dMoF1oQY8A(=%$`*)ZCqAwIwi4
zU#$Cz2IrY64E8K0lU>l{VSDG)#6406C7M~8=Ulex+-QJvL<6pB_d98zDAz!dsb-eF
zr{6%S;)`4lgd4a+-dPVmqRsLVwcu7~&FZ|P^DXe4o4mzy9$UW^&+;3U@LIx??rJLG
zwMB`ix){DKVePXFtAb&=YFJ6FXO8iAv$IdF;#8B!&4z82$mz(3pjz62^qskXmW8xz
z3p;sg3*U8ercNvvEPX7M{F1r0NG^S4IS*EGE8TmaxONy$*AXO8L}OqnDz+5yaT#-H
z&4q>k|FkvOR5IIuQZ{mOW?^A`s4>Z0j4&gFr?alM7W1R5)>ER@>OPmRs0qIZy@h3B
z+Ua~r7qfjQXX*>Jm%u;pD9yftQLoL7I>jLxcUr|f9_4g;!~$@O5|^0V_hZ>PH{($!
zdBA4%x$|p|=V+kJbx0nY9S%!pnNc=t)sYO>BTOx>rV_4Cl$2Cc#4l$T%(A`8bdegT
zZ5PJrJ7{{YHZaxld)ngMFqn%k@0;1J$#|3>juPPqS>mZKK_5%mq*MEtYlYKbS+4y$
zJ`Ln_EAqK9-DZ!42NTeho0O2UOpTi`H5M1nKo7+POu=%b1%018GJA4!gQj8O#H4-~
z?r2m(k=Y~car5z~86itBBjB4dcKGDXl0pOF6s!-vOvuK9Wztwnewnolxox~X#|0_(
z3faC}jLlW>ki~!nJmlpJC~#6!Z3Q;~gF)**-|#8ib9&COF$U48x-{>N|BuF;fM*&D
zheiwwO<OsI)bO%Vuc+({aZm6GQd`9*v3U-}<m9wxah|4FN0Wl4OW~9%9bAAZm6Oa(
z>oSxp8brCLnnDoQBua{_%Q3xh9@bCJglsz@B5^tQEp|#i-e&NpEZ;kE{>;UOjYSI<
zdOLS0y~{;vUPfD9G0#z$E9HGH6FsQ#m2<jM&{e+jSv{VI5+3(+eXT|b*P82P4NACn
zQBqP}3x6oBi1M=P`6yRf6XliFb?{0(D{F4<-8D4av1?m5D{1cDH9XkcJ;aKeM>_iU
zAXC<Cj8Bg>kH^LgR%zxZGRgFKY!otwW24i?6w_C)VMVLgbkVO~`n8jVSFh=djVCh`
z>Ew|OvGMVVY%H6e7~jx4J~e41va$H6F_4*<G&0$v%_F2`_~@k3&dzkGHfUTjoz56j
z14d>nJv9YQ?W_*62V;k08%AT}2R004GwJaI?bP}R{knj;R<F6Rm;c_$T9H3(d%Dr#
z?(uBqX!|>>*E1SBAnL7gYH!e(f}x4*@I>=a0{w4i3rKW!KNhZ@UD%7Rm266krpMFS
z&CIjOO!dv}th!^@uHC~O!@awA?cdhdF*L;HDJ8?_58zw3j`8#unqPnL@Ywo8SyoGQ
zEIW}=$|^g?k1AvZ$l;4KMl4Ac=5=H;F_m4_k<F^LJ)OO~ItI^Y^E=byNh2d_isq_1
zCniP}-EPxN_qN@Ay9ZhMw%wS6gL}3OgQ(aR8yy{*#^j)8tF~QiBo3kG^k|mo8ct7<
zvt?Hnn?*y(L%rkKj%=S1o61UF`L>DCi44lAZUra$CdLo&4slAcsdU@K*ko)Rvx^}+
zo{go)4O|dV))>!@q>W3ZRt?{Bb`7vaUB+a_NW`*6awt8XFghmFQes|LddwJClvnct
znz~Y?sw+K}n3&GQ4jA0Q3qVhf#*Xs#j^uh!+cmLkBHKHTVK-#e+OACOQd&ex1C`xl
zli8y=zm?{uF?09ycK3BLS5I#r)_BjJUE64)u+rRwWtBan6S3?d7Lvhz-h(bHs%v{P
zu>`GOrL1`SV8=-B@cFD{`{3?91N(csSk3lK>~K1Jl)Np5y<+=xER!^nokvM;^^VwR
ziZ><sS}!Z<-PO}QIN04qx#9iYyY}>(xt_j`?X03VsWiISCVog&rD(RxNKrfG$mTjz
z1Hw39s55mT6=fzTMlJJS+sVq$F^oy6QtM;IeZ8H7G^;B`W<T#Pt1BS)4-9tq^zLPP
zUmq*#!>_8o-P=0)_K$Q7_I7l_>q~8;k64oJ><mY?u&|viaS)*u+0K?bam`iO&X(B=
zh$Y?bWT3gi+gX!sb#<XTsSxYl$;8}RcXEQV{M%Whtr_`<(9Z0)9h(5*<PsS#91W&;
zLLp>M1$<EKM^y<Y?QFGehh~Qrr^aNIaq4(3=rreIn^VVfqD~{BgsXPeY;Sl$1anlB
z4`_}e`S|8E>iKZzB#{qlPLor_IVUTWu;<i9KIA$1H5UP$1ad*Koi*5cm50D~7PM#D
zoTzf4|D9CI?FR3pl5%#lUwJkG+bNcr@!M&p%aHCg5cw$I&RQHiRS@*s*<xEU+5nt}
zsxNkQVw!eFrwK)Y0h^GMk^MMQ$cSveCG_LC&GoOaHEtI+*aQ41J%<syCdPM7kB&M;
zZLs&G#UaDV+f<*<7fuU(_oOl2Gm#m_ah4yu?E~|`C{8z{Q{2>g+x`q3aheT-u}gV9
z`ye`K;G~o=&P!)6c3QmhnE{8gcILNjU5a!c!2yqsW{8sF*w@Zhon95E*(P=O7_sbh
z29C7fLUUp`&$hF5bGDg(`e`1-p}d`~KV9+jGU+T#u-|Q@33>JHY^8%{>(h(<xMSeN
zQ;yR@7&PD%EQK^ylKnCqN?!(x?awvl!yaE}a|!VIV}I}&${yv1XQyG|d~v{TXZCAx
zI1|I95yxUDQ%||l_M~M%u%DwN>8UgpVt%oyJGuQFomIuDm*-7n4#@{Kr**h@j2_$Y
zh?$Fh@^swNmyC@bP9IXA?>lmj`WT%U9@(hr*<#(}iP4EEM2>Bvu_-8DW+T%(j;Ald
zKf{LKZ;Zu-fEkZxH#3wzFfLYKjq*4xlvXQ6v|~~q^AF-wvWe9yCA;GXadpvNP-f0V
z3PJgr%5_KH9gZSh6Nza&DdG{5TxF}Jd(<Ea^NPfwB?LqS8Z%@!+N;5ugBC<NTHdw|
z<s=3sM$-x0e=N0^8;)fT81TgWzC#mPJeO|BA6VO2jV$apvauv=qEIU2Y+aLUl{TBX
z1ZA^!QvK6Y*-k@s<}w>ys+X49@^da)Y{QlY<apSu$EG&WRO!ZrQJUtVGj9`~;Y9al
z)jJ2?TqC)7cHWStCsf?BZOEIf>`i6joIww}EBYof2R0luvhfT~7gNe=oZ5hk1M?){
z>F*xivAc^^=1(B}L0=p<<dSyn+P$lr)fJpFB(F*wD<nN%Jx9pGdGg>O3u+2a3e;%v
zK*zRoI<|MSc_M?S=iZTy;ciws&@tEnOS=alB+BLu4DKH29vnV@|Mu=-;^Yg4%z{!#
z40mrE#tni#u$R^3PaV>T(t#r~TRzx5w0qCswr;wxC?4FiYq+<+n^l^p4JqWJ?G^u$
zCV$9~oRBC>HpY)OW-m4x<t69(j4_3~oP?1cpPWLNz%px`j3o}?a%VkhGVd>y3!-{i
zmOFgNHgeM9=s-T3FQw^}E(I6K!u-xHSvC1BSQb_0_gvEGG2OuQp#fGlw5OBb$Kk@)
z&F>{yG3~!3SCQLniK;d!XqRf|$*oit%vbkLS?C__9vU8EE`AkRSFm$Rk?P!5DND-b
z-bgK<v1iI?w7Ya^#H7#C9VOF7*gSr1y+1#Xibnc+S!wPuh1Jd497*|nbtja~yZNb!
zRhm1XEY&VxI_{PA3wN^6|L9Kn9n?}D$=*S&TxW6Mv$s&ro7~hxh<1{kvfNkKsJGP=
z`LGSBMRG?hk0lbu6u+mPVs6~%?oP2PBomh!Ni&X4v9kPr0Fm*d5GjgH;{WJ~;od17
zpUxV+N#@2;VccLPiHW4azlJDJOpGV_xeH%H=t(~iVCBYmY68oTHcBFL5!odAW0R9O
zZm=@r2ySfoHwdiMkjH-JN?}>Ca{4VLU8&5(7^|e;y*RB*Po)nVtPI<pi1e)L;@A}3
zfJ-}z(_@npnd}tP4l&PYY%HFPG1pjZ>JTd$iydLbV`vu9091OMm5kwRl%5<lm_BwG
z{~rc@z2d_60l0adKv>CKnw~OP>0~Se1~vj#JT-mb08Z7+ljVCa)3Xz-JUfv$%{7g0
z1(^FVeVM|Fc>;Hq@(i6En1^Slz%w%Rti$vpX=Yq;MOXAaO>smjV?5cku_<XBX<FNq
zz(sf(x1$hSHwM3RMtu4JSm^b-1YOBbVe4z!n9WQZYn#xebr`s&je+ReCZQj7+SZ5G
z`$J9dWj|YT#T8e)$NmXOUV=j2h$rHqKx-SCv3>qfzOrbCcqC-R0+F_)vpByTg=93)
z8fgtggL6oVQ#geEv2ZGqh$kF{<)tZP!;!Y25oz^1%8CnAh_?ECzF1qd)k(DAG8OWM
zztu>zMgxxW<`*jD2)~gGhW(+qlW6{u6~fU-!k01<j@?r)Tp=FvCxd}hDD0@4&jpH9
zWJw|%N(Gb7{;<1<MYTwzHJ%6tB94uSFL9`en9-Jsr+m>lW%&gygbjaNye-x0I7Q@F
zKzup{!>L##HHQ&6lbPQGk$5WDnu-S^j^mR*6U*<0s8+Bo5o~LXhMcU=UFbqK;SYt{
z{9(t*mAkQ39tly+?+-?O@ixcFo~uUoB>h3Z-|skc)H`2DM-tIgC>nH}429odk^WdR
z9QOM{F~|NYcfk;k2K_!?(%E$7S{Tx8e!~bvV~#_hToIErrn1i$Fq}+Lu8ScZZ%sxM
z@iu2^^D8pyV>HqhPKM(tN5%PX&$xKp7mX*Qj>D>4DMNWM84gAK2}hUYub0V^SfDi=
zLcDeep!ut22)72Kfut|$7;VjKX9z~(u}C7Aa9kKRcf8H=ndm6>IF1P7OC=pcpPd4V
zD74jb1*ufR2!&IQ{jyUqlKW=`upkr&89`snG3ePS;6v3GkN88*8<M!PrY^>O0be5F
zxR7$!*N_bcf)O}m4tK~eEXjtL-*2P>0mn&B7vIWvnY>Ck8EB0r9VaBe;)ZIRnnR&j
z%F&SAl@BS67~yav6>^*|^6DF+;dmsFj3gY}&p(86YeT72I1=$WO<M7cN}|zls4W&X
z9HVE!gDX`C2V%*1GUXWm<yAR}hC=Xi%5h&&A9qQ0Ybx57ip3n4v3wFH*|tc~7YPO(
zqhR4fGB+IR199iGP5vR5q(g13VFYGJhvS+ZQt(_d5b-(AByr^qNh6LOzpd3V=qOLd
zq}WIW!>u8|<F+85H|Q!J;z55j5DEqz*NPO+J)S7n@~9rbg7hbyXV<Li)Mm0R7)|0Z
z;55l(C3#(sD$&-kFC6eYu8v$4arOyE6DglB<rrh6eEw<Oyv9dU5o}C}aN?8>RH~X+
z`lyQoMYt{Md`g(zEFUr)o-x3Vvp0W#ApW5eT54@=3q+H1xKKVTQUh(tWHO!zIEIV-
zZ3Icj1O9lV&3U@>Zv!9~g2|DP^CC5$KIxkQ2&aOfP!e`Hjkzg|o|16b2&WQ(kYf~*
z*Bm4piN%A-pyB8V^#+9ZE|@Y}{VB)cEw~S%3ZX!}HG(PYWO?qYgoI<kgg+1sI|eR!
zi^46(X(Aa5J8q=2Zbu4_mhpI7!iX4-PMTGncg7z{rP`8?mDIZzl21j#iBu}(*m?1d
z1SFFIU(y!~(i5hZWLir5uHLX-JD`1DU*c&9H$)nu4Q&m<hF09!XzwECS=xRiOI!^t
z4XYZ~G_2HO?l0*}G_Q8QzNE-|*vlfTw8wOp_AQVuq%QVD-Q_Eky7aW9jyOqi>xzYS
zfd*fLzoE^v%H41#x2m~eMPZ9aopcpgf7xkCz2~%~E<Y`)_c}@OJ{FmMH2bDCtSao&
z6;5?UpUN;I9`BWq+M#)wca`nH=mQwdr4`!Kx|f;5ZZ;Y;8`Wu;WwWJR;S3b^J1b<J
zG(EJ2g{C%_7^a|9QUfIw-m9Qw4U|OI(y#4W<ZLYx(!49?w6e;5ukL#L7%V-myV&E%
ze+Q70wN13t+K_9@oRjZE3$}BTPxcMwv|cCeGwWRKRHtCRT;n9gM^9@A$dPL<)c*cC
z>&bOT^IB+d@p-Mx>S}ng)O#)Ta4&A9@tE6r^R<&S#0B<$z{w6FRmoeq4!Q&0)!u%j
ze~7p=TW9Kn`dzwf(UZEjS3egspnf4cBqo$xsXUG}_)MR;W&FsmR2Nz+_WlEG>NC63
zYu^%|u?w|l5nS{kKH2IQn3JHSA%IvVqZa&Uw&j8M%xI-}(45R4L~Go6_N&8GTg*d@
zR4Y~ng&I?-CDeTA6iziK*!8C+^<gI|F~P!x<M|OMaWS3?;Nf!bM<ErVWw%p{L@7N-
z^EP?c%;D@Mu19qL@7_M4Z+QmkmH(`7DQx#+P-45n3TE3so|e?douqh|U2=S-0p>7%
z0+r^7NmAH!{S8hn6j*zslN7f@rzv61E*%pgHw9|>in$4OyU4SqP2Lr@-r-B8xpXDg
z%!s*Wa+~RVs44S)QmW}CU7I!UDkn{RNi=I;M_5#}UZ4;2<>6gzW?bGgyg&8c?9Ii;
zA~aKh0$Sfb?`z(q*YKviTfOi0{&5bA7j1n~k1WtkokiY%<{B@e@bXvb=*3XH$ona2
z|Cwa}M*6i|^WGc@Am_a)(yF0{=#qDhx5c~GyUsh}y#RXcTjo7n>G=YB_>jJYeFgZM
zz6Gvh-`5)|%s5a~zoNdmzQtU$nv67BessJrtK54F?BD~#B4M(rTl1bd=k#Ay^sv7C
zDSbKiwOjx#hN@!kKcRYrbnMi;&2t#OT7N`;4gV)NeP*7~Uwhm9Tq*r!PRv`O=+w*T
zHYX`QF-sdlJX-k>3eAWm;+3aiHBHopW*m@O3fuj(lg5Gt@tIRd)pO_G4k?Rs&zjS@
z>uj8By5qB_Xwa0p<FusibdusuE6ME{IO)QDA-QkR3Ad$TCET{U&}DZy=__#A=T1xN
z^G;GC;+ey!M4Q}!%=EzBPW20Hx#zT`?sbr2=6+k~gfBP<n+uT6kwF|__*27L)1yUv
z%gmjI>M&(Wz4t*)kQPxpejy-iuw4Y^K{cv9N{dj88l8|#@6f)V8?_af=&LZ%Tk@mk
z;mh?H8llNahbD)Z%;QX(j)Nvbr%TfgGShOo-SZPf5gu@g3LkKku)EU?=Ixrnw0(3G
z+9=)T=2m<O2H>pABIi0<A&xa0)$@lu*aW1ua<1)uDB^pK5Br0y=cK&3RXzZDb6c_(
z=B{<iZB{;5nFF^*s;WTK9`A#usxNz2+Nv@~Y%@HtbgQ~8{l)ap)<R_uosP0CR%MZT
zE$^fJRLDIJ&N}ujg5~qPUlvY?w9q)L)*|b~)Wcr%7wDX$KU-a&!wkF!_#*8HUi|A1
z7_~&N-(0^%-DZzto25-LQlrU^>S(*%dt7X{lio|b8Snl`g%)u;G)QOaX1?8eG}CFF
z`CXS95G#Bh6qk4(7M(&1>mwcqm11Ufm|oMdeEd?28BM+dEw-BwpBTls4QLf>E{Gjg
z7*GNOO1+OruXbpWEn1{=?me-~^^N>S_|5$G_=N6(Lp^Ux-3y_+%zHw1j_=pZyJ5~v
zrCYab*Jj_o>eRP_NcpwXl6urhN-Q9AGUAy>_QN#cF{f$;COm#xQeQuXR2BE!H~4&8
z?fos%H@v_1zGgeT=Je{9#+uJ!C(%F;t&A1kxt_)PwQuV#T|SHTNgZZ~zj+EHO{pgw
zq;Ou+*j4mGAEs$$>ei7`UIqAiu_(hC81Lb3)E3cC>2))%<Lk8d&A6Ul=YkFwFVz;6
zqx|)C6{bq9(o9`dv(;*~CQqL)cxb9<fg)FmcQuvV(x~CTPt9mfsK2H0*m@0(-oAm1
z`MFOky>0`rUMqc--V5kirl_>^tf*PxQBPMXrmV5>*5-No`g~sVAy0Mv`7%A2&ud|m
zueFLaVy3RBkdZc(pu075c6ZY)jko%#tJeppt0#h5>6?D7^v~$>bAFhhbqdwnEUL-8
z?V`+$L0lvUQCrjtb<YJ!-S2{K4C68}jM}1ez_~8ehia~6F1+U2rMs88+%CF%q<5gv
zyUTod4O$S`2=oH;frY?Qz{;OE1^>o5_|Jj&io$;sd8__ny#8#i_Sen9C;j-RhPnE7
z`j0AnYyXac_prkM4DvK7O7QA3=_8VP$wuaUMdl3T*8;L1b;y&RFIi+RQDoxCTYd4b
z3jY~}Up8otRSi;VqX?<W52B35G9vhLEa}~L#7m)k0-*ADAtl>>gH-nM9^@YZr2RJ{
zZ?)}D3ZMK)?{d3v2=BB7mICx{uQ*bAuie*>ejAYbFGK!AfYfgwFKv4b`M&^U+xJB|
z^|u`_qwNEzuPc#Cc^Z!lXp*P#vf6nwc(NV4@&1m&|2p#Ii&c2Bt!nEViVWFmZDR}M
zo!X#rFiye$kiw^NlzpRlbP_!3+k;4DyK?;B5cQnKfBwj9yFQAts{zu{g>*MS_1lnA
z-@l8LWL^ZM%uUEk85-ALf~I%4{RdJSV~QhGCyW;nb^?Dxo^;)h{PzITL*uj?`4ND0
z(OA(t{8r+HaKwKV<!=byOGv5y#o(#q5Ctv$Y&Q<qDtzl$(>NTn@TH%BgYv%v<mVqE
zm3|I_rh3hId7W&R^pf3IqfFYp6M5<r*{#-n4zf2Yb?xHOqYB^7=2zz6FS`KmPXwfG
z#mG~i$Szth=Yb}>XuYU*QN8zC>Z$yPz<XTb--*1+C!hR6;gj7oUK{YjXE|OZQwmzz
zX4kh?3!iL%5M^m#5_m7L4<OxMyewMkeja7N0;KN8h0H$43;;p2eJ0X&fX0;gtB|KR
zf!>Cc^rVoI9O)WEo^&OUN_pu=((@=le*8RA)epq`4WQaV`~+THeK{}*P+!&{Z3XH9
z;y-|t_>TjUe>L*Nr+68BH{J;i$o~Ee<-Y@DJI^4`-=PQ@T7R@AlgQILd=TkfzzJX!
zAm9B7snkXNeG0VHMZQt{L}OpRKhLK>TtPZ6M=Ett{O(a?{K(Uq_z6<EChkDqZcWg<
z_?1%EZeCPglyBdTA9UbT+vMwmf=}(AkGvd9S`!}wZMP<#gI!-y^wL_TJ*_%s?rATB
zM}F!7JqSo&c#)UBRQ*W$E>w7SYyT>RPyPIL0u3milB7Z)yV^qUu+SG<=<6)>Jr??D
z3;k;gU1Airzt%zzSm>;UzQIBtx6sd9=+`ZDb*iv^pM~B5T2n+^$Ztj2q($yJ3w^tV
zK4GDMVxj+Rp_d#`8bx-Kh2CeOFSpP)Sm@&x`gsferiEU6vDrSw0QxKj>QUB!v=Ql6
z!6zPlk`{W#Lf>VfpR~}gTIjbd^pdpMj{F_9(0eU3{-=O~&&?M4goS?2LjTS}S05};
z$9xug*g|J5^z|0{0So=Sg~m6x1)q8g9ktMVE%Xr!eH=8+V>zDlkw1pA%}8lnw;;V8
z^wXAluUqH}dSSov@mc6T3q5L~ueZ?0EcCM$`c(_<8dDlawhpwqK9`}4)@R5fH*BG6
zgc@0wQu%i!$w!w0^tUA`K6`=Ni_N`nBl7e&Cc(=6ok<V!{Q&)~Nv#ooivoH2dy_@T
z6OY~nu2q|L=x@5{D5tjQ?@_vtKMom+?+p3nNa$~wxRED2=x=rup)R%=9=km#r?#@x
MAC!~b^fxj8FK>M8sQ>@~

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/annotation-jvm-old.dex b/tests/fixtures/zucchini/annotation-jvm-old.dex
new file mode 100644
index 0000000000000000000000000000000000000000..34834755d296dc94cee6fb6f0f3623344a83efaa
GIT binary patch
literal 28568
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
Wn>-f#P)=>VNc}-M*-d|6?|%U=5t#D;

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/annotation-jvm.zuc b/tests/fixtures/zucchini/annotation-jvm.zuc
new file mode 100644
index 0000000000000000000000000000000000000000..6b2f47f100dde8ef902ef61b404d46e88d7c05c8
GIT binary patch
literal 8286
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
J-c<P6{oi6Fg7p9Z

literal 0
HcmV?d00001

diff --git a/tests/zucchini_pure.rs b/tests/zucchini_pure.rs
index 809f816..513d93b 100644
--- a/tests/zucchini_pure.rs
+++ b/tests/zucchini_pure.rs
@@ -298,3 +298,11 @@ fn pure_rust_rejects_absurd_element_count() {
     let error = zucchini_pure::apply(old, &patch, new.len()).unwrap_err();
     assert_eq!(error.status(), Status::InvalidPatch);
 }
+
+/// Real-world differential case (AndroidX annotation-jvm 1.8.1 -> 1.10.0).
+/// It requires both the canonical Dalvik opcode-family mapping and the
+/// libstdc++ `std::sort` tie ordering in the equivalence-map pruning.
+#[test]
+fn pure_rust_applies_realistic_dex_differential_fixture() {
+    assert_fixture("annotation-jvm", ".dex");
+}

From 4e3cd3ca5ed3e51e332ca499be9ea231ee815690 Mon Sep 17 00:00:00 2001
From: otadump audit <audit@opencode.local>
Date: Sat, 12 Sep 2026 17:51:27 +0530
Subject: [PATCH 33/42] build: prune dead native closure, drop bsdiff-android,
 split CLI/Python profiles

Build-only optimization prototype on top of delta-ota-support. No behavior
changes: all 48 Rust tests and the Python smoke pass.

- build.rs: drop xxhash.c (only lz4frame.c uses it; not built) and the dead
  libchrome debug/metrics/activity stack (17 TUs, ~7.8k upstream lines);
  keep callback_internal.cc + stringprintf.cc and add a ~90-line
  libchrome_shim.cc providing the 5 logging/StackTrace symbols the Zucchini
  closure actually references. Fixes the as-committed link failure (missing
  thread_id_name_manager/process_handle/command_line TUs).
- build.rs: -fvisibility=hidden [-inlines-hidden] for native code, unwind
  tables dropped for C, --exclude-libs,ALL on final links.
- Cargo: drop bsdiff-android; local src/bsdiff.rs replicates
  parse_bsdf2_header (BSDIFF40/BSDF2 magic, offtin lengths, None/Bz2/Brotli
  streams) using existing bzip2/brotli deps.
- Cargo: add release-cli profile (panic=abort) for the static CLI; release
  stays unwind so Python wheels raise panics as exceptions.
- CI: build --profile release-cli --bin otadump (no more pointless cdylib
  in CLI artifacts); packaging paths updated.

Measured (linux x86_64, rustc 1.98): CLI 2,892,080 B (panic=abort,
-131,760 B vs unwind); cdylib 2,754,352 B exporting exactly one symbol
(PyInit_otadump); zero XXH symbols in either artifact.
---
 .github/workflows/release.yaml |  10 +--
 Cargo.lock                     |  22 -------
 Cargo.toml                     |  12 +++-
 README.md                      |   4 +-
 build.rs                       |  33 +++++-----
 pyproject.toml                 |   3 +
 src/bsdiff.rs                  | 111 +++++++++++++++++++++++++++++++++
 src/lib.rs                     |   5 +-
 8 files changed, 149 insertions(+), 51 deletions(-)
 create mode 100644 src/bsdiff.rs

diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index ad07844..ecbb8c4 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -112,17 +112,17 @@ jobs:
       - name: Build binary (Linux)
         if: runner.os == 'Linux' && !contains(matrix.target, 'android')
         run: |
-          cargo zigbuild --release --locked --target=${{ matrix.target }} --color=always --verbose
+          cargo zigbuild --profile release-cli --locked --target=${{ matrix.target }} --color=always --verbose --bin otadump
 
       - name: Build binary (Android)
         if: contains(matrix.target, 'android')
         run: |
-          cargo ndk --target=${{ matrix.target }} build --release --locked --color=always --verbose
+          cargo ndk --target=${{ matrix.target }} build --profile release-cli --locked --color=always --verbose --bin otadump
 
       - name: Build binary (macOS / Windows)
         if: runner.os == 'macOS' || runner.os == 'Windows'
         run: |
-          cargo build --release --locked --target=${{ matrix.target }} --color=always --verbose
+          cargo build --profile release-cli --locked --target=${{ matrix.target }} --color=always --verbose --bin otadump
 
       - name: Package (*nix)
         if: runner.os != 'Windows'
@@ -134,7 +134,7 @@ jobs:
           native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE
           native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE
           native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
-          -C target/${{ matrix.target }}/release/ otadump
+          -C target/${{ matrix.target }}/release-cli/ otadump
           | gzip --best
           > 'otadump-${{ steps.get_version.outputs.value }}-${{ matrix.target }}.tar.gz'
       - name: Package (Windows)
@@ -147,7 +147,7 @@ jobs:
           native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE
           native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE
           native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
-          ./target/${{ matrix.target }}/release/otadump.exe
+          ./target/${{ matrix.target }}/release-cli/otadump.exe
       - name: Upload artifact
         uses: actions/upload-artifact@v4.6.0
         with:
diff --git a/Cargo.lock b/Cargo.lock
index 75f87b4..c782812 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -127,16 +127,6 @@ dependencies = [
  "alloc-stdlib",
 ]
 
-[[package]]
-name = "bsdiff-android"
-version = "0.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd6e86c63a796e87fc125590d0dd6e6933a873642e6f8bbfea8eb31bb527ce56"
-dependencies = [
- "brotli",
- "bzip2",
-]
-
 [[package]]
 name = "bumpalo"
 version = "3.18.1"
@@ -155,20 +145,9 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f3a53fac24f34a81bc9954b5d6cfce0c21e18ec6959f44f56e8e90e4bb7c346c"
 dependencies = [
- "bzip2-sys",
  "libbz2-rs-sys",
 ]
 
-[[package]]
-name = "bzip2-sys"
-version = "0.1.13+1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225bff33b2141874fe80d71e07d6eec4f85c5c216453dd96388240f96e1acc14"
-dependencies = [
- "cc",
- "pkg-config",
-]
-
 [[package]]
 name = "cc"
 version = "1.2.27"
@@ -633,7 +612,6 @@ version = "0.1.3"
 dependencies = [
  "anyhow",
  "brotli",
- "bsdiff-android",
  "bzip2",
  "cc",
  "clap",
diff --git a/Cargo.toml b/Cargo.toml
index 06fb104..156271c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -28,7 +28,6 @@ protoc-bin-vendored = "3.2.0"
 [dependencies]
 anyhow = "1.0.69"
 brotli = "8.0.2"
-bsdiff-android = "0.0.2"
 bzip2 = { version = "0.6.0" }
 clap = { version = "4.2.1", features = ["derive"] }
 color-print = "0.3.4"
@@ -53,3 +52,14 @@ codegen-units = 1
 debug = 0
 lto = true
 strip = true
+
+# Static CLI builds (CI + install.sh): panic=abort drops unwinding machinery.
+# Kept out of [profile.release] because maturin wheel builds use the `release`
+# profile and must preserve unwinding so panics surface as Python exceptions.
+[profile.release-cli]
+codegen-units = 1
+debug = 0
+inherits = "release"
+lto = true
+panic = "abort"
+strip = true
diff --git a/README.md b/README.md
index ca99adb..8202e52 100644
--- a/README.md
+++ b/README.md
@@ -114,7 +114,9 @@ Extraction releases the Python GIL.
 
 ### Local release packages
 
-Build the Linux x86-64 GNU CLI with `cargo build --release --locked`.
+Build the Linux x86-64 GNU CLI with `cargo build --profile release-cli --bin otadump --locked`
+(`release-cli` adds `panic = "abort"` on top of `release`; the plain `release`
+profile keeps unwinding so Python wheels can raise panics as exceptions).
 Build the ABI3 Python wheel with `uv build --wheel`.
 The wheel supports Python 3.9 and later and uses the build host's glibc baseline.
 Build release packages on the oldest Linux environment that you support.
diff --git a/build.rs b/build.rs
index 0a5a4fb..529b934 100644
--- a/build.rs
+++ b/build.rs
@@ -1,6 +1,7 @@
 use std::fs;
 use std::path::{Path, PathBuf};
 
+// Upstream Zucchini apply-only closure.
 const ZUCCHINI_SOURCES: &[&str] = &[
     "native/zucchini/src/zucchini_ffi.cc",
     "native/zucchini/vendor/zucchini/abs32_utils.cc",
@@ -20,32 +21,20 @@ const ZUCCHINI_SOURCES: &[&str] = &[
     "native/zucchini/vendor/zucchini/reloc_elf.cc",
     "native/zucchini/vendor/zucchini/target_pool.cc",
     "native/zucchini/vendor/zucchini/zucchini_apply.cc",
-    "native/zucchini/vendor/libchrome/base/at_exit.cc",
+    // Minimal libchrome runtime: the only upstream TUs still referenced after
+    // the dead debug/metrics/activity-tracking closure was removed, plus a shim
+    // replacing logging.cc + base/debug/*.
     "native/zucchini/vendor/libchrome/base/callback_internal.cc",
-    "native/zucchini/vendor/libchrome/base/debug/activity_tracker.cc",
-    "native/zucchini/vendor/libchrome/base/debug/alias.cc",
-    "native/zucchini/vendor/libchrome/base/debug/debugger_posix.cc",
-    "native/zucchini/vendor/libchrome/base/debug/stack_trace.cc",
-    "native/zucchini/vendor/libchrome/base/debug/stack_trace_posix.cc",
-    "native/zucchini/vendor/libchrome/base/lazy_instance_helpers.cc",
-    "native/zucchini/vendor/libchrome/base/location.cc",
-    "native/zucchini/vendor/libchrome/base/logging.cc",
-    "native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.cc",
-    "native/zucchini/vendor/libchrome/base/strings/string_piece.cc",
     "native/zucchini/vendor/libchrome/base/strings/stringprintf.cc",
-    "native/zucchini/vendor/libchrome/base/strings/string_util.cc",
-    "native/zucchini/vendor/libchrome/base/synchronization/lock_impl_posix.cc",
-    "native/zucchini/vendor/libchrome/base/threading/platform_thread_posix.cc",
-    "native/zucchini/vendor/libchrome/base/threading/thread_local_storage.cc",
-    "native/zucchini/vendor/libchrome/base/time/time.cc",
-    "native/zucchini/vendor/libchrome/base/time/time_now_posix.cc",
+    "native/zucchini/src/libchrome_shim.cc",
 ];
 
+// LZ4 block codec only. xxhash.c serves lz4frame.c (not built) and is
+// referenced by neither lz4.c nor lz4hc.c.
 const LZ4_SOURCES: &[&str] = &[
     "native/lz4/src/lz4_ffi.c",
     "native/lz4/vendor/lib/lz4.c",
     "native/lz4/vendor/lib/lz4hc.c",
-    "native/lz4/vendor/lib/xxhash.c",
 ];
 
 fn main() {
@@ -92,6 +81,10 @@ fn build_lz4() {
         .define("NDEBUG", None)
         .warnings(true)
         .warnings_into_errors(true)
+        .flag("-fvisibility=hidden")
+        // C code never throws: drop unwind tables.
+        .flag("-fno-asynchronous-unwind-tables")
+        .flag("-fno-unwind-tables")
         .include(root.join("src"))
         .include(root.join("vendor/lib"))
         .files(LZ4_SOURCES)
@@ -116,6 +109,8 @@ fn build_zucchini() {
         .flag("-fdata-sections")
         .flag("-fno-exceptions")
         .flag("-fno-rtti")
+        .flag("-fvisibility=hidden")
+        .flag("-fvisibility-inlines-hidden")
         .flag("-Wno-deprecated-declarations")
         .flag("-Wno-unused-parameter")
         .include(root.join("include"))
@@ -160,7 +155,7 @@ fn add_static_runtime(compiler: &cc::Tool, archive: &str, library: &str) {
 
 fn collect_files(directory: &Path, files: &mut Vec<PathBuf>) {
     let entries = fs::read_dir(directory)
-        .unwrap_or_else(|error| panic!("unable to read {}: {error}", directory.display()));
+        .unwrap_or_else(|error| panic!("unable to read native source entry: {error}"));
     for entry in entries {
         let path = entry.expect("unable to read native source entry").path();
         if path.is_dir() {
diff --git a/pyproject.toml b/pyproject.toml
index 6749678..14b315f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -29,5 +29,8 @@ classifiers = [
 ]
 
 [tool.maturin]
+# Wheels build with the default `release` profile, which keeps `panic =
+# "unwind"` so extraction-thread panics surface as Python exceptions. The
+# `release-cli` profile (panic = "abort") is for the static CLI only.
 features = ["python"]
 locked = true
diff --git a/src/bsdiff.rs b/src/bsdiff.rs
new file mode 100644
index 0000000..39bb0c7
--- /dev/null
+++ b/src/bsdiff.rs
@@ -0,0 +1,111 @@
+//! Local BSDF2/BSDIFF40 patch header and stream reader.
+//!
+//! Replaces the external `bsdiff-android` crate, of which only
+//! `parse_bsdf2_header` was ever linked. The apply loop itself lives in
+//! `lib.rs`; this module reproduces the header semantics bit-exactly:
+//!
+//! - `BSDIFF40`: all three streams are bzip2-compressed.
+//! - `BSDF2`: magic bytes 5..8 select a per-stream algorithm
+//!   (`0` = stored, `1` = bzip2, `2` = brotli).
+//! - Lengths use the bspatch sign-magnitude 64-bit encoding (`offtin`).
+//! - The extra stream spans the remainder of the patch.
+
+use std::io::Read;
+
+use anyhow::{Result, bail, ensure};
+
+enum Algorithm {
+    None,
+    Bz2,
+    Brotli,
+}
+
+fn algorithm_from_byte(value: u8) -> Result<Algorithm> {
+    match value {
+        0 => Ok(Algorithm::None),
+        1 => Ok(Algorithm::Bz2),
+        2 => Ok(Algorithm::Brotli),
+        _ => bail!("Unknown BSDF2 compression algorithm: {value}"),
+    }
+}
+
+/// Reads a sign-magnitude 64-bit integer as used by bspatch. This is not plain
+/// little-endian: the top bit encodes the sign of the magnitude.
+#[inline]
+fn offtin(buf: [u8; 8]) -> i64 {
+    let value = i64::from_le_bytes(buf);
+    if value & (1 << 63) == 0 {
+        value
+    } else {
+        -(value & !(1 << 63))
+    }
+}
+
+fn decompress_bz2(data: &[u8]) -> Result<Vec<u8>> {
+    let mut output = Vec::new();
+    let mut decoder = bzip2::read::BzDecoder::new(data);
+    decoder.read_to_end(&mut output)?;
+    Ok(output)
+}
+
+fn decompress_brotli(data: &[u8]) -> Result<Vec<u8>> {
+    let mut output = Vec::new();
+    let mut decoder = brotli::Decompressor::new(data, 4096);
+    decoder.read_to_end(&mut output)?;
+    Ok(output)
+}
+
+fn decompress(algorithm: Algorithm, data: &[u8]) -> Result<Vec<u8>> {
+    match algorithm {
+        Algorithm::None => Ok(data.to_vec()),
+        Algorithm::Bz2 => decompress_bz2(data),
+        Algorithm::Brotli => decompress_brotli(data),
+    }
+}
+
+/// Parses a BSDIFF40/BSDF2 patch header and returns the decompressed
+/// `(new_size, control, diff, extra)` streams.
+pub fn parse_header(patch: &[u8]) -> Result<(i64, Vec<u8>, Vec<u8>, Vec<u8>)> {
+    ensure!(patch.len() >= 32, "Patch data too short");
+
+    let magic = &patch[0..8];
+    let (control_algorithm, diff_algorithm, extra_algorithm) = if magic == b"BSDIFF40" {
+        (Algorithm::Bz2, Algorithm::Bz2, Algorithm::Bz2)
+    } else if &magic[0..5] == b"BSDF2" {
+        (
+            algorithm_from_byte(magic[5])?,
+            algorithm_from_byte(magic[6])?,
+            algorithm_from_byte(magic[7])?,
+        )
+    } else {
+        bail!("Invalid BSDIFF/BSDF2 magic header");
+    };
+
+    let control_length = offtin(patch[8..16].try_into()?);
+    let diff_length = offtin(patch[16..24].try_into()?);
+    let new_size = offtin(patch[24..32].try_into()?);
+    ensure!(
+        control_length >= 0 && diff_length >= 0 && new_size >= 0,
+        "Negative length in patch header"
+    );
+    let (control_length, diff_length) =
+        (control_length as usize, diff_length as usize);
+
+    let control_end = 32usize
+        .checked_add(control_length)
+        .ok_or_else(|| anyhow::anyhow!("Control stream length overflows patch bounds"))?;
+    ensure!(control_end <= patch.len(), "Control stream exceeds patch bounds");
+    let diff_end = control_end
+        .checked_add(diff_length)
+        .ok_or_else(|| anyhow::anyhow!("Diff stream length overflows patch bounds"))?;
+    ensure!(diff_end <= patch.len(), "Diff stream exceeds patch bounds");
+
+    let control = decompress(control_algorithm, &patch[32..control_end])?;
+    ensure!(
+        control.len() % 24 == 0,
+        "Invalid control data length (not multiple of 24)"
+    );
+    let diff = decompress(diff_algorithm, &patch[control_end..diff_end])?;
+    let extra = decompress(extra_algorithm, &patch[diff_end..])?;
+    Ok((new_size, control, diff, extra))
+}
diff --git a/src/lib.rs b/src/lib.rs
index 1b082ed..7e9c47e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -3,6 +3,7 @@
 mod chromeos_update_engine {
     include!(concat!(env!("OUT_DIR"), "/chromeos_update_engine.rs"));
 }
+mod bsdiff;
 pub mod lz4;
 mod lz4diff;
 mod payload;
@@ -26,7 +27,6 @@ use std::{error, result, slice, thread};
 
 use anyhow::{Context as _, Error, Result, bail, ensure};
 use brotli::Decompressor as BrotliDecoder;
-use bsdiff_android::parse_bsdf2_header;
 use bzip2::read::BzDecoder;
 use chromeos_update_engine::install_operation::Type;
 use chromeos_update_engine::{DeltaArchiveManifest, InstallOperation, PartitionUpdate};
@@ -1283,8 +1283,7 @@ pub(crate) fn apply_bsdiff(
     puffin::validate_bsdiff_resources(patch, expected_output_len, cancellation_token)?;
     cancellation_token.check()?;
 
-    let (new_size, control_data, diff_data, extra_data) =
-        parse_bsdf2_header(patch).map_err(|error| anyhow::anyhow!("{error}"))?;
+    let (new_size, control_data, diff_data, extra_data) = bsdiff::parse_header(patch)?;
     let new_size = usize::try_from(new_size).context("Patch new_size is negative or overflows")?;
     ensure!(
         new_size == expected_output_len,

From 2b636d2f582cdd53e72d7ed4def0aa1b94f0da40 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 20:51:21 +0530
Subject: [PATCH 34/42] zucchini: remove obsolete native implementation

Signed-off-by: Akhil Narang <me@akhilnarang.dev>
---
 .github/workflows/release.yaml                |   10 -
 .gitignore                                    |    2 -
 README.md                                     |    2 +-
 build.rs                                      |   99 +-
 docs/zucchini-rust-port.md                    |    8 +-
 native/lz4/SOURCE_INVENTORY.sha256            |    2 -
 native/lz4/vendor/lib/xxhash.c                | 1030 ---------
 native/lz4/vendor/lib/xxhash.h                |  328 ---
 native/zucchini/README.md                     |   89 -
 native/zucchini/SOURCE_INVENTORY.sha256       |  216 --
 .../include/components/zucchini/buildflags.h  |   12 -
 native/zucchini/include/gtest/gtest_prod.h    |    5 -
 native/zucchini/src/zucchini_ffi.cc           |  353 ---
 native/zucchini/src/zucchini_ffi.h            |   39 -
 .../vendor/libchrome/MODULE_LICENSE_BSD       |    0
 native/zucchini/vendor/libchrome/NOTICE       |   27 -
 .../zucchini/vendor/libchrome/base/at_exit.cc |  109 -
 .../zucchini/vendor/libchrome/base/at_exit.h  |   80 -
 .../vendor/libchrome/base/atomic_ref_count.h  |   67 -
 .../libchrome/base/atomic_sequence_num.h      |   33 -
 .../vendor/libchrome/base/atomicops.h         |  161 --
 .../base/atomicops_internals_portable.h       |  229 --
 .../vendor/libchrome/base/base_export.h       |   29 -
 .../vendor/libchrome/base/base_switches.h     |   51 -
 native/zucchini/vendor/libchrome/base/bind.h  |  482 -----
 .../vendor/libchrome/base/bind_internal.h     |  971 ---------
 .../zucchini/vendor/libchrome/base/callback.h |  146 --
 .../vendor/libchrome/base/callback_forward.h  |   27 -
 .../vendor/libchrome/base/callback_helpers.h  |  104 -
 .../libchrome/base/callback_internal.cc       |   84 -
 .../vendor/libchrome/base/callback_internal.h |  165 --
 .../vendor/libchrome/base/cfi_buildflags.h    |    7 -
 .../vendor/libchrome/base/command_line.h      |  247 ---
 .../vendor/libchrome/base/compiler_specific.h |  236 --
 .../base/containers/circular_deque.h          | 1111 ----------
 .../vendor/libchrome/base/containers/queue.h  |   23 -
 .../vendor/libchrome/base/containers/span.h   |  453 ----
 .../vendor/libchrome/base/containers/stack.h  |   23 -
 .../libchrome/base/containers/vector_buffer.h |  163 --
 .../libchrome/base/debug/activity_tracker.cc  | 1828 ----------------
 .../libchrome/base/debug/activity_tracker.h   | 1367 ------------
 .../vendor/libchrome/base/debug/alias.cc      |   27 -
 .../vendor/libchrome/base/debug/alias.h       |   43 -
 .../vendor/libchrome/base/debug/debugger.h    |   44 -
 .../libchrome/base/debug/debugger_posix.cc    |  272 ---
 .../base/debug/debugging_buildflags.h         |   12 -
 .../libchrome/base/debug/leak_annotations.h   |   46 -
 .../libchrome/base/debug/proc_maps_linux.h    |   94 -
 .../libchrome/base/debug/stack_trace.cc       |  277 ---
 .../vendor/libchrome/base/debug/stack_trace.h |  197 --
 .../libchrome/base/debug/stack_trace_posix.cc |  898 --------
 .../vendor/libchrome/base/environment.h       |   90 -
 .../vendor/libchrome/base/feature_list.h      |  310 ---
 .../libchrome/base/file_descriptor_posix.h    |   59 -
 .../vendor/libchrome/base/files/file.h        |  381 ----
 .../vendor/libchrome/base/files/file_path.h   |  481 -----
 .../libchrome/base/files/file_tracing.h       |   95 -
 .../vendor/libchrome/base/files/file_util.h   |  498 -----
 .../libchrome/base/files/memory_mapped_file.h |  136 --
 .../libchrome/base/files/platform_file.h      |   43 -
 .../vendor/libchrome/base/files/scoped_file.h |   62 -
 .../vendor/libchrome/base/format_macros.h     |   97 -
 .../vendor/libchrome/base/gtest_prod_util.h   |   66 -
 native/zucchini/vendor/libchrome/base/hash.h  |   69 -
 .../vendor/libchrome/base/lazy_instance.h     |  210 --
 .../libchrome/base/lazy_instance_helpers.cc   |   64 -
 .../libchrome/base/lazy_instance_helpers.h    |  101 -
 .../vendor/libchrome/base/location.cc         |   77 -
 .../zucchini/vendor/libchrome/base/location.h |  117 -
 .../zucchini/vendor/libchrome/base/logging.cc | 1065 ----------
 .../zucchini/vendor/libchrome/base/logging.h  | 1179 ----------
 .../zucchini/vendor/libchrome/base/macros.h   |  114 -
 .../libchrome/base/memory/free_deleter.h      |   25 -
 .../vendor/libchrome/base/memory/ptr_util.h   |   23 -
 .../raw_scoped_refptr_mismatch_checker.h      |   52 -
 .../libchrome/base/memory/ref_counted.h       |  425 ----
 .../libchrome/base/memory/scoped_refptr.h     |  337 ---
 .../libchrome/base/memory/shared_memory.h     |  254 ---
 .../base/memory/shared_memory_handle.h        |  238 ---
 .../vendor/libchrome/base/memory/singleton.h  |  262 ---
 .../vendor/libchrome/base/memory/weak_ptr.h   |  377 ----
 .../libchrome/base/metrics/bucket_ranges.h    |  105 -
 .../libchrome/base/metrics/field_trial.h      |  802 -------
 .../vendor/libchrome/base/metrics/histogram.h |  610 ------
 .../libchrome/base/metrics/histogram_base.h   |  307 ---
 .../base/metrics/histogram_functions.h        |  158 --
 .../libchrome/base/metrics/histogram_macros.h |  382 ----
 .../base/metrics/histogram_macros_internal.h  |  268 ---
 .../base/metrics/histogram_macros_local.h     |   90 -
 .../base/metrics/histogram_samples.h          |  267 ---
 .../metrics/persistent_memory_allocator.cc    | 1204 -----------
 .../metrics/persistent_memory_allocator.h     |  872 --------
 .../libchrome/base/metrics/sparse_histogram.h |  108 -
 .../vendor/libchrome/base/no_destructor.h     |   99 -
 .../libchrome/base/numerics/checked_math.h    |  393 ----
 .../base/numerics/checked_math_impl.h         |  567 -----
 .../libchrome/base/numerics/clamped_math.h    |  262 ---
 .../base/numerics/clamped_math_impl.h         |  341 ---
 .../base/numerics/safe_conversions.h          |  344 ---
 .../base/numerics/safe_conversions_impl.h     |  850 --------
 .../libchrome/base/numerics/safe_math.h       |   12 -
 .../base/numerics/safe_math_clang_gcc_impl.h  |  157 --
 .../base/numerics/safe_math_shared_impl.h     |  237 ---
 .../vendor/libchrome/base/observer_list.h     |  307 ---
 .../libchrome/base/observer_list_threadsafe.h |  237 ---
 .../zucchini/vendor/libchrome/base/optional.h |  922 --------
 .../vendor/libchrome/base/pending_task.h      |   68 -
 .../zucchini/vendor/libchrome/base/pickle.h   |  345 ---
 .../libchrome/base/posix/eintr_wrapper.h      |   68 -
 .../base/posix/file_descriptor_shuffle.h      |   87 -
 .../libchrome/base/posix/safe_strerror.h      |   44 -
 .../vendor/libchrome/base/process/launch.h    |  396 ----
 .../vendor/libchrome/base/process/process.h   |  213 --
 .../libchrome/base/process/process_handle.h   |  103 -
 .../libchrome/base/scoped_clear_errno.h       |   34 -
 .../vendor/libchrome/base/scoped_generic.h    |  189 --
 .../vendor/libchrome/base/sequence_checker.h  |   88 -
 .../libchrome/base/sequence_checker_impl.h    |   48 -
 .../libchrome/base/sequenced_task_runner.h    |  176 --
 .../base/sequenced_task_runner_helpers.h      |   42 -
 .../base/single_thread_task_runner.h          |   36 -
 .../zucchini/vendor/libchrome/base/stl_util.h |  410 ----
 .../libchrome/base/strings/char_traits.h      |   92 -
 .../vendor/libchrome/base/strings/string16.h  |  219 --
 .../base/strings/string_number_conversions.h  |  166 --
 .../libchrome/base/strings/string_piece.cc    |  453 ----
 .../libchrome/base/strings/string_piece.h     |  483 -----
 .../base/strings/string_piece_forward.h       |   24 -
 .../libchrome/base/strings/string_util.cc     | 1124 ----------
 .../libchrome/base/strings/string_util.h      |  485 -----
 .../base/strings/string_util_posix.h          |   37 -
 .../libchrome/base/strings/stringprintf.cc    |  189 --
 .../libchrome/base/strings/stringprintf.h     |   66 -
 .../base/strings/sys_string_conversions.h     |   84 -
 .../strings/utf_string_conversion_utils.h     |  100 -
 .../base/strings/utf_string_conversions.h     |   54 -
 .../libchrome/base/synchronization/lock.h     |  151 --
 .../base/synchronization/lock_impl.h          |   78 -
 .../base/synchronization/lock_impl_posix.cc   |  133 --
 .../synchronization_buildflags.h              |    4 -
 .../zucchini/vendor/libchrome/base/sys_info.h |  179 --
 .../vendor/libchrome/base/task_runner.h       |  154 --
 .../vendor/libchrome/base/template_util.h     |  154 --
 .../libchrome/base/third_party/icu/LICENSE    |   76 -
 .../libchrome/base/third_party/icu/icu_utf.h  |  442 ----
 .../libchrome/base/third_party/nspr/LICENSE   |   35 -
 .../base/third_party/nspr/MPL-1.1.txt         |  469 ----
 .../libchrome/base/third_party/nspr/prtime.h  |  263 ---
 .../base/threading/platform_thread.h          |  240 ---
 .../platform_thread_internal_posix.h          |   48 -
 .../base/threading/platform_thread_posix.cc   |  305 ---
 .../threading/sequenced_task_runner_handle.h  |   43 -
 .../base/threading/thread_collision_warner.h  |  245 ---
 .../base/threading/thread_id_name_manager.h   |   80 -
 .../libchrome/base/threading/thread_local.h   |   99 -
 .../base/threading/thread_local_storage.cc    |  408 ----
 .../base/threading/thread_local_storage.h     |  184 --
 .../base/threading/thread_restrictions.h      |  536 -----
 .../threading/thread_task_runner_handle.h     |   57 -
 .../vendor/libchrome/base/time/time.cc        |  420 ----
 .../vendor/libchrome/base/time/time.h         |  993 ---------
 .../libchrome/base/time/time_now_posix.cc     |  123 --
 .../libchrome/base/time/time_override.h       |   74 -
 native/zucchini/vendor/libchrome/base/token.h |   72 -
 .../vendor/libchrome/base/unguessable_token.h |  116 -
 native/zucchini/vendor/libchrome/base/vlog.h  |   77 -
 .../vendor/libchrome/build/build_config.h     |  263 ---
 .../testing/gtest/include/gtest/gtest_prod.h  |    1 -
 native/zucchini/vendor/zucchini/LICENSE       |   27 -
 .../vendor/zucchini/MODULE_LICENSE_CHROME     |    0
 .../zucchini/vendor/zucchini/abs32_utils.cc   |  211 --
 .../vendor/zucchini/address_translator.cc     |  258 ---
 .../vendor/zucchini/aosp/include/base/check.h |   22 -
 .../zucchini/aosp/include/base/check_op.h     |   24 -
 .../include/base/containers/cxx20_erase.h     |   22 -
 .../zucchini/aosp/include/build/buildflag.h   |   47 -
 .../include/components/zucchini/abs32_utils.h |  142 --
 .../components/zucchini/address_translator.h  |  199 --
 .../include/components/zucchini/algorithm.h   |  147 --
 .../include/components/zucchini/arm_utils.h   |  423 ----
 .../include/components/zucchini/buffer_sink.h |   68 -
 .../components/zucchini/buffer_source.h       |  141 --
 .../include/components/zucchini/buffer_view.h |  217 --
 .../aosp/include/components/zucchini/crc32.h  |   17 -
 .../components/zucchini/disassembler.h        |  155 --
 .../components/zucchini/disassembler_dex.h    |  295 ---
 .../components/zucchini/disassembler_elf.h    |  356 ----
 .../components/zucchini/disassembler_no_op.h  |   41 -
 .../components/zucchini/element_detection.h   |   62 -
 .../components/zucchini/encoded_view.h        |  185 --
 .../components/zucchini/equivalence_map.h     |  208 --
 .../include/components/zucchini/image_index.h |  116 -
 .../include/components/zucchini/image_utils.h |  225 --
 .../include/components/zucchini/io_utils.h    |  144 --
 .../components/zucchini/patch_reader.h        |  285 ---
 .../include/components/zucchini/patch_utils.h |  139 --
 .../components/zucchini/patch_writer.h        |  272 ---
 .../components/zucchini/reference_set.h       |   64 -
 .../components/zucchini/rel32_finder.h        |  284 ---
 .../include/components/zucchini/rel32_utils.h |  184 --
 .../include/components/zucchini/reloc_elf.h   |  102 -
 .../components/zucchini/suffix_array.h        |  475 -----
 .../include/components/zucchini/target_pool.h |   81 -
 .../components/zucchini/targets_affinity.h    |   74 -
 .../include/components/zucchini/type_dex.h    |  332 ---
 .../include/components/zucchini/type_elf.h    |  283 ---
 .../include/components/zucchini/typed_value.h |   57 -
 .../components/zucchini/version_info.h        |   30 -
 .../include/components/zucchini/zucchini.h    |   72 -
 .../components/zucchini/zucchini_apply.h      |   41 -
 native/zucchini/vendor/zucchini/arm_utils.cc  |  597 ------
 .../zucchini/vendor/zucchini/buffer_source.cc |  105 -
 native/zucchini/vendor/zucchini/crc32.cc      |   43 -
 .../zucchini/vendor/zucchini/disassembler.cc  |   52 -
 .../vendor/zucchini/disassembler_dex.cc       | 1890 -----------------
 .../vendor/zucchini/disassembler_elf.cc       |  758 -------
 .../vendor/zucchini/disassembler_no_op.cc     |   31 -
 .../vendor/zucchini/element_detection.cc      |  200 --
 .../vendor/zucchini/equivalence_map.cc        |  549 -----
 .../zucchini/vendor/zucchini/patch_reader.cc  |  401 ----
 .../zucchini/vendor/zucchini/rel32_finder.cc  |  294 ---
 .../zucchini/vendor/zucchini/rel32_utils.cc   |   67 -
 native/zucchini/vendor/zucchini/reloc_elf.cc  |  163 --
 .../zucchini/vendor/zucchini/target_pool.cc   |   84 -
 .../vendor/zucchini/zucchini_apply.cc         |  217 --
 pyproject.toml                                |    5 -
 src/bsdiff.rs                                 |   18 +-
 src/lib.rs                                    |    9 +-
 src/zucchini.rs                               |  142 +-
 src/zucchini_pure/arm.rs                      |   12 +-
 src/zucchini_pure/crc32.rs                    |   15 +-
 src/zucchini_pure/dex.rs                      |  106 +-
 src/zucchini_pure/elf.rs                      |   64 +-
 src/zucchini_pure/engine.rs                   |  166 +-
 src/zucchini_pure/mod.rs                      |   27 +-
 src/zucchini_pure/patch.rs                    |   89 +-
 tests/delta_extraction.rs                     |    8 -
 tests/zucchini_pure.rs                        |   37 -
 238 files changed, 265 insertions(+), 54392 deletions(-)
 delete mode 100644 native/lz4/vendor/lib/xxhash.c
 delete mode 100644 native/lz4/vendor/lib/xxhash.h
 delete mode 100644 native/zucchini/README.md
 delete mode 100644 native/zucchini/SOURCE_INVENTORY.sha256
 delete mode 100644 native/zucchini/include/components/zucchini/buildflags.h
 delete mode 100644 native/zucchini/include/gtest/gtest_prod.h
 delete mode 100644 native/zucchini/src/zucchini_ffi.cc
 delete mode 100644 native/zucchini/src/zucchini_ffi.h
 delete mode 100644 native/zucchini/vendor/libchrome/MODULE_LICENSE_BSD
 delete mode 100644 native/zucchini/vendor/libchrome/NOTICE
 delete mode 100644 native/zucchini/vendor/libchrome/base/at_exit.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/at_exit.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/atomic_ref_count.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/atomic_sequence_num.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/atomicops.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/atomicops_internals_portable.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/base_export.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/base_switches.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/bind.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/bind_internal.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/callback.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/callback_forward.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/callback_helpers.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/callback_internal.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/callback_internal.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/cfi_buildflags.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/command_line.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/compiler_specific.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/containers/circular_deque.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/containers/queue.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/containers/span.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/containers/stack.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/containers/vector_buffer.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/debug/activity_tracker.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/debug/activity_tracker.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/debug/alias.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/debug/alias.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/debug/debugger.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/debug/debugger_posix.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/debug/debugging_buildflags.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/debug/leak_annotations.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/debug/proc_maps_linux.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/debug/stack_trace.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/debug/stack_trace.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/debug/stack_trace_posix.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/environment.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/feature_list.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/file_descriptor_posix.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/files/file.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/files/file_path.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/files/file_tracing.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/files/file_util.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/files/memory_mapped_file.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/files/platform_file.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/files/scoped_file.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/format_macros.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/gtest_prod_util.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/hash.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/lazy_instance.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/lazy_instance_helpers.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/lazy_instance_helpers.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/location.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/location.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/logging.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/logging.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/macros.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/memory/free_deleter.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/memory/ptr_util.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/memory/raw_scoped_refptr_mismatch_checker.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/memory/ref_counted.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/memory/scoped_refptr.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/memory/shared_memory.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/memory/shared_memory_handle.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/memory/singleton.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/memory/weak_ptr.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/metrics/bucket_ranges.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/metrics/field_trial.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram_base.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram_functions.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram_macros.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram_macros_internal.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram_macros_local.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/metrics/histogram_samples.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/metrics/sparse_histogram.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/no_destructor.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/numerics/checked_math.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/numerics/checked_math_impl.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/numerics/clamped_math.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/numerics/clamped_math_impl.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/numerics/safe_conversions.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/numerics/safe_conversions_impl.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/numerics/safe_math.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/numerics/safe_math_clang_gcc_impl.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/numerics/safe_math_shared_impl.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/observer_list.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/observer_list_threadsafe.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/optional.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/pending_task.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/pickle.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/posix/eintr_wrapper.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/posix/file_descriptor_shuffle.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/posix/safe_strerror.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/process/launch.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/process/process.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/process/process_handle.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/scoped_clear_errno.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/scoped_generic.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/sequence_checker.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/sequence_checker_impl.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/sequenced_task_runner.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/sequenced_task_runner_helpers.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/single_thread_task_runner.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/stl_util.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/char_traits.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/string16.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/string_number_conversions.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/string_piece.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/string_piece.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/string_piece_forward.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/string_util.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/string_util.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/string_util_posix.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/stringprintf.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/stringprintf.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/sys_string_conversions.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/utf_string_conversion_utils.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/strings/utf_string_conversions.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/synchronization/lock.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/synchronization/lock_impl.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/synchronization/lock_impl_posix.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/synchronization/synchronization_buildflags.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/sys_info.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/task_runner.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/template_util.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE
 delete mode 100644 native/zucchini/vendor/libchrome/base/third_party/icu/icu_utf.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE
 delete mode 100644 native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
 delete mode 100644 native/zucchini/vendor/libchrome/base/third_party/nspr/prtime.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/threading/platform_thread.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/threading/platform_thread_internal_posix.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/threading/platform_thread_posix.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/threading/sequenced_task_runner_handle.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_collision_warner.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_id_name_manager.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_local.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_local_storage.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_local_storage.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_restrictions.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/threading/thread_task_runner_handle.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/time/time.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/time/time.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/time/time_now_posix.cc
 delete mode 100644 native/zucchini/vendor/libchrome/base/time/time_override.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/token.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/unguessable_token.h
 delete mode 100644 native/zucchini/vendor/libchrome/base/vlog.h
 delete mode 100644 native/zucchini/vendor/libchrome/build/build_config.h
 delete mode 100644 native/zucchini/vendor/libchrome/testing/gtest/include/gtest/gtest_prod.h
 delete mode 100644 native/zucchini/vendor/zucchini/LICENSE
 delete mode 100644 native/zucchini/vendor/zucchini/MODULE_LICENSE_CHROME
 delete mode 100644 native/zucchini/vendor/zucchini/abs32_utils.cc
 delete mode 100644 native/zucchini/vendor/zucchini/address_translator.cc
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/base/check.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/base/check_op.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/base/containers/cxx20_erase.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/build/buildflag.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/abs32_utils.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/address_translator.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/algorithm.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/arm_utils.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_sink.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_source.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_view.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/crc32.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_dex.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_elf.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_no_op.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/element_detection.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/encoded_view.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/equivalence_map.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_index.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_utils.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/io_utils.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_reader.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_utils.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_writer.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reference_set.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_finder.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_utils.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reloc_elf.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/suffix_array.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/target_pool.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/targets_affinity.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_dex.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_elf.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/typed_value.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/version_info.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini.h
 delete mode 100644 native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini_apply.h
 delete mode 100644 native/zucchini/vendor/zucchini/arm_utils.cc
 delete mode 100644 native/zucchini/vendor/zucchini/buffer_source.cc
 delete mode 100644 native/zucchini/vendor/zucchini/crc32.cc
 delete mode 100644 native/zucchini/vendor/zucchini/disassembler.cc
 delete mode 100644 native/zucchini/vendor/zucchini/disassembler_dex.cc
 delete mode 100644 native/zucchini/vendor/zucchini/disassembler_elf.cc
 delete mode 100644 native/zucchini/vendor/zucchini/disassembler_no_op.cc
 delete mode 100644 native/zucchini/vendor/zucchini/element_detection.cc
 delete mode 100644 native/zucchini/vendor/zucchini/equivalence_map.cc
 delete mode 100644 native/zucchini/vendor/zucchini/patch_reader.cc
 delete mode 100644 native/zucchini/vendor/zucchini/rel32_finder.cc
 delete mode 100644 native/zucchini/vendor/zucchini/rel32_utils.cc
 delete mode 100644 native/zucchini/vendor/zucchini/reloc_elf.cc
 delete mode 100644 native/zucchini/vendor/zucchini/target_pool.cc
 delete mode 100644 native/zucchini/vendor/zucchini/zucchini_apply.cc

diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index ecbb8c4..454c7d5 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -129,11 +129,6 @@ jobs:
         run: >
           tar -cv
           LICENSE README.md src/puffin/LICENSE native/lz4/LICENSE
-          native/zucchini/vendor/zucchini/LICENSE
-          native/zucchini/vendor/libchrome/NOTICE
-          native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE
-          native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE
-          native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
           -C target/${{ matrix.target }}/release-cli/ otadump
           | gzip --best
           > 'otadump-${{ steps.get_version.outputs.value }}-${{ matrix.target }}.tar.gz'
@@ -142,11 +137,6 @@ jobs:
         run: >
           7z a 'otadump-${{ steps.get_version.outputs.value }}-${{ matrix.target }}.zip'
           LICENSE README.md src/puffin/LICENSE native/lz4/LICENSE
-          native/zucchini/vendor/zucchini/LICENSE
-          native/zucchini/vendor/libchrome/NOTICE
-          native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE
-          native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE
-          native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
           ./target/${{ matrix.target }}/release-cli/otadump.exe
       - name: Upload artifact
         uses: actions/upload-artifact@v4.6.0
diff --git a/.gitignore b/.gitignore
index 1e54029..43d1f25 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,8 +2,6 @@
 # Generated by Cargo
 # will have compiled files and executables
 debug/
-!native/zucchini/vendor/libchrome/base/debug/
-!native/zucchini/vendor/libchrome/base/debug/**
 dist/
 target/
 
diff --git a/README.md b/README.md
index 8202e52..a8de477 100644
--- a/README.md
+++ b/README.md
@@ -120,7 +120,7 @@ profile keeps unwinding so Python wheels can raise panics as exceptions).
 Build the ABI3 Python wheel with `uv build --wheel`.
 The wheel supports Python 3.9 and later and uses the build host's glibc baseline.
 Build release packages on the oldest Linux environment that you support.
-Release archives and wheels include the notices for vendored Puffin, LZ4, Zucchini, libchrome, ICU, and NSPR code.
+Release archives and wheels include the notices for vendored Puffin and LZ4 code.
 
 ## Contributors
 
diff --git a/build.rs b/build.rs
index 529b934..9a88d57 100644
--- a/build.rs
+++ b/build.rs
@@ -1,48 +1,15 @@
 use std::fs;
 use std::path::{Path, PathBuf};
 
-// Upstream Zucchini apply-only closure.
-const ZUCCHINI_SOURCES: &[&str] = &[
-    "native/zucchini/src/zucchini_ffi.cc",
-    "native/zucchini/vendor/zucchini/abs32_utils.cc",
-    "native/zucchini/vendor/zucchini/address_translator.cc",
-    "native/zucchini/vendor/zucchini/arm_utils.cc",
-    "native/zucchini/vendor/zucchini/buffer_source.cc",
-    "native/zucchini/vendor/zucchini/crc32.cc",
-    "native/zucchini/vendor/zucchini/disassembler.cc",
-    "native/zucchini/vendor/zucchini/disassembler_dex.cc",
-    "native/zucchini/vendor/zucchini/disassembler_elf.cc",
-    "native/zucchini/vendor/zucchini/disassembler_no_op.cc",
-    "native/zucchini/vendor/zucchini/element_detection.cc",
-    "native/zucchini/vendor/zucchini/equivalence_map.cc",
-    "native/zucchini/vendor/zucchini/patch_reader.cc",
-    "native/zucchini/vendor/zucchini/rel32_finder.cc",
-    "native/zucchini/vendor/zucchini/rel32_utils.cc",
-    "native/zucchini/vendor/zucchini/reloc_elf.cc",
-    "native/zucchini/vendor/zucchini/target_pool.cc",
-    "native/zucchini/vendor/zucchini/zucchini_apply.cc",
-    // Minimal libchrome runtime: the only upstream TUs still referenced after
-    // the dead debug/metrics/activity-tracking closure was removed, plus a shim
-    // replacing logging.cc + base/debug/*.
-    "native/zucchini/vendor/libchrome/base/callback_internal.cc",
-    "native/zucchini/vendor/libchrome/base/strings/stringprintf.cc",
-    "native/zucchini/src/libchrome_shim.cc",
-];
-
 // LZ4 block codec only. xxhash.c serves lz4frame.c (not built) and is
 // referenced by neither lz4.c nor lz4hc.c.
-const LZ4_SOURCES: &[&str] = &[
-    "native/lz4/src/lz4_ffi.c",
-    "native/lz4/vendor/lib/lz4.c",
-    "native/lz4/vendor/lib/lz4hc.c",
-];
+const LZ4_SOURCES: &[&str] =
+    &["native/lz4/src/lz4_ffi.c", "native/lz4/vendor/lib/lz4.c", "native/lz4/vendor/lib/lz4hc.c"];
 
 fn main() {
     println!("cargo:rustc-check-cfg=cfg(otadump_lz4)");
     println!("cargo:rustc-check-cfg=cfg(otadump_zucchini)");
-    println!("cargo:rustc-check-cfg=cfg(otadump_native_zucchini)");
     println!("cargo:rerun-if-changed=src/protos/chromeos_update_engine/update_metadata.proto");
-    println!("cargo:rerun-if-env-changed=OTADUMP_NATIVE_ZUCCHINI");
     if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("linux")
         && std::env::var("CARGO_CFG_TARGET_ARCH").as_deref() == Ok("x86_64")
         && std::env::var("CARGO_CFG_TARGET_ENV").as_deref() == Ok("gnu")
@@ -51,15 +18,6 @@ fn main() {
         println!("cargo:rustc-cfg=otadump_lz4");
     }
 
-    // Zucchini is implemented in pure Rust (`src/zucchini_pure`). The vendored
-    // C++/libchrome implementation is retained only for differential testing,
-    // enabled explicitly with `OTADUMP_NATIVE_ZUCCHINI=1` (exact value only).
-    println!("cargo:rustc-cfg=otadump_zucchini");
-    if std::env::var("OTADUMP_NATIVE_ZUCCHINI").as_deref() == Ok("1") {
-        build_zucchini();
-        println!("cargo:rustc-cfg=otadump_native_zucchini");
-    }
-
     let protoc = protoc_bin_vendored::protoc_bin_path().expect("unable to find vendored protoc");
     let mut config = prost_build::Config::new();
     config.protoc_executable(protoc);
@@ -91,42 +49,6 @@ fn build_lz4() {
         .compile("otadump_lz4");
 }
 
-fn build_zucchini() {
-    let root = Path::new("native/zucchini");
-    track_directory(root);
-
-    let mut build = cc::Build::new();
-    build
-        .cpp(true)
-        .cpp_link_stdlib(None)
-        .std("c++17")
-        .opt_level(2)
-        .define("NDEBUG", None)
-        .define("OFFICIAL_BUILD", None)
-        .define("__ANDROID_HOST__", None)
-        .define("DONT_EMBED_BUILD_METADATA", None)
-        .flag("-ffunction-sections")
-        .flag("-fdata-sections")
-        .flag("-fno-exceptions")
-        .flag("-fno-rtti")
-        .flag("-fvisibility=hidden")
-        .flag("-fvisibility-inlines-hidden")
-        .flag("-Wno-deprecated-declarations")
-        .flag("-Wno-unused-parameter")
-        .include(root.join("include"))
-        .include(root.join("src"))
-        .include(root.join("vendor/zucchini/aosp/include"))
-        .include(root.join("vendor/zucchini/aosp/include/components"))
-        .include(root.join("vendor/libchrome"))
-        .files(ZUCCHINI_SOURCES);
-
-    let compiler = build.get_compiler();
-    build.compile("otadump_zucchini");
-    add_static_runtime(&compiler, "libstdc++.a", "stdc++");
-    add_static_runtime(&compiler, "libgcc.a", "gcc");
-    println!("cargo:rustc-link-arg=-static-libgcc");
-}
-
 fn track_directory(root: &Path) {
     let mut tracked = Vec::new();
     collect_files(root, &mut tracked);
@@ -136,23 +58,6 @@ fn track_directory(root: &Path) {
     }
 }
 
-fn add_static_runtime(compiler: &cc::Tool, archive: &str, library: &str) {
-    let output = compiler
-        .to_command()
-        .arg(format!("-print-file-name={archive}"))
-        .output()
-        .unwrap_or_else(|error| panic!("unable to locate {archive}: {error}"));
-    assert!(output.status.success(), "unable to locate {archive}");
-    let path =
-        PathBuf::from(String::from_utf8(output.stdout).expect("compiler path is not UTF-8").trim());
-    let directory = path
-        .parent()
-        .filter(|_| path.is_absolute() && path.is_file())
-        .unwrap_or_else(|| panic!("compiler did not provide a usable {archive} path"));
-    println!("cargo:rustc-link-search=native={}", directory.display());
-    println!("cargo:rustc-link-lib=static={library}");
-}
-
 fn collect_files(directory: &Path, files: &mut Vec<PathBuf>) {
     let entries = fs::read_dir(directory)
         .unwrap_or_else(|error| panic!("unable to read native source entry: {error}"));
diff --git a/docs/zucchini-rust-port.md b/docs/zucchini-rust-port.md
index b58557a..b0de882 100644
--- a/docs/zucchini-rust-port.md
+++ b/docs/zucchini-rust-port.md
@@ -142,11 +142,5 @@ group and range on the ELF/DEX fixtures.
 
 ## Remaining work
 
-1. **Differential testing.** Building the native path
-   (`OTADUMP_NATIVE_ZUCCHINI=1 cargo test`, exact value `1` required) enables
-   `native_and_pure_agree_on_all_fixtures`. That build currently fails to link in
-   this environment on pre-existing libchrome symbols
-   (`base::Histogram::FactoryGet` from `activity_tracker.cc`), unrelated to the
-   Rust port; the default, pure build is unaffected.
-2. **Non-Android formats (Win32, ZTF).** Not emitted by Android payloads and
+1. **Non-Android formats (Win32, ZTF).** Not emitted by Android payloads and
    intentionally rejected.
diff --git a/native/lz4/SOURCE_INVENTORY.sha256 b/native/lz4/SOURCE_INVENTORY.sha256
index aede22b..96e465a 100644
--- a/native/lz4/SOURCE_INVENTORY.sha256
+++ b/native/lz4/SOURCE_INVENTORY.sha256
@@ -5,5 +5,3 @@
 26b82efc53d1570f3b54eef02e9c4764c1ad374ff03cac04e2ced5ea4d4c552f  vendor/lib/lz4.h
 126cafafdb91767e6e55238298a910903851b35b2cee27ce80ae2280469ee232  vendor/lib/lz4hc.c
 e43824e8a9ba16f54100c4ccbccfa5782a858ca9ab83c48aac303fea3e76e21e  vendor/lib/lz4hc.h
-b667033dc735fb5ea5648e0a61a2e065e5ef5bbda53669730063bd856c643c48  vendor/lib/xxhash.c
-aefdd236f35130495c18764cabed3f7b216906855fc5e6a9025cd2040bc84444  vendor/lib/xxhash.h
diff --git a/native/lz4/vendor/lib/xxhash.c b/native/lz4/vendor/lib/xxhash.c
deleted file mode 100644
index e132619..0000000
--- a/native/lz4/vendor/lib/xxhash.c
+++ /dev/null
@@ -1,1030 +0,0 @@
-/*
-*  xxHash - Fast Hash algorithm
-*  Copyright (C) 2012-2016, Yann Collet
-*
-*  BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-*
-*  Redistribution and use in source and binary forms, with or without
-*  modification, are permitted provided that the following conditions are
-*  met:
-*
-*  * Redistributions of source code must retain the above copyright
-*  notice, this list of conditions and the following disclaimer.
-*  * Redistributions in binary form must reproduce the above
-*  copyright notice, this list of conditions and the following disclaimer
-*  in the documentation and/or other materials provided with the
-*  distribution.
-*
-*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-*  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-*  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-*  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*
-*  You can contact the author at :
-*  - xxHash homepage: http://www.xxhash.com
-*  - xxHash source repository : https://github.com/Cyan4973/xxHash
-*/
-
-
-/* *************************************
-*  Tuning parameters
-***************************************/
-/*!XXH_FORCE_MEMORY_ACCESS :
- * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
- * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
- * The below switch allow to select different access method for improved performance.
- * Method 0 (default) : use `memcpy()`. Safe and portable.
- * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
- *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
- * Method 2 : direct access. This method doesn't depend on compiler but violate C standard.
- *            It can generate buggy code on targets which do not support unaligned memory accesses.
- *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See http://stackoverflow.com/a/32095106/646947 for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef XXH_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */
-#  if defined(__GNUC__) && ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) \
-                        || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) \
-                        || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
-#    define XXH_FORCE_MEMORY_ACCESS 2
-#  elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || \
-  (defined(__GNUC__) && ( defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) \
-                    || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) \
-                    || defined(__ARM_ARCH_7S__) ))
-#    define XXH_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
-/*!XXH_ACCEPT_NULL_INPUT_POINTER :
- * If input pointer is NULL, xxHash default behavior is to dereference it, triggering a segfault.
- * When this macro is enabled, xxHash actively checks input for null pointer.
- * It it is, result for null input pointers is the same as a null-length input.
- */
-#ifndef XXH_ACCEPT_NULL_INPUT_POINTER   /* can be defined externally */
-#  define XXH_ACCEPT_NULL_INPUT_POINTER 0
-#endif
-
-/*!XXH_FORCE_NATIVE_FORMAT :
- * By default, xxHash library provides endian-independent Hash values, based on little-endian convention.
- * Results are therefore identical for little-endian and big-endian CPU.
- * This comes at a performance cost for big-endian CPU, since some swapping is required to emulate little-endian format.
- * Should endian-independence be of no importance for your application, you may set the #define below to 1,
- * to improve speed for Big-endian CPU.
- * This option has no impact on Little_Endian CPU.
- */
-#ifndef XXH_FORCE_NATIVE_FORMAT   /* can be defined externally */
-#  define XXH_FORCE_NATIVE_FORMAT 0
-#endif
-
-/*!XXH_FORCE_ALIGN_CHECK :
- * This is a minor performance trick, only useful with lots of very small keys.
- * It means : check for aligned/unaligned input.
- * The check costs one initial branch per hash;
- * set it to 0 when the input is guaranteed to be aligned,
- * or when alignment doesn't matter for performance.
- */
-#ifndef XXH_FORCE_ALIGN_CHECK /* can be defined externally */
-#  if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
-#    define XXH_FORCE_ALIGN_CHECK 0
-#  else
-#    define XXH_FORCE_ALIGN_CHECK 1
-#  endif
-#endif
-
-
-/* *************************************
-*  Includes & Memory related functions
-***************************************/
-/*! Modify the local functions below should you wish to use some other memory routines
-*   for malloc(), free() */
-#include <stdlib.h>
-static void* XXH_malloc(size_t s) { return malloc(s); }
-static void  XXH_free  (void* p)  { free(p); }
-/*! and for memcpy() */
-#include <string.h>
-static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcpy(dest,src,size); }
-
-#include <assert.h>   /* assert */
-
-#define XXH_STATIC_LINKING_ONLY
-#include "xxhash.h"
-
-
-/* *************************************
-*  Compiler Specific Options
-***************************************/
-#if defined (_MSC_VER) && !defined (__clang__)    /* MSVC */
-#  pragma warning(disable : 4127)      /* disable: C4127: conditional expression is constant */
-#  define FORCE_INLINE static __forceinline
-#else
-#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#    if defined (__GNUC__) || defined (__clang__)
-#      define FORCE_INLINE static inline __attribute__((always_inline))
-#    else
-#      define FORCE_INLINE static inline
-#    endif
-#  else
-#    define FORCE_INLINE static
-#  endif /* __STDC_VERSION__ */
-#endif
-
-
-/* *************************************
-*  Basic Types
-***************************************/
-#ifndef MEM_MODULE
-# if !defined (__VMS) \
-  && (defined (__cplusplus) \
-  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
-#   include <stdint.h>
-    typedef uint8_t  BYTE;
-    typedef uint16_t U16;
-    typedef uint32_t U32;
-# else
-    typedef unsigned char      BYTE;
-    typedef unsigned short     U16;
-    typedef unsigned int       U32;
-# endif
-#endif
-
-#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))
-
-/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */
-static U32 XXH_read32(const void* memPtr) { return *(const U32*) memPtr; }
-
-#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))
-
-/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
-/* currently only defined for gcc and icc */
-typedef union { U32 u32; } __attribute__((packed)) unalign;
-static U32 XXH_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
-
-#else
-
-/* portable and safe solution. Generally efficient.
- * see : http://stackoverflow.com/a/32095106/646947
- */
-static U32 XXH_read32(const void* memPtr)
-{
-    U32 val;
-    memcpy(&val, memPtr, sizeof(val));
-    return val;
-}
-
-#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */
-
-
-/* ****************************************
-*  Compiler-specific Functions and Macros
-******************************************/
-#define XXH_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-
-/* Note : although _rotl exists for minGW (GCC under windows), performance seems poor */
-#if defined(_MSC_VER)
-#  define XXH_rotl32(x,r) _rotl(x,r)
-#  define XXH_rotl64(x,r) _rotl64(x,r)
-#else
-#  define XXH_rotl32(x,r) ((x << r) | (x >> (32 - r)))
-#  define XXH_rotl64(x,r) ((x << r) | (x >> (64 - r)))
-#endif
-
-#if defined(_MSC_VER)     /* Visual Studio */
-#  define XXH_swap32 _byteswap_ulong
-#elif XXH_GCC_VERSION >= 403
-#  define XXH_swap32 __builtin_bswap32
-#else
-static U32 XXH_swap32 (U32 x)
-{
-    return  ((x << 24) & 0xff000000 ) |
-            ((x <<  8) & 0x00ff0000 ) |
-            ((x >>  8) & 0x0000ff00 ) |
-            ((x >> 24) & 0x000000ff );
-}
-#endif
-
-
-/* *************************************
-*  Architecture Macros
-***************************************/
-typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianness;
-
-/* XXH_CPU_LITTLE_ENDIAN can be defined externally, for example on the compiler command line */
-#ifndef XXH_CPU_LITTLE_ENDIAN
-static int XXH_isLittleEndian(void)
-{
-    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */
-    return one.c[0];
-}
-#   define XXH_CPU_LITTLE_ENDIAN   XXH_isLittleEndian()
-#endif
-
-
-/* ***************************
-*  Memory reads
-*****************************/
-typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;
-
-FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianness endian, XXH_alignment align)
-{
-    if (align==XXH_unaligned)
-        return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));
-    else
-        return endian==XXH_littleEndian ? *(const U32*)ptr : XXH_swap32(*(const U32*)ptr);
-}
-
-FORCE_INLINE U32 XXH_readLE32(const void* ptr, XXH_endianness endian)
-{
-    return XXH_readLE32_align(ptr, endian, XXH_unaligned);
-}
-
-static U32 XXH_readBE32(const void* ptr)
-{
-    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr);
-}
-
-
-/* *************************************
-*  Macros
-***************************************/
-#define XXH_STATIC_ASSERT(c)  { enum { XXH_sa = 1/(int)(!!(c)) }; }  /* use after variable declarations */
-XXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; }
-
-
-/* *******************************************************************
-*  32-bit hash functions
-*********************************************************************/
-static const U32 PRIME32_1 = 2654435761U;
-static const U32 PRIME32_2 = 2246822519U;
-static const U32 PRIME32_3 = 3266489917U;
-static const U32 PRIME32_4 =  668265263U;
-static const U32 PRIME32_5 =  374761393U;
-
-static U32 XXH32_round(U32 seed, U32 input)
-{
-    seed += input * PRIME32_2;
-    seed  = XXH_rotl32(seed, 13);
-    seed *= PRIME32_1;
-    return seed;
-}
-
-/* mix all bits */
-static U32 XXH32_avalanche(U32 h32)
-{
-    h32 ^= h32 >> 15;
-    h32 *= PRIME32_2;
-    h32 ^= h32 >> 13;
-    h32 *= PRIME32_3;
-    h32 ^= h32 >> 16;
-    return(h32);
-}
-
-#define XXH_get32bits(p) XXH_readLE32_align(p, endian, align)
-
-static U32
-XXH32_finalize(U32 h32, const void* ptr, size_t len,
-                XXH_endianness endian, XXH_alignment align)
-
-{
-    const BYTE* p = (const BYTE*)ptr;
-
-#define PROCESS1               \
-    h32 += (*p++) * PRIME32_5; \
-    h32 = XXH_rotl32(h32, 11) * PRIME32_1 ;
-
-#define PROCESS4                         \
-    h32 += XXH_get32bits(p) * PRIME32_3; \
-    p+=4;                                \
-    h32  = XXH_rotl32(h32, 17) * PRIME32_4 ;
-
-    switch(len&15)  /* or switch(bEnd - p) */
-    {
-      case 12:      PROCESS4;
-                    /* fallthrough */
-      case 8:       PROCESS4;
-                    /* fallthrough */
-      case 4:       PROCESS4;
-                    return XXH32_avalanche(h32);
-
-      case 13:      PROCESS4;
-                    /* fallthrough */
-      case 9:       PROCESS4;
-                    /* fallthrough */
-      case 5:       PROCESS4;
-                    PROCESS1;
-                    return XXH32_avalanche(h32);
-
-      case 14:      PROCESS4;
-                    /* fallthrough */
-      case 10:      PROCESS4;
-                    /* fallthrough */
-      case 6:       PROCESS4;
-                    PROCESS1;
-                    PROCESS1;
-                    return XXH32_avalanche(h32);
-
-      case 15:      PROCESS4;
-                    /* fallthrough */
-      case 11:      PROCESS4;
-                    /* fallthrough */
-      case 7:       PROCESS4;
-                    /* fallthrough */
-      case 3:       PROCESS1;
-                    /* fallthrough */
-      case 2:       PROCESS1;
-                    /* fallthrough */
-      case 1:       PROCESS1;
-                    /* fallthrough */
-      case 0:       return XXH32_avalanche(h32);
-    }
-    assert(0);
-    return h32;   /* reaching this point is deemed impossible */
-}
-
-
-FORCE_INLINE U32
-XXH32_endian_align(const void* input, size_t len, U32 seed,
-                    XXH_endianness endian, XXH_alignment align)
-{
-    const BYTE* p = (const BYTE*)input;
-    const BYTE* bEnd = p + len;
-    U32 h32;
-
-#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
-    if (p==NULL) {
-        len=0;
-        bEnd=p=(const BYTE*)(size_t)16;
-    }
-#endif
-
-    if (len>=16) {
-        const BYTE* const limit = bEnd - 15;
-        U32 v1 = seed + PRIME32_1 + PRIME32_2;
-        U32 v2 = seed + PRIME32_2;
-        U32 v3 = seed + 0;
-        U32 v4 = seed - PRIME32_1;
-
-        do {
-            v1 = XXH32_round(v1, XXH_get32bits(p)); p+=4;
-            v2 = XXH32_round(v2, XXH_get32bits(p)); p+=4;
-            v3 = XXH32_round(v3, XXH_get32bits(p)); p+=4;
-            v4 = XXH32_round(v4, XXH_get32bits(p)); p+=4;
-        } while (p < limit);
-
-        h32 = XXH_rotl32(v1, 1)  + XXH_rotl32(v2, 7)
-            + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);
-    } else {
-        h32  = seed + PRIME32_5;
-    }
-
-    h32 += (U32)len;
-
-    return XXH32_finalize(h32, p, len&15, endian, align);
-}
-
-
-XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int seed)
-{
-#if 0
-    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
-    XXH32_state_t state;
-    XXH32_reset(&state, seed);
-    XXH32_update(&state, input, len);
-    return XXH32_digest(&state);
-#else
-    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
-
-    if (XXH_FORCE_ALIGN_CHECK) {
-        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
-            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-                return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
-            else
-                return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
-    }   }
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
-    else
-        return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
-#endif
-}
-
-
-
-/*======   Hash streaming   ======*/
-
-XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)
-{
-    return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));
-}
-XXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)
-{
-    XXH_free(statePtr);
-    return XXH_OK;
-}
-
-XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dstState, const XXH32_state_t* srcState)
-{
-    memcpy(dstState, srcState, sizeof(*dstState));
-}
-
-XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed)
-{
-    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
-    memset(&state, 0, sizeof(state));
-    state.v1 = seed + PRIME32_1 + PRIME32_2;
-    state.v2 = seed + PRIME32_2;
-    state.v3 = seed + 0;
-    state.v4 = seed - PRIME32_1;
-    /* do not write into reserved, planned to be removed in a future version */
-    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
-    return XXH_OK;
-}
-
-
-FORCE_INLINE XXH_errorcode
-XXH32_update_endian(XXH32_state_t* state, const void* input, size_t len, XXH_endianness endian)
-{
-    if (input==NULL)
-#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
-        return XXH_OK;
-#else
-        return XXH_ERROR;
-#endif
-
-    {   const BYTE* p = (const BYTE*)input;
-        const BYTE* const bEnd = p + len;
-
-        state->total_len_32 += (unsigned)len;
-        state->large_len |= (len>=16) | (state->total_len_32>=16);
-
-        if (state->memsize + len < 16)  {   /* fill in tmp buffer */
-            XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, len);
-            state->memsize += (unsigned)len;
-            return XXH_OK;
-        }
-
-        if (state->memsize) {   /* some data left from previous update */
-            XXH_memcpy((BYTE*)(state->mem32) + state->memsize, input, 16-state->memsize);
-            {   const U32* p32 = state->mem32;
-                state->v1 = XXH32_round(state->v1, XXH_readLE32(p32, endian)); p32++;
-                state->v2 = XXH32_round(state->v2, XXH_readLE32(p32, endian)); p32++;
-                state->v3 = XXH32_round(state->v3, XXH_readLE32(p32, endian)); p32++;
-                state->v4 = XXH32_round(state->v4, XXH_readLE32(p32, endian));
-            }
-            p += 16-state->memsize;
-            state->memsize = 0;
-        }
-
-        if (p <= bEnd-16) {
-            const BYTE* const limit = bEnd - 16;
-            U32 v1 = state->v1;
-            U32 v2 = state->v2;
-            U32 v3 = state->v3;
-            U32 v4 = state->v4;
-
-            do {
-                v1 = XXH32_round(v1, XXH_readLE32(p, endian)); p+=4;
-                v2 = XXH32_round(v2, XXH_readLE32(p, endian)); p+=4;
-                v3 = XXH32_round(v3, XXH_readLE32(p, endian)); p+=4;
-                v4 = XXH32_round(v4, XXH_readLE32(p, endian)); p+=4;
-            } while (p<=limit);
-
-            state->v1 = v1;
-            state->v2 = v2;
-            state->v3 = v3;
-            state->v4 = v4;
-        }
-
-        if (p < bEnd) {
-            XXH_memcpy(state->mem32, p, (size_t)(bEnd-p));
-            state->memsize = (unsigned)(bEnd-p);
-        }
-    }
-
-    return XXH_OK;
-}
-
-
-XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void* input, size_t len)
-{
-    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH32_update_endian(state_in, input, len, XXH_littleEndian);
-    else
-        return XXH32_update_endian(state_in, input, len, XXH_bigEndian);
-}
-
-
-FORCE_INLINE U32
-XXH32_digest_endian (const XXH32_state_t* state, XXH_endianness endian)
-{
-    U32 h32;
-
-    if (state->large_len) {
-        h32 = XXH_rotl32(state->v1, 1)
-            + XXH_rotl32(state->v2, 7)
-            + XXH_rotl32(state->v3, 12)
-            + XXH_rotl32(state->v4, 18);
-    } else {
-        h32 = state->v3 /* == seed */ + PRIME32_5;
-    }
-
-    h32 += state->total_len_32;
-
-    return XXH32_finalize(h32, state->mem32, state->memsize, endian, XXH_aligned);
-}
-
-
-XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in)
-{
-    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH32_digest_endian(state_in, XXH_littleEndian);
-    else
-        return XXH32_digest_endian(state_in, XXH_bigEndian);
-}
-
-
-/*======   Canonical representation   ======*/
-
-/*! Default XXH result types are basic unsigned 32 and 64 bits.
-*   The canonical representation follows human-readable write convention, aka big-endian (large digits first).
-*   These functions allow transformation of hash result into and from its canonical format.
-*   This way, hash values can be written into a file or buffer, remaining comparable across different systems.
-*/
-
-XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash)
-{
-    XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t));
-    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);
-    memcpy(dst, &hash, sizeof(*dst));
-}
-
-XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src)
-{
-    return XXH_readBE32(src);
-}
-
-
-#ifndef XXH_NO_LONG_LONG
-
-/* *******************************************************************
-*  64-bit hash functions
-*********************************************************************/
-
-/*======   Memory access   ======*/
-
-#ifndef MEM_MODULE
-# define MEM_MODULE
-# if !defined (__VMS) \
-  && (defined (__cplusplus) \
-  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
-#   include <stdint.h>
-    typedef uint64_t U64;
-# else
-    /* if compiler doesn't support unsigned long long, replace by another 64-bit type */
-    typedef unsigned long long U64;
-# endif
-#endif
-
-
-#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))
-
-/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */
-static U64 XXH_read64(const void* memPtr) { return *(const U64*) memPtr; }
-
-#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))
-
-/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
-/* currently only defined for gcc and icc */
-typedef union { U32 u32; U64 u64; } __attribute__((packed)) unalign64;
-static U64 XXH_read64(const void* ptr) { return ((const unalign64*)ptr)->u64; }
-
-#else
-
-/* portable and safe solution. Generally efficient.
- * see : http://stackoverflow.com/a/32095106/646947
- */
-
-static U64 XXH_read64(const void* memPtr)
-{
-    U64 val;
-    memcpy(&val, memPtr, sizeof(val));
-    return val;
-}
-
-#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */
-
-#if defined(_MSC_VER)     /* Visual Studio */
-#  define XXH_swap64 _byteswap_uint64
-#elif XXH_GCC_VERSION >= 403
-#  define XXH_swap64 __builtin_bswap64
-#else
-static U64 XXH_swap64 (U64 x)
-{
-    return  ((x << 56) & 0xff00000000000000ULL) |
-            ((x << 40) & 0x00ff000000000000ULL) |
-            ((x << 24) & 0x0000ff0000000000ULL) |
-            ((x << 8)  & 0x000000ff00000000ULL) |
-            ((x >> 8)  & 0x00000000ff000000ULL) |
-            ((x >> 24) & 0x0000000000ff0000ULL) |
-            ((x >> 40) & 0x000000000000ff00ULL) |
-            ((x >> 56) & 0x00000000000000ffULL);
-}
-#endif
-
-FORCE_INLINE U64 XXH_readLE64_align(const void* ptr, XXH_endianness endian, XXH_alignment align)
-{
-    if (align==XXH_unaligned)
-        return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));
-    else
-        return endian==XXH_littleEndian ? *(const U64*)ptr : XXH_swap64(*(const U64*)ptr);
-}
-
-FORCE_INLINE U64 XXH_readLE64(const void* ptr, XXH_endianness endian)
-{
-    return XXH_readLE64_align(ptr, endian, XXH_unaligned);
-}
-
-static U64 XXH_readBE64(const void* ptr)
-{
-    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr);
-}
-
-
-/*======   xxh64   ======*/
-
-static const U64 PRIME64_1 = 11400714785074694791ULL;
-static const U64 PRIME64_2 = 14029467366897019727ULL;
-static const U64 PRIME64_3 =  1609587929392839161ULL;
-static const U64 PRIME64_4 =  9650029242287828579ULL;
-static const U64 PRIME64_5 =  2870177450012600261ULL;
-
-static U64 XXH64_round(U64 acc, U64 input)
-{
-    acc += input * PRIME64_2;
-    acc  = XXH_rotl64(acc, 31);
-    acc *= PRIME64_1;
-    return acc;
-}
-
-static U64 XXH64_mergeRound(U64 acc, U64 val)
-{
-    val  = XXH64_round(0, val);
-    acc ^= val;
-    acc  = acc * PRIME64_1 + PRIME64_4;
-    return acc;
-}
-
-static U64 XXH64_avalanche(U64 h64)
-{
-    h64 ^= h64 >> 33;
-    h64 *= PRIME64_2;
-    h64 ^= h64 >> 29;
-    h64 *= PRIME64_3;
-    h64 ^= h64 >> 32;
-    return h64;
-}
-
-
-#define XXH_get64bits(p) XXH_readLE64_align(p, endian, align)
-
-static U64
-XXH64_finalize(U64 h64, const void* ptr, size_t len,
-               XXH_endianness endian, XXH_alignment align)
-{
-    const BYTE* p = (const BYTE*)ptr;
-
-#define PROCESS1_64            \
-    h64 ^= (*p++) * PRIME64_5; \
-    h64 = XXH_rotl64(h64, 11) * PRIME64_1;
-
-#define PROCESS4_64          \
-    h64 ^= (U64)(XXH_get32bits(p)) * PRIME64_1; \
-    p+=4;                    \
-    h64 = XXH_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;
-
-#define PROCESS8_64 {        \
-    U64 const k1 = XXH64_round(0, XXH_get64bits(p)); \
-    p+=8;                    \
-    h64 ^= k1;               \
-    h64  = XXH_rotl64(h64,27) * PRIME64_1 + PRIME64_4; \
-}
-
-    switch(len&31) {
-      case 24: PROCESS8_64;
-                    /* fallthrough */
-      case 16: PROCESS8_64;
-                    /* fallthrough */
-      case  8: PROCESS8_64;
-               return XXH64_avalanche(h64);
-
-      case 28: PROCESS8_64;
-                    /* fallthrough */
-      case 20: PROCESS8_64;
-                    /* fallthrough */
-      case 12: PROCESS8_64;
-                    /* fallthrough */
-      case  4: PROCESS4_64;
-               return XXH64_avalanche(h64);
-
-      case 25: PROCESS8_64;
-                    /* fallthrough */
-      case 17: PROCESS8_64;
-                    /* fallthrough */
-      case  9: PROCESS8_64;
-               PROCESS1_64;
-               return XXH64_avalanche(h64);
-
-      case 29: PROCESS8_64;
-                    /* fallthrough */
-      case 21: PROCESS8_64;
-                    /* fallthrough */
-      case 13: PROCESS8_64;
-                    /* fallthrough */
-      case  5: PROCESS4_64;
-               PROCESS1_64;
-               return XXH64_avalanche(h64);
-
-      case 26: PROCESS8_64;
-                    /* fallthrough */
-      case 18: PROCESS8_64;
-                    /* fallthrough */
-      case 10: PROCESS8_64;
-               PROCESS1_64;
-               PROCESS1_64;
-               return XXH64_avalanche(h64);
-
-      case 30: PROCESS8_64;
-                    /* fallthrough */
-      case 22: PROCESS8_64;
-                    /* fallthrough */
-      case 14: PROCESS8_64;
-                    /* fallthrough */
-      case  6: PROCESS4_64;
-               PROCESS1_64;
-               PROCESS1_64;
-               return XXH64_avalanche(h64);
-
-      case 27: PROCESS8_64;
-                    /* fallthrough */
-      case 19: PROCESS8_64;
-                    /* fallthrough */
-      case 11: PROCESS8_64;
-               PROCESS1_64;
-               PROCESS1_64;
-               PROCESS1_64;
-               return XXH64_avalanche(h64);
-
-      case 31: PROCESS8_64;
-                    /* fallthrough */
-      case 23: PROCESS8_64;
-                    /* fallthrough */
-      case 15: PROCESS8_64;
-                    /* fallthrough */
-      case  7: PROCESS4_64;
-                    /* fallthrough */
-      case  3: PROCESS1_64;
-                    /* fallthrough */
-      case  2: PROCESS1_64;
-                    /* fallthrough */
-      case  1: PROCESS1_64;
-                    /* fallthrough */
-      case  0: return XXH64_avalanche(h64);
-    }
-
-    /* impossible to reach */
-    assert(0);
-    return 0;  /* unreachable, but some compilers complain without it */
-}
-
-FORCE_INLINE U64
-XXH64_endian_align(const void* input, size_t len, U64 seed,
-                XXH_endianness endian, XXH_alignment align)
-{
-    const BYTE* p = (const BYTE*)input;
-    const BYTE* bEnd = p + len;
-    U64 h64;
-
-#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
-    if (p==NULL) {
-        len=0;
-        bEnd=p=(const BYTE*)(size_t)32;
-    }
-#endif
-
-    if (len>=32) {
-        const BYTE* const limit = bEnd - 32;
-        U64 v1 = seed + PRIME64_1 + PRIME64_2;
-        U64 v2 = seed + PRIME64_2;
-        U64 v3 = seed + 0;
-        U64 v4 = seed - PRIME64_1;
-
-        do {
-            v1 = XXH64_round(v1, XXH_get64bits(p)); p+=8;
-            v2 = XXH64_round(v2, XXH_get64bits(p)); p+=8;
-            v3 = XXH64_round(v3, XXH_get64bits(p)); p+=8;
-            v4 = XXH64_round(v4, XXH_get64bits(p)); p+=8;
-        } while (p<=limit);
-
-        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
-        h64 = XXH64_mergeRound(h64, v1);
-        h64 = XXH64_mergeRound(h64, v2);
-        h64 = XXH64_mergeRound(h64, v3);
-        h64 = XXH64_mergeRound(h64, v4);
-
-    } else {
-        h64  = seed + PRIME64_5;
-    }
-
-    h64 += (U64) len;
-
-    return XXH64_finalize(h64, p, len, endian, align);
-}
-
-
-XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed)
-{
-#if 0
-    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
-    XXH64_state_t state;
-    XXH64_reset(&state, seed);
-    XXH64_update(&state, input, len);
-    return XXH64_digest(&state);
-#else
-    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
-
-    if (XXH_FORCE_ALIGN_CHECK) {
-        if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */
-            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-                return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
-            else
-                return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
-    }   }
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
-    else
-        return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
-#endif
-}
-
-/*======   Hash Streaming   ======*/
-
-XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)
-{
-    return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));
-}
-XXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)
-{
-    XXH_free(statePtr);
-    return XXH_OK;
-}
-
-XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dstState, const XXH64_state_t* srcState)
-{
-    memcpy(dstState, srcState, sizeof(*dstState));
-}
-
-XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed)
-{
-    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
-    memset(&state, 0, sizeof(state));
-    state.v1 = seed + PRIME64_1 + PRIME64_2;
-    state.v2 = seed + PRIME64_2;
-    state.v3 = seed + 0;
-    state.v4 = seed - PRIME64_1;
-     /* do not write into reserved, planned to be removed in a future version */
-    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
-    return XXH_OK;
-}
-
-FORCE_INLINE XXH_errorcode
-XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianness endian)
-{
-    if (input==NULL)
-#if defined(XXH_ACCEPT_NULL_INPUT_POINTER) && (XXH_ACCEPT_NULL_INPUT_POINTER>=1)
-        return XXH_OK;
-#else
-        return XXH_ERROR;
-#endif
-
-    {   const BYTE* p = (const BYTE*)input;
-        const BYTE* const bEnd = p + len;
-
-        state->total_len += len;
-
-        if (state->memsize + len < 32) {  /* fill in tmp buffer */
-            XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, len);
-            state->memsize += (U32)len;
-            return XXH_OK;
-        }
-
-        if (state->memsize) {   /* tmp buffer is full */
-            XXH_memcpy(((BYTE*)state->mem64) + state->memsize, input, 32-state->memsize);
-            state->v1 = XXH64_round(state->v1, XXH_readLE64(state->mem64+0, endian));
-            state->v2 = XXH64_round(state->v2, XXH_readLE64(state->mem64+1, endian));
-            state->v3 = XXH64_round(state->v3, XXH_readLE64(state->mem64+2, endian));
-            state->v4 = XXH64_round(state->v4, XXH_readLE64(state->mem64+3, endian));
-            p += 32-state->memsize;
-            state->memsize = 0;
-        }
-
-        if (p+32 <= bEnd) {
-            const BYTE* const limit = bEnd - 32;
-            U64 v1 = state->v1;
-            U64 v2 = state->v2;
-            U64 v3 = state->v3;
-            U64 v4 = state->v4;
-
-            do {
-                v1 = XXH64_round(v1, XXH_readLE64(p, endian)); p+=8;
-                v2 = XXH64_round(v2, XXH_readLE64(p, endian)); p+=8;
-                v3 = XXH64_round(v3, XXH_readLE64(p, endian)); p+=8;
-                v4 = XXH64_round(v4, XXH_readLE64(p, endian)); p+=8;
-            } while (p<=limit);
-
-            state->v1 = v1;
-            state->v2 = v2;
-            state->v3 = v3;
-            state->v4 = v4;
-        }
-
-        if (p < bEnd) {
-            XXH_memcpy(state->mem64, p, (size_t)(bEnd-p));
-            state->memsize = (unsigned)(bEnd-p);
-        }
-    }
-
-    return XXH_OK;
-}
-
-XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len)
-{
-    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH64_update_endian(state_in, input, len, XXH_littleEndian);
-    else
-        return XXH64_update_endian(state_in, input, len, XXH_bigEndian);
-}
-
-FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianness endian)
-{
-    U64 h64;
-
-    if (state->total_len >= 32) {
-        U64 const v1 = state->v1;
-        U64 const v2 = state->v2;
-        U64 const v3 = state->v3;
-        U64 const v4 = state->v4;
-
-        h64 = XXH_rotl64(v1, 1) + XXH_rotl64(v2, 7) + XXH_rotl64(v3, 12) + XXH_rotl64(v4, 18);
-        h64 = XXH64_mergeRound(h64, v1);
-        h64 = XXH64_mergeRound(h64, v2);
-        h64 = XXH64_mergeRound(h64, v3);
-        h64 = XXH64_mergeRound(h64, v4);
-    } else {
-        h64  = state->v3 /*seed*/ + PRIME64_5;
-    }
-
-    h64 += (U64) state->total_len;
-
-    return XXH64_finalize(h64, state->mem64, (size_t)state->total_len, endian, XXH_aligned);
-}
-
-XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in)
-{
-    XXH_endianness endian_detected = (XXH_endianness)XXH_CPU_LITTLE_ENDIAN;
-
-    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
-        return XXH64_digest_endian(state_in, XXH_littleEndian);
-    else
-        return XXH64_digest_endian(state_in, XXH_bigEndian);
-}
-
-
-/*====== Canonical representation   ======*/
-
-XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash)
-{
-    XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));
-    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);
-    memcpy(dst, &hash, sizeof(*dst));
-}
-
-XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src)
-{
-    return XXH_readBE64(src);
-}
-
-#endif  /* XXH_NO_LONG_LONG */
diff --git a/native/lz4/vendor/lib/xxhash.h b/native/lz4/vendor/lib/xxhash.h
deleted file mode 100644
index d6bad94..0000000
--- a/native/lz4/vendor/lib/xxhash.h
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
-   xxHash - Extremely Fast Hash algorithm
-   Header File
-   Copyright (C) 2012-2016, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-   - xxHash source repository : https://github.com/Cyan4973/xxHash
-*/
-
-/* Notice extracted from xxHash homepage :
-
-xxHash is an extremely fast Hash algorithm, running at RAM speed limits.
-It also successfully passes all tests from the SMHasher suite.
-
-Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)
-
-Name            Speed       Q.Score   Author
-xxHash          5.4 GB/s     10
-CrapWow         3.2 GB/s      2       Andrew
-MumurHash 3a    2.7 GB/s     10       Austin Appleby
-SpookyHash      2.0 GB/s     10       Bob Jenkins
-SBox            1.4 GB/s      9       Bret Mulvey
-Lookup3         1.2 GB/s      9       Bob Jenkins
-SuperFastHash   1.2 GB/s      1       Paul Hsieh
-CityHash64      1.05 GB/s    10       Pike & Alakuijala
-FNV             0.55 GB/s     5       Fowler, Noll, Vo
-CRC32           0.43 GB/s     9
-MD5-32          0.33 GB/s    10       Ronald L. Rivest
-SHA1-32         0.28 GB/s    10
-
-Q.Score is a measure of quality of the hash function.
-It depends on successfully passing SMHasher test set.
-10 is a perfect score.
-
-A 64-bit version, named XXH64, is available since r35.
-It offers much better speed, but for 64-bit applications only.
-Name     Speed on 64 bits    Speed on 32 bits
-XXH64       13.8 GB/s            1.9 GB/s
-XXH32        6.8 GB/s            6.0 GB/s
-*/
-
-#ifndef XXHASH_H_5627135585666179
-#define XXHASH_H_5627135585666179 1
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-/* ****************************
-*  Definitions
-******************************/
-#include <stddef.h>   /* size_t */
-typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
-
-
-/* ****************************
- *  API modifier
- ******************************/
-/** XXH_INLINE_ALL (and XXH_PRIVATE_API)
- *  This is useful to include xxhash functions in `static` mode
- *  in order to inline them, and remove their symbol from the public list.
- *  Inlining can offer dramatic performance improvement on small keys.
- *  Methodology :
- *     #define XXH_INLINE_ALL
- *     #include "xxhash.h"
- * `xxhash.c` is automatically included.
- *  It's not useful to compile and link it as a separate module.
- */
-#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
-#  ifndef XXH_STATIC_LINKING_ONLY
-#    define XXH_STATIC_LINKING_ONLY
-#  endif
-#  if defined(__GNUC__)
-#    define XXH_PUBLIC_API static __inline __attribute__((unused))
-#  elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-#    define XXH_PUBLIC_API static inline
-#  elif defined(_MSC_VER)
-#    define XXH_PUBLIC_API static __inline
-#  else
-     /* this version may generate warnings for unused static functions */
-#    define XXH_PUBLIC_API static
-#  endif
-#else
-#  define XXH_PUBLIC_API   /* do nothing */
-#endif /* XXH_INLINE_ALL || XXH_PRIVATE_API */
-
-/*! XXH_NAMESPACE, aka Namespace Emulation :
- *
- * If you want to include _and expose_ xxHash functions from within your own library,
- * but also want to avoid symbol collisions with other libraries which may also include xxHash,
- *
- * you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library
- * with the value of XXH_NAMESPACE (therefore, avoid NULL and numeric values).
- *
- * Note that no change is required within the calling program as long as it includes `xxhash.h` :
- * regular symbol name will be automatically translated by this header.
- */
-#ifdef XXH_NAMESPACE
-#  define XXH_CAT(A,B) A##B
-#  define XXH_NAME2(A,B) XXH_CAT(A,B)
-#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)
-#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)
-#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)
-#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)
-#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)
-#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)
-#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)
-#  define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)
-#  define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)
-#  define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)
-#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)
-#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)
-#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)
-#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)
-#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)
-#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)
-#  define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)
-#  define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)
-#  define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)
-#endif
-
-
-/* *************************************
-*  Version
-***************************************/
-#define XXH_VERSION_MAJOR    0
-#define XXH_VERSION_MINOR    6
-#define XXH_VERSION_RELEASE  5
-#define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
-XXH_PUBLIC_API unsigned XXH_versionNumber (void);
-
-
-/*-**********************************************************************
-*  32-bit hash
-************************************************************************/
-typedef unsigned int XXH32_hash_t;
-
-/*! XXH32() :
-    Calculate the 32-bit hash of sequence "length" bytes stored at memory address "input".
-    The memory between input & input+length must be valid (allocated and read-accessible).
-    "seed" can be used to alter the result predictably.
-    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s */
-XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed);
-
-/*======   Streaming   ======*/
-typedef struct XXH32_state_s XXH32_state_t;   /* incomplete type */
-XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
-XXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
-XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dst_state, const XXH32_state_t* src_state);
-
-XXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, unsigned int seed);
-XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
-XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr);
-
-/*
- * Streaming functions generate the xxHash of an input provided in multiple segments.
- * Note that, for small input, they are slower than single-call functions, due to state management.
- * For small inputs, prefer `XXH32()` and `XXH64()`, which are better optimized.
- *
- * XXH state must first be allocated, using XXH*_createState() .
- *
- * Start a new hash by initializing state with a seed, using XXH*_reset().
- *
- * Then, feed the hash state by calling XXH*_update() as many times as necessary.
- * The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
- *
- * Finally, a hash value can be produced anytime, by using XXH*_digest().
- * This function returns the nn-bits hash as an int or long long.
- *
- * It's still possible to continue inserting input into the hash state after a digest,
- * and generate some new hashes later on, by calling again XXH*_digest().
- *
- * When done, free XXH state space if it was allocated dynamically.
- */
-
-/*======   Canonical representation   ======*/
-
-typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
-XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);
-XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
-
-/* Default result type for XXH functions are primitive unsigned 32 and 64 bits.
- * The canonical representation uses human-readable write convention, aka big-endian (large digits first).
- * These functions allow transformation of hash result into and from its canonical format.
- * This way, hash values can be written into a file / memory, and remain comparable on different systems and programs.
- */
-
-
-#ifndef XXH_NO_LONG_LONG
-/*-**********************************************************************
-*  64-bit hash
-************************************************************************/
-typedef unsigned long long XXH64_hash_t;
-
-/*! XXH64() :
-    Calculate the 64-bit hash of sequence of length "len" stored at memory address "input".
-    "seed" can be used to alter the result predictably.
-    This function runs faster on 64-bit systems, but slower on 32-bit systems (see benchmark).
-*/
-XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed);
-
-/*======   Streaming   ======*/
-typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */
-XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
-XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
-XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state);
-
-XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, unsigned long long seed);
-XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
-XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr);
-
-/*======   Canonical representation   ======*/
-typedef struct { unsigned char digest[8]; } XXH64_canonical_t;
-XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
-XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
-#endif  /* XXH_NO_LONG_LONG */
-
-
-
-#ifdef XXH_STATIC_LINKING_ONLY
-
-/* ================================================================================================
-   This section contains declarations which are not guaranteed to remain stable.
-   They may change in future versions, becoming incompatible with a different version of the library.
-   These declarations should only be used with static linking.
-   Never use them in association with dynamic linking !
-=================================================================================================== */
-
-/* These definitions are only present to allow
- * static allocation of XXH state, on stack or in a struct for example.
- * Never **ever** use members directly. */
-
-#if !defined (__VMS) \
-  && (defined (__cplusplus) \
-  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
-#   include <stdint.h>
-
-struct XXH32_state_s {
-   uint32_t total_len_32;
-   uint32_t large_len;
-   uint32_t v1;
-   uint32_t v2;
-   uint32_t v3;
-   uint32_t v4;
-   uint32_t mem32[4];
-   uint32_t memsize;
-   uint32_t reserved;   /* never read nor write, might be removed in a future version */
-};   /* typedef'd to XXH32_state_t */
-
-struct XXH64_state_s {
-   uint64_t total_len;
-   uint64_t v1;
-   uint64_t v2;
-   uint64_t v3;
-   uint64_t v4;
-   uint64_t mem64[4];
-   uint32_t memsize;
-   uint32_t reserved[2];          /* never read nor write, might be removed in a future version */
-};   /* typedef'd to XXH64_state_t */
-
-# else
-
-struct XXH32_state_s {
-   unsigned total_len_32;
-   unsigned large_len;
-   unsigned v1;
-   unsigned v2;
-   unsigned v3;
-   unsigned v4;
-   unsigned mem32[4];
-   unsigned memsize;
-   unsigned reserved;   /* never read nor write, might be removed in a future version */
-};   /* typedef'd to XXH32_state_t */
-
-#   ifndef XXH_NO_LONG_LONG  /* remove 64-bit support */
-struct XXH64_state_s {
-   unsigned long long total_len;
-   unsigned long long v1;
-   unsigned long long v2;
-   unsigned long long v3;
-   unsigned long long v4;
-   unsigned long long mem64[4];
-   unsigned memsize;
-   unsigned reserved[2];     /* never read nor write, might be removed in a future version */
-};   /* typedef'd to XXH64_state_t */
-#    endif
-
-# endif
-
-
-#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
-#  include "xxhash.c"   /* include xxhash function bodies as `static`, for inlining */
-#endif
-
-#endif /* XXH_STATIC_LINKING_ONLY */
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* XXHASH_H_5627135585666179 */
diff --git a/native/zucchini/README.md b/native/zucchini/README.md
deleted file mode 100644
index 55d6a60..0000000
--- a/native/zucchini/README.md
+++ /dev/null
@@ -1,89 +0,0 @@
-# Zucchini native boundary
-
-This directory contains the audited apply-only closure used by `otadump` on Linux x86_64.
-It does not contain either complete upstream repository, patch generators, command-line tools, tests, binaries, or object files.
-
-## Source pins
-
-- AOSP `external/zucchini`: `e256025d9d9c906caba814fd7b99a311ac8b8ec1`
-- AOSP `external/libchrome`: `0aba0dccfcd93d8303678a4beb61594f7582c73c`
-
-`SOURCE_INVENTORY.sha256` lists every vendored file and its digest.
-The apply closure contains these upstream Zucchini translation units:
-
-```text
-abs32_utils.cc
-address_translator.cc
-arm_utils.cc
-buffer_source.cc
-crc32.cc
-disassembler.cc
-disassembler_dex.cc
-disassembler_elf.cc
-disassembler_no_op.cc
-element_detection.cc
-equivalence_map.cc
-patch_reader.cc
-rel32_finder.cc
-rel32_utils.cc
-reloc_elf.cc
-target_pool.cc
-zucchini_apply.cc
-```
-
-It contains these upstream libchrome translation units:
-
-```text
-base/at_exit.cc
-base/callback_internal.cc
-base/debug/activity_tracker.cc
-base/debug/alias.cc
-base/debug/debugger_posix.cc
-base/debug/stack_trace.cc
-base/debug/stack_trace_posix.cc
-base/lazy_instance_helpers.cc
-base/location.cc
-base/logging.cc
-base/metrics/persistent_memory_allocator.cc
-base/strings/string_piece.cc
-base/strings/stringprintf.cc
-base/strings/string_util.cc
-base/synchronization/lock_impl_posix.cc
-base/threading/platform_thread_posix.cc
-base/threading/thread_local_storage.cc
-base/time/time.cc
-base/time/time_now_posix.cc
-```
-
-Headers in the inventory are the compiler-reported transitive header closure for these units and the FFI wrapper.
-
-## Build configuration
-
-`build.rs` uses `cc` with the audited release configuration:
-
-```text
--std=c++17 -O2 -DNDEBUG -DOFFICIAL_BUILD -D__ANDROID_HOST__
--DDONT_EMBED_BUILD_METADATA -ffunction-sections -fdata-sections
--fno-exceptions -fno-rtti
-```
-
-The generated `include/components/zucchini/buildflags.h` is copied from the pinned Android build.
-It enables DEX and ELF and disables Win32 and ZTF.
-`include/gtest/gtest_prod.h` is a declaration-only generated-header substitute used by the proof.
-The build links the native C++ and GCC support archives statically.
-Rust's Linux GNU target still links its baseline `libgcc_s.so.1`, as an empty Rust binary does, and retains dynamic glibc.
-
-## Local boundary code
-
-`src/zucchini_ffi.cc` and `src/zucchini_ffi.h` started as the project-owned Milestone 5a proof boundary.
-The local copy changes the exported prefix from `zucchini_proof` to `otadump_zucchini`.
-It also extends the audited DEX preflight to allow more than 65,536 strings.
-The extension resolves each reference delta without writing and rejects any `const-string` 16-bit writer target above index 65,535 before upstream apply can reach its checked narrowing cast.
-The 32-bit and jumbo writers retain the full DEX string range.
-
-## License notices
-
-The Zucchini sources use the BSD-style license in `vendor/zucchini/LICENSE` and retain `vendor/zucchini/MODULE_LICENSE_CHROME`.
-The libchrome sources retain `vendor/libchrome/NOTICE` and `vendor/libchrome/MODULE_LICENSE_BSD`.
-The copied ICU declarations retain `vendor/libchrome/base/third_party/icu/LICENSE`.
-The copied NSPR declarations retain their tri-license notice in `vendor/libchrome/base/third_party/nspr/LICENSE` and the canonical full MPL 1.1 text in `vendor/libchrome/base/third_party/nspr/MPL-1.1.txt`.
diff --git a/native/zucchini/SOURCE_INVENTORY.sha256 b/native/zucchini/SOURCE_INVENTORY.sha256
deleted file mode 100644
index cdecc7d..0000000
--- a/native/zucchini/SOURCE_INVENTORY.sha256
+++ /dev/null
@@ -1,216 +0,0 @@
-b518d60f01ff369072d4c538af21735c7eadf1e7b4da6672b9d97747cdd90aee  ./README.md
-46910208394401b1554d4d7f72a29321825a69f56d652757416df82d233fc1ca  ./include/components/zucchini/buildflags.h
-c70eca6f124dd593ae6315bc4576e7d740776614248302e176bd4facd3fd8f46  ./include/gtest/gtest_prod.h
-525112dc60b8361681d6977a74b8a07d06e20fb266ef412e4a11e1a113068fb2  ./src/zucchini_ffi.cc
-11696b3b8d3dc920e2375d98fd95028cd32c6c1ea86b082d6f800e00fb357703  ./src/zucchini_ffi.h
-e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  ./vendor/libchrome/MODULE_LICENSE_BSD
-7a209dd1b94cabdb5ea9c6f9164b9546ffa5daaa671e7767d49510db055f5c51  ./vendor/libchrome/NOTICE
-7eea8279dea1533467acb0e6b21e7506843c75540455b79a1fb08be6b4ffa999  ./vendor/libchrome/base/at_exit.cc
-ab949b0cff351bb03783efae73468610a26ef4ae4dcce130a91777df9ea87c16  ./vendor/libchrome/base/at_exit.h
-95925ae1ec4daff96d8233d4c0a95405481542b50d58d33cafc2f46dce121e52  ./vendor/libchrome/base/atomic_ref_count.h
-ff55aafc7cdfd61ce5fd0f3fdd3deadcfe651171a195984bf2ecef7a6ee51e7e  ./vendor/libchrome/base/atomic_sequence_num.h
-e11cc9ca44c0d03b7fe7bbb75251f8946f2ff0faec7c34f93784d5bbca41a9af  ./vendor/libchrome/base/atomicops.h
-66aba23e522d58c43a150bf5b4d27c9fe568518a498ef36e8686bd6ad606ee50  ./vendor/libchrome/base/atomicops_internals_portable.h
-a115f8bb46d074a4c882b7ba45d3b9d63b89db80b81c48e334e7da3d31e1b24a  ./vendor/libchrome/base/base_export.h
-fcaf8cb6e8d7e8844d53e8a79152d313ff7d1fb2faa4bad867a7d629855ba9a0  ./vendor/libchrome/base/base_switches.h
-0a5c281222b7ed05e208bb255ec597c6386314d02e57b8f7f871dc9445e9dcc4  ./vendor/libchrome/base/bind.h
-3e9d5557534a399d69813cab3bc2b41a7c68a4ea2a9c868979576fcf05933414  ./vendor/libchrome/base/bind_internal.h
-14acefaa5942c15a522d943d88422e8f1d6e861998248ed2654b303752434ebf  ./vendor/libchrome/base/callback.h
-6a3fe03450edca7552622704220e7bfd8b7455b8898e84b0d4c68fda7a8492f3  ./vendor/libchrome/base/callback_forward.h
-1f6dd284ea3299ef73ddd1a6c1adc8b83c7192a36cb48ca747a364cba837f533  ./vendor/libchrome/base/callback_helpers.h
-0f2c1cbf003f898f298a74ac9c247d52a8b825e2d6d0f251155e43be8f297c2b  ./vendor/libchrome/base/callback_internal.cc
-f43005e3ae91bc78a6493b7f0ba9e41603bd2c4e5cf079d7f4a3075ccf9e0911  ./vendor/libchrome/base/callback_internal.h
-763e91c9dc45aed5f350df32ec0f2ada535e9d36f7e28c9924fa02dcf07e28d4  ./vendor/libchrome/base/cfi_buildflags.h
-6256e005c8a1d0a3af1038064b851feacd021605e0017c0e3481512e279c6804  ./vendor/libchrome/base/command_line.h
-ddf87b6d8ada67f84b3032ee303ae67f3cac666303e532930af7eb64818fc88f  ./vendor/libchrome/base/compiler_specific.h
-16be70435e9ea50e74da48e11f40cbddd8d9a508a8ba5ee86fa611b6ed81f183  ./vendor/libchrome/base/containers/circular_deque.h
-4d1d402d9b199e292d06dad9ef9fcfdd453d8e6ba6f93c9b305d7e4cc4d7ac06  ./vendor/libchrome/base/containers/queue.h
-8b290149ae390c707d5120690b5f7dc016325276ff83e3231fb31e62de5543ca  ./vendor/libchrome/base/containers/span.h
-d524a463cc85d6c3359d79cd2d8e619ba4894b1820930296115c8685cf8a0615  ./vendor/libchrome/base/containers/stack.h
-2095c72078ff48d5cd31fb16f8c131c4b037ba8afdf42e01c21358b069dbd5a3  ./vendor/libchrome/base/containers/vector_buffer.h
-5248ace2637fd8a66e235de1e0eec6371b5f5036f360105bccf3c0e824f6ab04  ./vendor/libchrome/base/debug/activity_tracker.cc
-660e2682919377aef71bd26189022d665583dcaeff1933666ae82d0dedb2cc22  ./vendor/libchrome/base/debug/activity_tracker.h
-7e60b2250a92dddad5c0aff52d0ba7d8988e1662549943334604b6120d4710f9  ./vendor/libchrome/base/debug/alias.cc
-19d038abbeb20294dae3dd7bee5f17ec166d981c45e664a3d627a930f860d479  ./vendor/libchrome/base/debug/alias.h
-384808eaf4c764a17104d7e42d28ebed58ded5c06cfc1d618e673c4a44959978  ./vendor/libchrome/base/debug/debugger.h
-5e7ccee5d6abf15827f1bbb054528af3d3ad105f8bf517ef8d06671bdf913414  ./vendor/libchrome/base/debug/debugger_posix.cc
-ef306a4df95ee2e7325dfe59ad00b8f328a5f4a6a83cef95295a7ad32ef9af9c  ./vendor/libchrome/base/debug/debugging_buildflags.h
-577cc68c01e8fc3195301091d0dea125358d3d1012a735480fa965a79f2775c6  ./vendor/libchrome/base/debug/leak_annotations.h
-c0a70a2d084504e5995ced489c99b27699aae553982934a4a8bf45310c86ba31  ./vendor/libchrome/base/debug/proc_maps_linux.h
-abbad5021abe5d0610cd527a1c32fbf21ca66b387d66de25eb2754f6cdab8dad  ./vendor/libchrome/base/debug/stack_trace.cc
-8983e7f6cef3edcf2e61b8dfa1f3ef59801f6ce921967718164b955ef0a1c3be  ./vendor/libchrome/base/debug/stack_trace.h
-509ccef03a82f241e79dc5eb697c274a099c41459494bc4192cb2c9a33a71e0f  ./vendor/libchrome/base/debug/stack_trace_posix.cc
-6f1023488e5778f8918240f820a21822995a52bd33e122ad559a06aeb099f9b6  ./vendor/libchrome/base/environment.h
-6847915693d962edb7c003221ef28c463b38450fc4fb0778d6ee42ee5b4e392a  ./vendor/libchrome/base/feature_list.h
-898df95516fd3d653460682a50bac033bd634211007e1aa26522db31993c2425  ./vendor/libchrome/base/file_descriptor_posix.h
-6331fcdf07251dd8ff20df9b0b63cc356d9e65b15fae4f0ffd37dc8d865dc21b  ./vendor/libchrome/base/files/file.h
-abd100566d3872fdb06542f9eba167b825b3dd716969769125d2219152535b49  ./vendor/libchrome/base/files/file_path.h
-1edbaf0012fac3c3b0b7750548a400c82ddcb8303fa3e2a0ef1cbec4fc7706e0  ./vendor/libchrome/base/files/file_tracing.h
-98e9466692904f0201b6d3ce9ed1655b7a8e7fb9b4fac7794bd9c17823b44038  ./vendor/libchrome/base/files/file_util.h
-2c8211841884991837e1f674e9e472e5ce2e33d3a00f3d0e282fd6310d05a140  ./vendor/libchrome/base/files/memory_mapped_file.h
-356a0860f98e07c65fb55bab6c1358ce798deeb0926f36c6366d8ce2d50725ae  ./vendor/libchrome/base/files/platform_file.h
-4bc310531e4c3a0ef738451c12c1c2c8075b2d3b578ca769687f86f28ca82c3c  ./vendor/libchrome/base/files/scoped_file.h
-c7867f094c7341c1908171982cac96da60a4e8ff636d565bd41f38f331bee0b7  ./vendor/libchrome/base/format_macros.h
-39f1ed8adf4d8c130ccf26985fc9e248d50810231d1f337fdcc2fd23cb5c2841  ./vendor/libchrome/base/gtest_prod_util.h
-0b29c9dc2964398c0e106032951219bae13038f3752e74c5d4103e65ed43771e  ./vendor/libchrome/base/hash.h
-faaa17dc769a74fa9d4a3471e318b96cdd13f273bb0389bbbbccdcc127c6fb90  ./vendor/libchrome/base/lazy_instance.h
-25edacb2c87e390ce637d53a8fca9238dbeb93bd499775b80630af3f02c20b2a  ./vendor/libchrome/base/lazy_instance_helpers.cc
-a3c6aeefd21c577d5c943a6e57ba275a0ea9510871a08c10ce2667e42f2a46b7  ./vendor/libchrome/base/lazy_instance_helpers.h
-e4448091f421abc708425d6f7edbd3cb54024f624269c2c2365845d72edc21b9  ./vendor/libchrome/base/location.cc
-ea21ca73df75d082d8054fff602c3504c0b7e1fe47bb7d61469890eec55d5887  ./vendor/libchrome/base/location.h
-db1ed6dd2bd092bfb20f526ac4c1ebfd73b175bcc9c78bcf99d5686f5179c67f  ./vendor/libchrome/base/logging.cc
-4c16e632e60a9033a0d5bdcc840dbc339001b2f8dff90992213b2ac3655cd566  ./vendor/libchrome/base/logging.h
-b8d421b95f0707ebddcb68f73aa9b52018c0918e0745ed537a5079df61640ccd  ./vendor/libchrome/base/macros.h
-39eee8aa7118e77b59b571cf1275a1e7ab8cf6038be511e3fc239f41ef07f49b  ./vendor/libchrome/base/memory/free_deleter.h
-12b1c3664472a7e0f9f860f09e204433210a6c466c059d6550a80b37d2c5ea32  ./vendor/libchrome/base/memory/ptr_util.h
-0ad0481767efdee6ded70882010b370ab8c440010271216ce6c5ac1485dcee2c  ./vendor/libchrome/base/memory/raw_scoped_refptr_mismatch_checker.h
-3a8c7bee6566182520d980bdb7c84a2f8115e92e800b6570042ab835947b875f  ./vendor/libchrome/base/memory/ref_counted.h
-3d76ab6dcc4b61f201e5addb6f7e75104af267fdeb2cf0108fc454bcf1ee4433  ./vendor/libchrome/base/memory/scoped_refptr.h
-adb6c67fde3e25c44a8c6167f77b31f925cf888d0f8a6b77715915e549dd7990  ./vendor/libchrome/base/memory/shared_memory.h
-7cfd65f746b47c18f17beed5d590f766b6bf1a46842a6981a6aa8546cf79697d  ./vendor/libchrome/base/memory/shared_memory_handle.h
-6d767a757eeb586fc1db68f531e15e6a25ea411fc4d803f9e581feeeecbcd9ae  ./vendor/libchrome/base/memory/singleton.h
-d98c1ee76f99ab424c1130d0cdb6f91c115c2840b424884687f0b54cc703ddb1  ./vendor/libchrome/base/memory/weak_ptr.h
-53e8213f2af73f0e4589ab80d23044fc9b3c4613eaa942e339311c0153168723  ./vendor/libchrome/base/metrics/bucket_ranges.h
-566636ba6da0c61032f573fc00787adecb6749bf090d55a0ae26ae3afcf75745  ./vendor/libchrome/base/metrics/field_trial.h
-04bb4fcdeaf28852ddaa9dee4b52121fa773533f7cedb6d16819a0404c8a5425  ./vendor/libchrome/base/metrics/histogram.h
-002a9bcb9e23b91e262ba1591a41b4980750ad9c651cc20c40341dabf3df0dd4  ./vendor/libchrome/base/metrics/histogram_base.h
-b0a4f1f19a60d420d36e37c4e35a49b09d2dddf185fef2c2ecbc3677ce5b8faf  ./vendor/libchrome/base/metrics/histogram_functions.h
-d8207dfd23a62e3ee0f8f15d22f905f97893826afbce31f3bd92475366f2b4a1  ./vendor/libchrome/base/metrics/histogram_macros.h
-26b160d21fdf9e326661872cf277c833c71f1df079d8b468e2e901a9a476db47  ./vendor/libchrome/base/metrics/histogram_macros_internal.h
-f12f2fe5cdc0ad5b3c0f7f0eda55eefda882c4a64730ac7220137ff5e0819f1d  ./vendor/libchrome/base/metrics/histogram_macros_local.h
-879a70627882d3e5c61d745d3dce90f499575380d159a6af652f29b838ac401b  ./vendor/libchrome/base/metrics/histogram_samples.h
-950b5200b8b79ad3f17647df2d6be1c9857edf53c6b12ac5a5af711c78197e8d  ./vendor/libchrome/base/metrics/persistent_memory_allocator.cc
-fddf573151d2bb41823eee2cb6a287f3693907ba7e5aadc5dcce38a414171e73  ./vendor/libchrome/base/metrics/persistent_memory_allocator.h
-3128707a2e0d6ceca20e38525dc0f36001fe28cd9f804d6d410e3ecf6e14d7fb  ./vendor/libchrome/base/metrics/sparse_histogram.h
-7f1973655f80dcf22a56859302666c4f585ec18cb4bd57f2a18e1b8b0f68aec6  ./vendor/libchrome/base/no_destructor.h
-0bb2cfd67028f404afe4eecdb25685faa3cefe49580ed6c45d04b4cda119eade  ./vendor/libchrome/base/numerics/checked_math.h
-6b7c4cdfce938c30e60b842ccdabd126796fd4b099abd7f26326ec4b479d7952  ./vendor/libchrome/base/numerics/checked_math_impl.h
-b48654af190a06d2689fa3d74846700e94639f6354d9aaba9f44a502f9617c16  ./vendor/libchrome/base/numerics/clamped_math.h
-81ed1886215ce8529a67fba88f9489acaba34eb3d135043484502e9933d125a1  ./vendor/libchrome/base/numerics/clamped_math_impl.h
-5cfe96da219c074e6c663663a307da3400ff3929c84331543152e9a2d413aec1  ./vendor/libchrome/base/numerics/safe_conversions.h
-5dd3f1a915832056c17acb2d6dd3b090e77b6fe43a6793730dc1b6a74173d285  ./vendor/libchrome/base/numerics/safe_conversions_impl.h
-bca10c42ff950f1f1e4cef59c34b48b9ff5f70f248ed12eead48d74fc0e38de2  ./vendor/libchrome/base/numerics/safe_math.h
-656227ab097d774ee47371f7ad50c94bd86d9ab83ab43531c57c9c78052417cd  ./vendor/libchrome/base/numerics/safe_math_clang_gcc_impl.h
-ee8d59a9e7c0b79319787aba29622a1bbaec08987d4b587d4ef91184b7788c5d  ./vendor/libchrome/base/numerics/safe_math_shared_impl.h
-bb44ae253fa52ccdd2bad7c3a1122a1923d64f341d95ab148397aea97b783950  ./vendor/libchrome/base/observer_list.h
-f711d658592ab18b49edaa43672263ee9a4cf116e4891e0fa9b5e314740eb167  ./vendor/libchrome/base/observer_list_threadsafe.h
-f3af785ce37e88f8cdb42e76f8a6d27fb09c63d4071aff38926c980c4d5eb66d  ./vendor/libchrome/base/optional.h
-aedd02ae4884b5ecf2de228e6444eb297f093d566cfd09a7de06e5ef900505dd  ./vendor/libchrome/base/pending_task.h
-42808892f816366f75f101f8adb830dec6d808c785cefd490d8fa8cc06f343fb  ./vendor/libchrome/base/pickle.h
-cb298c5e1569f0f85ef07d569a6beb76637ba0310a52cf9741a68690d2f8c7ef  ./vendor/libchrome/base/posix/eintr_wrapper.h
-8746ddfd8cbc57e67fbde0033b3616d5b868ee23179d2c1846c3a7c01317eadc  ./vendor/libchrome/base/posix/file_descriptor_shuffle.h
-fdc5328da33867488cc291f4654f9a69502307390f7f9d876739f530016ed9f3  ./vendor/libchrome/base/posix/safe_strerror.h
-1b6ef4a5ce4fc7b7bedad53ec48d340be9fff8215f209a03134ecc7612fcc3d6  ./vendor/libchrome/base/process/launch.h
-7d0eaedf65343835f38d16c7281cd096491866e8156417c379940feeb316e2db  ./vendor/libchrome/base/process/process.h
-d45eb69e02ac8d950d8aebc87946dbbb0fc5e927e34302128665cc6c5700c881  ./vendor/libchrome/base/process/process_handle.h
-5eef370b91123e0b12854ff383947d9a6bd9e553315d75f8d7f2a394456d3c06  ./vendor/libchrome/base/scoped_clear_errno.h
-4f68c4c5758cc579cfdab0405d437c54161e4d3ec2761ea5bdadfbdc9d65619a  ./vendor/libchrome/base/scoped_generic.h
-863a1fb61810bd5d308439428d5301155030dd2d51a73244c4a75ce07ebc3b35  ./vendor/libchrome/base/sequence_checker.h
-3b55182f87a1b4c57979f3fe2fcff4833404ed9be6e75ec0423bc8e253afc537  ./vendor/libchrome/base/sequence_checker_impl.h
-0b41692ee85e5781605eb68d0e51e3ca4191cede5bb0c37372cb25633f482ec0  ./vendor/libchrome/base/sequenced_task_runner.h
-73aee8f58898e1b0f0e0f713003d753b76f901dba5abb5598333a23f38781afe  ./vendor/libchrome/base/sequenced_task_runner_helpers.h
-a6123b3785d441a2e3d348954d72c90cce063444195e28fef3e5ee4652cd55d1  ./vendor/libchrome/base/single_thread_task_runner.h
-b1d59c6adc27090ae8dce081d7ba4f61e38d7fad34ac435d186c53f838bdb4e3  ./vendor/libchrome/base/stl_util.h
-36761f94411e4dea7e10d51d6f73f8d850073fffb2810cdbf61a4cbc9781c5b2  ./vendor/libchrome/base/strings/char_traits.h
-e307adafcec337b2c94aebbf0895f9895a10e3144a340de022a591329d3cfd83  ./vendor/libchrome/base/strings/string16.h
-d5566a0b4d8a72eff8c29981486a256ac311db017fe83440ca28df91a597064d  ./vendor/libchrome/base/strings/string_number_conversions.h
-d1a7eb29ef12aac370ce7440fd762a3c895df482bfbfce91fe389f8fc02a207c  ./vendor/libchrome/base/strings/string_piece.cc
-cabcd4c342b5517ca10ca87822167007909a6eb1ea55c56dbf17b399355f2c8e  ./vendor/libchrome/base/strings/string_piece.h
-aa31bae42314a2cb199178d5b89344e7e238bb87794fcff05a5f4fb14a234680  ./vendor/libchrome/base/strings/string_piece_forward.h
-135247764c1c921b0e29227ea50fa6888fcb1f9df1edae94a634c22a2ef9e2ce  ./vendor/libchrome/base/strings/string_util.cc
-2742eb72e2b4b24c188428bf4fbbf13abfffa0d7ff36d1a1236686f0e02b1174  ./vendor/libchrome/base/strings/string_util.h
-65d8a40c660e94776b8062a3ff99362fc0105438cc6b829a31b3ac0042251eda  ./vendor/libchrome/base/strings/string_util_posix.h
-dc764a4d57c22571762baa7020b2aade45efd771e48de4df1f61864977015427  ./vendor/libchrome/base/strings/stringprintf.cc
-f34b0fce20b11198a643713112ce8d896ddbb4c3a9422e91f6d00a2cd836147a  ./vendor/libchrome/base/strings/stringprintf.h
-af2490563321b285c2c7c4b5d3f37c3769599b227755b2c5b7dae2fe374147b5  ./vendor/libchrome/base/strings/sys_string_conversions.h
-dfac333abfe781d854063c6857f91025d34923267d5c2ce25a264a57b1812d2b  ./vendor/libchrome/base/strings/utf_string_conversion_utils.h
-d1245a0efe12da92fe31ac87a563143612f4192dd569bc88b22114556399d231  ./vendor/libchrome/base/strings/utf_string_conversions.h
-2c27513476338b412cfd0c4ea101568e13d82e147dc034bac9c27a37ba5af2c0  ./vendor/libchrome/base/synchronization/lock.h
-8bd9a1409ae597c71970d684ef35569ef75640722b51f5f63a17b04cd3173788  ./vendor/libchrome/base/synchronization/lock_impl.h
-2ae402e3a5261b4366f889ee2a7e2819c0ce204cf3cafa2db612d142a84020ed  ./vendor/libchrome/base/synchronization/lock_impl_posix.cc
-b8b9d2bd6274cdafbecc0dfe305629304ad2ae5294d5732e7753ae12fb3cc497  ./vendor/libchrome/base/synchronization/synchronization_buildflags.h
-7e422f463d25ff45bfe4790d9f03db767834391dff615aa1776ef27d03f7eb41  ./vendor/libchrome/base/sys_info.h
-7f686442f979e845be8587b7512104f691ee19c2adf7c84d766194d2007dccc1  ./vendor/libchrome/base/task_runner.h
-68c12b240d5d3b448ac9284c2c6e97b1433f00306316fb6b11a2d1d2cc2f99a6  ./vendor/libchrome/base/template_util.h
-5d85142a5609ad177a2d7a2e7cae060b886b8b42f25c5b9803cf0cb5ee04ad2f  ./vendor/libchrome/base/third_party/icu/LICENSE
-19bafc2118bc6b45b99c38ce1af08bf8aaee09cf97045d1d98085876b5a1b1b7  ./vendor/libchrome/base/third_party/icu/icu_utf.h
-d55a403514532af12dc2fbfb2e41900090a5dd6c7c76c8e4d9b20bcc737eac35  ./vendor/libchrome/base/third_party/nspr/LICENSE
-f849fc26a7a99981611a3a370e83078deb617d12a45776d6c4cada4d338be469  ./vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
-fde038204e73c962e053ac163369338ffe8ac54fd84e3aa21391b3369fd63aca  ./vendor/libchrome/base/third_party/nspr/prtime.h
-f4b6e1de49233de43b0ce2500468a2c1f5b8783af3fb7761220f38315bc2df67  ./vendor/libchrome/base/threading/platform_thread.h
-136e195f9176bcd14c3a3549ea5d8541094439993a4ace95eba87ee0e02288ef  ./vendor/libchrome/base/threading/platform_thread_internal_posix.h
-40044c247b6b06af72ff5eb62da18dd37ff2f48031f087ba7ed9f86ead7fc04d  ./vendor/libchrome/base/threading/platform_thread_posix.cc
-2a9146e0a822daad3282d81c663eed290d0a536a11ea0265ae6262f11630e2dd  ./vendor/libchrome/base/threading/sequenced_task_runner_handle.h
-b1bdbadeed33ddb77193f0844c32e8baa67a5ae5d5dbe3b9f54cadc6a631b972  ./vendor/libchrome/base/threading/thread_collision_warner.h
-09573a81341f073ff72e141847c45445e4b41029bcc54ef469416ce34e7f4e1a  ./vendor/libchrome/base/threading/thread_id_name_manager.h
-39f1e448827d544c6a4ea6052730a23774e43d805675dc4eff1e62dac7430fbb  ./vendor/libchrome/base/threading/thread_local.h
-4ce66ab1de62adcd404711aed89d5ce6866930cf0903275b32a67d83c78e5dfc  ./vendor/libchrome/base/threading/thread_local_storage.cc
-9ec1a85d04bdf1e460791ec8825f0af1e25d4a9962069dbf90b55089a41b4408  ./vendor/libchrome/base/threading/thread_local_storage.h
-294837f7209f5398f09fc050a4dc7737fe7a35f48c5fedb7be49102a36ceb7c8  ./vendor/libchrome/base/threading/thread_restrictions.h
-20a42edaec24cb2b33d7134c1efb0b9343a0dcf4c825f676cefee6e09be7454d  ./vendor/libchrome/base/threading/thread_task_runner_handle.h
-f3045ca162b851e605cf21dd3b5369f74d5d937c41bab06770b7d45369cf8833  ./vendor/libchrome/base/time/time.cc
-fd4782801bfdf9286362116a6a7a905ccfbc55df32645f1967d8cbc265f0e6a8  ./vendor/libchrome/base/time/time.h
-6817b3e18ea1f6dc3c67195380e5b873cd6952acbf7600edd54df1526623d997  ./vendor/libchrome/base/time/time_now_posix.cc
-5fd3201d87e6d2e314f6397ad2e81b7a7d0100df233af3f2a488c4480e096640  ./vendor/libchrome/base/time/time_override.h
-f69f40e3b8536c7df01132d4d4028fc0c25ec0d4223c965536564691e50344fe  ./vendor/libchrome/base/token.h
-bc23ab463856a5e56ab83b1ef3c4226099bbb7bf6c427c32ae15d42a21f6bfed  ./vendor/libchrome/base/unguessable_token.h
-c23322de7ef5b172228c9009237d15d2faf7106e30e0278f3d4519d78bfc4cd3  ./vendor/libchrome/base/vlog.h
-12b6cd8acf682fe2a6d90c469619c4b9d794d7fe9c3172d9d5e024d5a1659bfd  ./vendor/libchrome/build/build_config.h
-3039541e5c5d018230b8bee6a5e59eb4d6bafa7c68732b9e61b41fd81a27bc3f  ./vendor/libchrome/testing/gtest/include/gtest/gtest_prod.h
-845022e0c1db1abb41a6ba4cd3c4b674ec290f3359d9d3c78ae558d4c0ed9308  ./vendor/zucchini/LICENSE
-e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  ./vendor/zucchini/MODULE_LICENSE_CHROME
-4701a0af1d9be83a5b24d65490c75c2c37772333b38ad3fc7878e8fc9d8267e0  ./vendor/zucchini/abs32_utils.cc
-859d2681911be3697121b7eea7b5382b28da16deb8b068a03ef6e0c361dbd445  ./vendor/zucchini/address_translator.cc
-ab9c9deb93f16a550ac6a34907b78c272f2a19604e5409473895315e29bcb2c3  ./vendor/zucchini/aosp/include/base/check.h
-05525647e279146b36863904530dd0006d1f82f99fd2767ff39d69239e235aea  ./vendor/zucchini/aosp/include/base/check_op.h
-43d9d019e637b750a7bc1e0a3944d1d4cea12cdff4e0905474e16db58415b6a2  ./vendor/zucchini/aosp/include/base/containers/cxx20_erase.h
-30ef02104a03e0d55e3bc63c048f9057312f0131b2b949397e1d978dd011695a  ./vendor/zucchini/aosp/include/build/buildflag.h
-9df450f653d9e0026b162f57a2c77133836cd62df378e25534322b6ee3e98ab5  ./vendor/zucchini/aosp/include/components/zucchini/abs32_utils.h
-3ed0c865d024dcce6538903397ce6ac72c40c2a3ba0f16bc4a92f1180924269d  ./vendor/zucchini/aosp/include/components/zucchini/address_translator.h
-4ab4a0705c8376ae4619d6122afd390118d94ad90e7909da2e532884423f1d2e  ./vendor/zucchini/aosp/include/components/zucchini/algorithm.h
-3f069245e00549328cbf36cfb78dcc9b2ab90c08a5476d82c49f6c7fa165b8a7  ./vendor/zucchini/aosp/include/components/zucchini/arm_utils.h
-f149c8b80c4234ad7be88d896e4498524f48f168cb1c31637e9c1d1695b2cf8e  ./vendor/zucchini/aosp/include/components/zucchini/buffer_sink.h
-c25889b6dd08e241d8903f460284a2792e73ad88776c787f41b1ac480b51fb0a  ./vendor/zucchini/aosp/include/components/zucchini/buffer_source.h
-5bd8910752183f45f840b6065dd94e5bc9e7481f83fb7631c4ef25df687b854d  ./vendor/zucchini/aosp/include/components/zucchini/buffer_view.h
-f739b6c029ec40a9f7bd5305c3d0ae5e428c085797fa18739fddd46a0fb98663  ./vendor/zucchini/aosp/include/components/zucchini/crc32.h
-03780b011ee7c187fce41b42aee32de5ce1078c76c32366fb16b4c9aaf6e05db  ./vendor/zucchini/aosp/include/components/zucchini/disassembler.h
-b9c91a0dd897bfaa26df6c3247aaf99e75cd264357f615bf2e109b9f7b119080  ./vendor/zucchini/aosp/include/components/zucchini/disassembler_dex.h
-852e3797431f194424044d210da3f53cdeceefb23e8baa51a21ec73b38dd5733  ./vendor/zucchini/aosp/include/components/zucchini/disassembler_elf.h
-69bc539bf723efccb937c5fe93d29f49f6639559920d9259ee44a4f46e134c19  ./vendor/zucchini/aosp/include/components/zucchini/disassembler_no_op.h
-b5e86cf5987049adb790b81a485b108f2a5db180fcef9234a7b5948159cf5ce0  ./vendor/zucchini/aosp/include/components/zucchini/element_detection.h
-ccd17f233302411ba5d2df59071ab7201893422aa9d54db54b2d75dddbad22ba  ./vendor/zucchini/aosp/include/components/zucchini/encoded_view.h
-952c790d808deb6bb9c5bccd00a8e6504ecf474ade5312303e078b1de3fb5065  ./vendor/zucchini/aosp/include/components/zucchini/equivalence_map.h
-7c6f41c221036f83051e057eeffcbcd509a556ca994bba85b0b78c6a6cb5dcc4  ./vendor/zucchini/aosp/include/components/zucchini/image_index.h
-908655de17bfebe5eaeeade4cdd2a567a2907e5e013cb0bb19d820a92aa8ec96  ./vendor/zucchini/aosp/include/components/zucchini/image_utils.h
-a3bc23d7687bcf4e5d316b7e8e7771797be973dc9bde2977bab80ef946665cc0  ./vendor/zucchini/aosp/include/components/zucchini/io_utils.h
-d28d66e9de9ba132d6f9b907e18ae7c61801a4fe8737a2a5e5206b5906315e19  ./vendor/zucchini/aosp/include/components/zucchini/patch_reader.h
-53f48d894382fec2677ac434e139b770bcad69a8f642a945f1ccfe44938be211  ./vendor/zucchini/aosp/include/components/zucchini/patch_utils.h
-d6556ba0cf992253dbfa0e469927b3238279865ebb8b9795752b08ad55adaff5  ./vendor/zucchini/aosp/include/components/zucchini/patch_writer.h
-6562d611fab6975c17fbf375d9654878c5f6ea9c711394d5f54fa6a2b34ba7a7  ./vendor/zucchini/aosp/include/components/zucchini/reference_set.h
-e461b4da6a293817f7aba5005f8d53b3597e931899ab5b4a0f725c830cf442b3  ./vendor/zucchini/aosp/include/components/zucchini/rel32_finder.h
-92214559985d7813f39651fc56820c9aad03cd360398cd778fd84880f6abe08d  ./vendor/zucchini/aosp/include/components/zucchini/rel32_utils.h
-85deddab8aec5f2eb2c7d38e35900434ab0bdb98ca82d03be1114920c229ef12  ./vendor/zucchini/aosp/include/components/zucchini/reloc_elf.h
-608a7b2e6a6c998d9641d46f0b138e44c95acf2559ddfc31fdf52fe61806d7d6  ./vendor/zucchini/aosp/include/components/zucchini/suffix_array.h
-e7a1365b362bda44cf68df75f21d3c6df49f6c75e04a53788d3d3d3451cab935  ./vendor/zucchini/aosp/include/components/zucchini/target_pool.h
-8dc3dab58827d8c1432eafa7714a1d39e7e9e2d132b895b9997f4226b9937a4a  ./vendor/zucchini/aosp/include/components/zucchini/targets_affinity.h
-f4e5ad0c852f80f2929e95fb81ff095abb3f2c9ecc9257254558bf49cc99d453  ./vendor/zucchini/aosp/include/components/zucchini/type_dex.h
-9204b7970c7b1f3ec27f5f3970fc5131c5d4d3177052a93f47a9ab378e16c958  ./vendor/zucchini/aosp/include/components/zucchini/type_elf.h
-74733f75da09ff5e3a3d7e15c662eac946f6acd58033579673c3ddfc6952692f  ./vendor/zucchini/aosp/include/components/zucchini/typed_value.h
-480438e1cde53fecf15fba573aaf3c60c0a0870c6cc53efdd6746d6ad5b00a43  ./vendor/zucchini/aosp/include/components/zucchini/version_info.h
-f78d8351a1483bdb35774eb37b4f68f64eeca722eaf433437d1cdb32b5db0a5b  ./vendor/zucchini/aosp/include/components/zucchini/zucchini.h
-9033c748e797f9db69ee599d994d51763fd531cd2bf1793a635d52ce22994972  ./vendor/zucchini/aosp/include/components/zucchini/zucchini_apply.h
-027123695382e7a5630d5da6841fe87d9b229b8bfb2e5cca6467da266ae95c9a  ./vendor/zucchini/arm_utils.cc
-ab75e4e8d05002d9db732fb92d3d36ac862a823d92d8be14ef595f452dc746eb  ./vendor/zucchini/buffer_source.cc
-9994adabd554adf6992231d74ca4dec66651e86b3987017f432cb04d04d8d48e  ./vendor/zucchini/crc32.cc
-3403dcba9034f039cfe245fe143b6e73e1ea7515ca3fd307eb8ee4be6cbf8128  ./vendor/zucchini/disassembler.cc
-02948825abc47bffaa1dd1c774b06394fe7192b4e74e33f14d4a61d263989f7e  ./vendor/zucchini/disassembler_dex.cc
-5b853a907c7bb883d7485cb22ec7d8def7c6df432ddfd54c49f96c8cf558276a  ./vendor/zucchini/disassembler_elf.cc
-4054b3a647ef5d16e3006526db1b34a39b8de8ba49871c1a88ea4778b0599d9d  ./vendor/zucchini/disassembler_no_op.cc
-e21f53a5d599a256f97d54abe890e21722847fe7aa2373b4a5968b74976e2ae8  ./vendor/zucchini/element_detection.cc
-5dc41a3c41970077b99dc5c6028cf9c5fa74b3fd9d115a2936f0064814761fb5  ./vendor/zucchini/equivalence_map.cc
-b0d6670916d0d5f6f0668605551d6fed1701231986f4e40538394dab7dd1660c  ./vendor/zucchini/patch_reader.cc
-175c78a1b4b9026c78fb891b5419ad3a90db7d75d0a39147e11f11d400fedd34  ./vendor/zucchini/rel32_finder.cc
-74e3c8f99128448b0fe75d0daf8efc31748491d1a3ea523d0a129c743d37440f  ./vendor/zucchini/rel32_utils.cc
-e472b81aebe0a511112dc88da24a70c65abfcbbc97c4cbe14b20372d690dec4b  ./vendor/zucchini/reloc_elf.cc
-a687290bda9b85b6696a9e983cb39c7e1477bc0da92ce46734ebd00302cae85f  ./vendor/zucchini/target_pool.cc
-e301b504ee2df95fbca1be829cd7f47384e07145b6316df14e370da5e9c7647f  ./vendor/zucchini/zucchini_apply.cc
diff --git a/native/zucchini/include/components/zucchini/buildflags.h b/native/zucchini/include/components/zucchini/buildflags.h
deleted file mode 100644
index fbd2c41..0000000
--- a/native/zucchini/include/components/zucchini/buildflags.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// Proof-only copy of the pinned Android generated buildflags.h.
-#ifndef COMPONENTS_ZUCCHINI_BUILDFLAGS_H_
-#define COMPONENTS_ZUCCHINI_BUILDFLAGS_H_
-
-#include "build/buildflag.h"
-
-#define BUILDFLAG_INTERNAL_ENABLE_DEX() (1)
-#define BUILDFLAG_INTERNAL_ENABLE_ELF() (1)
-#define BUILDFLAG_INTERNAL_ENABLE_WIN() (0)
-#define BUILDFLAG_INTERNAL_ENABLE_ZTF() (0)
-
-#endif  // COMPONENTS_ZUCCHINI_BUILDFLAGS_H_
diff --git a/native/zucchini/include/gtest/gtest_prod.h b/native/zucchini/include/gtest/gtest_prod.h
deleted file mode 100644
index 125a46c..0000000
--- a/native/zucchini/include/gtest/gtest_prod.h
+++ /dev/null
@@ -1,5 +0,0 @@
-#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
-#define GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
-#define FRIEND_TEST(test_case_name, test_name) \
-  friend class test_case_name##_##test_name##_Test
-#endif
diff --git a/native/zucchini/src/zucchini_ffi.cc b/native/zucchini/src/zucchini_ffi.cc
deleted file mode 100644
index d2faf47..0000000
--- a/native/zucchini/src/zucchini_ffi.cc
+++ /dev/null
@@ -1,353 +0,0 @@
-#include "zucchini_ffi.h"
-
-#include <stdint.h>
-
-#include <algorithm>
-#include <cstring>
-#include <limits>
-#include <map>
-#include <memory>
-#include <vector>
-
-#include "components/zucchini/disassembler.h"
-#include "components/zucchini/disassembler_dex.h"
-#include "components/zucchini/element_detection.h"
-#include "components/zucchini/equivalence_map.h"
-#include "components/zucchini/image_utils.h"
-#include "components/zucchini/patch_reader.h"
-#include "components/zucchini/target_pool.h"
-#include "components/zucchini/type_dex.h"
-#include "components/zucchini/type_elf.h"
-#include "components/zucchini/zucchini_apply.h"
-
-namespace {
-
-otadump_zucchini_result Error(otadump_zucchini_status status, const char* error) {
-  return {status, error};
-}
-
-bool RangeIsRepresentable(const uint8_t* data, size_t size) {
-  uintptr_t begin = reinterpret_cast<uintptr_t>(data);
-  return size <= std::numeric_limits<uintptr_t>::max() - begin;
-}
-
-bool RangesOverlap(const uint8_t* left,
-                   size_t left_size,
-                   const uint8_t* right,
-                   size_t right_size) {
-  if (!left_size || !right_size)
-    return false;
-  uintptr_t left_begin = reinterpret_cast<uintptr_t>(left);
-  uintptr_t right_begin = reinterpret_cast<uintptr_t>(right);
-  return left_begin < right_begin + right_size &&
-         right_begin < left_begin + left_size;
-}
-
-bool IsAndroidExecutable(zucchini::ExecutableType exe_type) {
-  return exe_type == zucchini::kExeTypeDex ||
-         exe_type == zucchini::kExeTypeElfX86 ||
-         exe_type == zucchini::kExeTypeElfX64 ||
-         exe_type == zucchini::kExeTypeElfAArch32 ||
-         exe_type == zucchini::kExeTypeElfAArch64;
-}
-
-bool ReadDexMapItem(zucchini::ConstBufferView image,
-                    uint16_t type,
-                    zucchini::dex::MapItem* result) {
-  using Header = zucchini::dex::HeaderItem;
-  using MapItem = zucchini::dex::MapItem;
-  if (!image.can_access<Header>(0))
-    return false;
-  Header header;
-  std::memcpy(&header, image.begin(), sizeof(header));
-  if (!image.can_access<uint32_t>(header.map_off))
-    return false;
-  uint32_t count = 0;
-  std::memcpy(&count, image.begin() + header.map_off, sizeof(count));
-  size_t items_offset = header.map_off + sizeof(count);
-  if (!image.covers_array(items_offset, count, sizeof(MapItem)))
-    return false;
-  for (uint32_t index = 0; index < count; ++index) {
-    MapItem item;
-    std::memcpy(&item, image.begin() + items_offset + index * sizeof(item),
-                sizeof(item));
-    if (item.type == type) {
-      *result = item;
-      return true;
-    }
-  }
-  return false;
-}
-
-bool ValidateDexWriterWidths(zucchini::ConstBufferView image) {
-  const uint16_t narrow_types[] = {
-      zucchini::dex::kTypeTypeIdItem,
-      zucchini::dex::kTypeProtoIdItem,
-      zucchini::dex::kTypeFieldIdItem,
-      zucchini::dex::kTypeMethodIdItem,
-      zucchini::dex::kTypeCallSiteIdItem,
-      zucchini::dex::kTypeMethodHandleItem,
-  };
-  for (uint16_t type : narrow_types) {
-    zucchini::dex::MapItem item;
-    if (ReadDexMapItem(image, type, &item) &&
-        item.size > static_cast<uint32_t>(UINT16_MAX) + 1) {
-      return false;
-    }
-  }
-  return true;
-}
-
-bool ValidateDexReferenceTargets(
-    const zucchini::PatchElementReader& element,
-    zucchini::Disassembler* old_disasm,
-    zucchini::Disassembler* new_disasm,
-    size_t old_size,
-    size_t new_size,
-    zucchini::ConstBufferView new_image) {
-  zucchini::dex::MapItem string_ids;
-  if (!ReadDexMapItem(new_image, zucchini::dex::kTypeStringIdItem,
-                      &string_ids)) {
-    return false;
-  }
-
-  zucchini::ReferenceDeltaSource deltas = element.GetReferenceDeltaSource();
-  std::map<zucchini::PoolTag, std::vector<zucchini::ReferenceGroup>> pools;
-  for (const auto& group : old_disasm->MakeReferenceGroups())
-    pools[group.pool_tag()].push_back(group);
-  std::vector<zucchini::ReferenceGroup> new_groups =
-      new_disasm->MakeReferenceGroups();
-  zucchini::OffsetMapper mapper(
-      element.GetEquivalenceSource(),
-      base::checked_cast<zucchini::offset_t>(old_size),
-      base::checked_cast<zucchini::offset_t>(new_size));
-
-  for (const auto& pool : pools) {
-    zucchini::TargetPool targets;
-    for (zucchini::ReferenceGroup group : pool.second)
-      targets.InsertTargets(std::move(*group.GetReader(old_disasm)));
-    targets.FilterAndProject(mapper);
-
-    zucchini::TargetSource extras = element.GetExtraTargetSource(pool.first);
-    targets.InsertTargets(&extras);
-    if (!extras.Done())
-      return false;
-
-    for (const zucchini::ReferenceGroup& group : pool.second) {
-      if (group.type_tag().value() >= new_groups.size())
-        return false;
-      zucchini::EquivalenceSource equivalences =
-          element.GetEquivalenceSource();
-      for (auto equivalence = equivalences.GetNext(); equivalence.has_value();
-           equivalence = equivalences.GetNext()) {
-        std::unique_ptr<zucchini::ReferenceReader> references =
-            group.GetReader(equivalence->src_offset, equivalence->src_end(),
-                            old_disasm);
-        for (auto reference = references->GetNext(); reference.has_value();
-             reference = references->GetNext()) {
-          zucchini::offset_t projected =
-              mapper.ExtendedForwardProject(reference->target);
-          zucchini::key_t expected = targets.KeyForNearestOffset(projected);
-          std::optional<int32_t> delta = deltas.GetNext();
-          if (!delta.has_value())
-            return false;
-          int64_t key = static_cast<int64_t>(expected) + delta.value();
-          if (key < 0 || key > UINT32_MAX ||
-              !targets.KeyIsValid(static_cast<zucchini::key_t>(key))) {
-            return false;
-          }
-          if (group.type_tag().value() ==
-              zucchini::DisassemblerDex::kCodeToStringId16) {
-            zucchini::offset_t target =
-                targets.OffsetForKey(static_cast<zucchini::key_t>(key));
-            if (target < string_ids.offset ||
-                (target - string_ids.offset) %
-                        sizeof(zucchini::dex::StringIdItem) !=
-                    0 ||
-                (target - string_ids.offset) /
-                        sizeof(zucchini::dex::StringIdItem) >
-                    UINT16_MAX) {
-              return false;
-            }
-          }
-        }
-      }
-    }
-  }
-  return deltas.Done();
-}
-
-bool ValidateReferenceBoundaries(
-    const zucchini::PatchElementReader& element,
-    zucchini::Disassembler* old_disasm,
-    zucchini::ExecutableType exe_type,
-    size_t new_size) {
-  std::vector<zucchini::offset_t> boundaries;
-  std::vector<zucchini::Equivalence> parsed_equivalences;
-  zucchini::EquivalenceSource equivalences = element.GetEquivalenceSource();
-  for (auto equivalence = equivalences.GetNext(); equivalence.has_value();
-       equivalence = equivalences.GetNext()) {
-    boundaries.push_back(equivalence->src_offset);
-    boundaries.push_back(equivalence->src_end());
-    parsed_equivalences.push_back(*equivalence);
-  }
-  std::sort(boundaries.begin(), boundaries.end());
-
-  for (const auto& group : old_disasm->MakeReferenceGroups()) {
-    size_t writer_width = group.width();
-    if (group.type_tag().value() == 0) {
-      if (exe_type == zucchini::kExeTypeElfX86 ||
-          exe_type == zucchini::kExeTypeElfAArch32) {
-        writer_width = sizeof(zucchini::elf::Elf32_Rel);
-      } else if (exe_type == zucchini::kExeTypeElfX64 ||
-                 exe_type == zucchini::kExeTypeElfAArch64) {
-        writer_width = sizeof(zucchini::elf::Elf64_Rel);
-      }
-    }
-
-    std::unique_ptr<zucchini::ReferenceReader> reader =
-        group.GetReader(old_disasm);
-    for (auto reference = reader->GetNext(); reference.has_value();
-         reference = reader->GetNext()) {
-      auto boundary =
-          std::upper_bound(boundaries.begin(), boundaries.end(),
-                           reference->location);
-      if (boundary != boundaries.end() &&
-          *boundary < reference->location + group.width()) {
-        return false;
-      }
-    }
-
-    // Upstream creates a fresh ranged reader for each equivalence. Mirror
-    // those reads so an invalid target before a later equivalence cannot hide
-    // a reference whose source or projected writer body crosses a boundary.
-    for (const auto& equivalence : parsed_equivalences) {
-      std::unique_ptr<zucchini::ReferenceReader> ranged_reader =
-          group.GetReader(equivalence.src_offset, equivalence.src_end(),
-                          old_disasm);
-      for (auto reference = ranged_reader->GetNext(); reference.has_value();
-           reference = ranged_reader->GetNext()) {
-        if (reference->location < equivalence.src_offset ||
-            reference->location > equivalence.src_end() ||
-            group.width() > equivalence.src_end() - reference->location) {
-          return false;
-        }
-        size_t projected = equivalence.dst_offset +
-                           reference->location - equivalence.src_offset;
-        if (projected > new_size || writer_width > new_size - projected)
-          return false;
-      }
-    }
-  }
-  return true;
-}
-
-bool PreflightAndroidElements(
-    zucchini::ConstBufferView old_image,
-    const zucchini::EnsemblePatchReader& patch,
-    zucchini::MutableBufferView new_image) {
-  if (!patch.CheckOldFile(old_image))
-    return false;
-  for (const auto& element : patch.elements()) {
-    zucchini::ExecutableType exe_type = element.element_match().exe_type();
-    if (!IsAndroidExecutable(exe_type))
-      continue;
-    zucchini::ConstBufferView old_element = old_image[element.old_element()];
-    zucchini::MutableBufferView new_element = new_image[element.new_element()];
-    if (!zucchini::ApplyEquivalenceAndExtraData(old_element, element,
-                                                 new_element) ||
-        !zucchini::ApplyRawDelta(element, new_element)) {
-      return false;
-    }
-    auto old_disasm = zucchini::MakeDisassemblerOfType(old_element, exe_type);
-    auto new_disasm = zucchini::MakeDisassemblerOfType(
-        zucchini::ConstBufferView(new_element), exe_type);
-    if (!old_disasm || !new_disasm ||
-        old_disasm->size() != old_element.size() ||
-        new_disasm->size() != new_element.size() ||
-        !ValidateReferenceBoundaries(element, old_disasm.get(), exe_type,
-                                     new_element.size())) {
-      return false;
-    }
-    if (exe_type == zucchini::kExeTypeDex) {
-      if (!ValidateDexWriterWidths(zucchini::ConstBufferView(new_element)) ||
-          !ValidateDexReferenceTargets(
-              element, old_disasm.get(), new_disasm.get(), old_element.size(),
-              new_element.size(), zucchini::ConstBufferView(new_element))) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
-}  // namespace
-
-extern "C" otadump_zucchini_result otadump_zucchini_apply(
-    const uint8_t* old_data,
-    size_t old_size,
-    const uint8_t* patch_data,
-    size_t patch_size,
-    uint8_t* new_data,
-    size_t new_size) {
-  if ((!old_data && old_size) || (!patch_data && patch_size) ||
-      (!new_data && new_size)) {
-    return Error(OTADUMP_ZUCCHINI_INVALID_ARGUMENT, "null non-empty buffer");
-  }
-  if (!RangeIsRepresentable(old_data, old_size) ||
-      !RangeIsRepresentable(patch_data, patch_size) ||
-      !RangeIsRepresentable(new_data, new_size)) {
-    return Error(OTADUMP_ZUCCHINI_INVALID_ARGUMENT, "buffer range wraps");
-  }
-  if (RangesOverlap(new_data, new_size, old_data, old_size) ||
-      RangesOverlap(new_data, new_size, patch_data, patch_size)) {
-    return Error(OTADUMP_ZUCCHINI_INVALID_ARGUMENT,
-                 "output overlaps an input buffer");
-  }
-  if (old_size >= zucchini::kOffsetBound || new_size >= zucchini::kOffsetBound) {
-    return Error(OTADUMP_ZUCCHINI_INVALID_ARGUMENT,
-                 "image exceeds Zucchini offset bound");
-  }
-
-  // BufferView performs pointer arithmetic in its constructor. Normalize
-  // empty null buffers to a valid one-past-capable address.
-  static const uint8_t empty_input = 0;
-  static uint8_t empty_output = 0;
-  old_data = old_data ? old_data : &empty_input;
-  patch_data = patch_data ? patch_data : &empty_input;
-  new_data = new_data ? new_data : &empty_output;
-
-  auto patch = zucchini::EnsemblePatchReader::Create(
-      zucchini::ConstBufferView(patch_data, patch_size));
-  if (!patch) {
-    return Error(OTADUMP_ZUCCHINI_INVALID_PATCH, "invalid ensemble patch");
-  }
-  if (patch->header().new_size != new_size) {
-    return Error(OTADUMP_ZUCCHINI_WRONG_OUTPUT_SIZE,
-                 "output buffer size does not match patch");
-  }
-
-  for (const auto& element : patch->elements()) {
-    const zucchini::ExecutableType exe_type =
-        element.element_match().exe_type();
-    if (exe_type != zucchini::kExeTypeNoOp && !IsAndroidExecutable(exe_type)) {
-      return Error(OTADUMP_ZUCCHINI_UNSUPPORTED_ELEMENT,
-                    "element format is not enabled by Android");
-    }
-  }
-
-  if (!PreflightAndroidElements(
-          zucchini::ConstBufferView(old_data, old_size), *patch,
-          zucchini::MutableBufferView(new_data, new_size))) {
-    return Error(OTADUMP_ZUCCHINI_APPLY_ERROR,
-                 "android executable preflight failed");
-  }
-
-  zucchini::status::Code status = zucchini::ApplyBuffer(
-      zucchini::ConstBufferView(old_data, old_size), *patch,
-      zucchini::MutableBufferView(new_data, new_size));
-  if (status != zucchini::status::kStatusSuccess) {
-    return Error(OTADUMP_ZUCCHINI_APPLY_ERROR, "zucchini apply failed");
-  }
-  return {OTADUMP_ZUCCHINI_OK, nullptr};
-}
diff --git a/native/zucchini/src/zucchini_ffi.h b/native/zucchini/src/zucchini_ffi.h
deleted file mode 100644
index 18ec992..0000000
--- a/native/zucchini/src/zucchini_ffi.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#ifndef OTADUMP_ZUCCHINI_FFI_H_
-#define OTADUMP_ZUCCHINI_FFI_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-enum otadump_zucchini_status {
-  OTADUMP_ZUCCHINI_OK = 0,
-  OTADUMP_ZUCCHINI_INVALID_ARGUMENT = 1,
-  OTADUMP_ZUCCHINI_INVALID_PATCH = 2,
-  OTADUMP_ZUCCHINI_UNSUPPORTED_ELEMENT = 3,
-  OTADUMP_ZUCCHINI_WRONG_OUTPUT_SIZE = 4,
-  OTADUMP_ZUCCHINI_APPLY_ERROR = 5,
-};
-
-struct otadump_zucchini_result {
-  int status;
-  const char* error;
-};
-
-// All non-empty buffers must remain valid for the complete call. Input buffers
-// are read-only. The output buffer must not overlap either input buffer.
-struct otadump_zucchini_result otadump_zucchini_apply(
-    const uint8_t* old_data,
-    size_t old_size,
-    const uint8_t* patch_data,
-    size_t patch_size,
-    uint8_t* new_data,
-    size_t new_size);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // OTADUMP_ZUCCHINI_FFI_H_
diff --git a/native/zucchini/vendor/libchrome/MODULE_LICENSE_BSD b/native/zucchini/vendor/libchrome/MODULE_LICENSE_BSD
deleted file mode 100644
index e69de29..0000000
diff --git a/native/zucchini/vendor/libchrome/NOTICE b/native/zucchini/vendor/libchrome/NOTICE
deleted file mode 100644
index 972bb2e..0000000
--- a/native/zucchini/vendor/libchrome/NOTICE
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/native/zucchini/vendor/libchrome/base/at_exit.cc b/native/zucchini/vendor/libchrome/base/at_exit.cc
deleted file mode 100644
index 52c2151..0000000
--- a/native/zucchini/vendor/libchrome/base/at_exit.cc
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/at_exit.h"
-
-#include <stddef.h>
-#include <ostream>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/logging.h"
-
-namespace base {
-
-// Keep a stack of registered AtExitManagers.  We always operate on the most
-// recent, and we should never have more than one outside of testing (for a
-// statically linked version of this library).  Testing may use the shadow
-// version of the constructor, and if we are building a dynamic library we may
-// end up with multiple AtExitManagers on the same process.  We don't protect
-// this for thread-safe access, since it will only be modified in testing.
-static AtExitManager* g_top_manager = nullptr;
-
-static bool g_disable_managers = false;
-
-AtExitManager::AtExitManager()
-    : processing_callbacks_(false), next_manager_(g_top_manager) {
-// If multiple modules instantiate AtExitManagers they'll end up living in this
-// module... they have to coexist.
-#if !defined(COMPONENT_BUILD)
-  DCHECK(!g_top_manager);
-#endif
-  g_top_manager = this;
-}
-
-AtExitManager::~AtExitManager() {
-  if (!g_top_manager) {
-    NOTREACHED() << "Tried to ~AtExitManager without an AtExitManager";
-    return;
-  }
-  DCHECK_EQ(this, g_top_manager);
-
-  if (!g_disable_managers)
-    ProcessCallbacksNow();
-  g_top_manager = next_manager_;
-}
-
-// static
-void AtExitManager::RegisterCallback(AtExitCallbackType func, void* param) {
-  DCHECK(func);
-  RegisterTask(base::Bind(func, param));
-}
-
-// static
-void AtExitManager::RegisterTask(base::Closure task) {
-  if (!g_top_manager) {
-    NOTREACHED() << "Tried to RegisterCallback without an AtExitManager";
-    return;
-  }
-
-  AutoLock lock(g_top_manager->lock_);
-  DCHECK(!g_top_manager->processing_callbacks_);
-  g_top_manager->stack_.push(std::move(task));
-}
-
-// static
-void AtExitManager::ProcessCallbacksNow() {
-  if (!g_top_manager) {
-    NOTREACHED() << "Tried to ProcessCallbacksNow without an AtExitManager";
-    return;
-  }
-
-  // Callbacks may try to add new callbacks, so run them without holding
-  // |lock_|. This is an error and caught by the DCHECK in RegisterTask(), but
-  // handle it gracefully in release builds so we don't deadlock.
-  base::stack<base::Closure> tasks;
-  {
-    AutoLock lock(g_top_manager->lock_);
-    tasks.swap(g_top_manager->stack_);
-    g_top_manager->processing_callbacks_ = true;
-  }
-
-  // Relax the cross-thread access restriction to non-thread-safe RefCount.
-  // It's safe since all other threads should be terminated at this point.
-  ScopedAllowCrossThreadRefCountAccess allow_cross_thread_ref_count_access;
-
-  while (!tasks.empty()) {
-    base::Closure task = tasks.top();
-    task.Run();
-    tasks.pop();
-  }
-
-  // Expect that all callbacks have been run.
-  DCHECK(g_top_manager->stack_.empty());
-}
-
-void AtExitManager::DisableAllAtExitManagers() {
-  AutoLock lock(g_top_manager->lock_);
-  g_disable_managers = true;
-}
-
-AtExitManager::AtExitManager(bool shadow)
-    : processing_callbacks_(false), next_manager_(g_top_manager) {
-  DCHECK(shadow || !g_top_manager);
-  g_top_manager = this;
-}
-
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/at_exit.h b/native/zucchini/vendor/libchrome/base/at_exit.h
deleted file mode 100644
index e74de8d..0000000
--- a/native/zucchini/vendor/libchrome/base/at_exit.h
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_AT_EXIT_H_
-#define BASE_AT_EXIT_H_
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/containers/stack.h"
-#include "base/macros.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-// This class provides a facility similar to the CRT atexit(), except that
-// we control when the callbacks are executed. Under Windows for a DLL they
-// happen at a really bad time and under the loader lock. This facility is
-// mostly used by base::Singleton.
-//
-// The usage is simple. Early in the main() or WinMain() scope create an
-// AtExitManager object on the stack:
-// int main(...) {
-//    base::AtExitManager exit_manager;
-//
-// }
-// When the exit_manager object goes out of scope, all the registered
-// callbacks and singleton destructors will be called.
-
-class BASE_EXPORT AtExitManager {
- public:
-  typedef void (*AtExitCallbackType)(void*);
-
-  AtExitManager();
-
-  // The dtor calls all the registered callbacks. Do not try to register more
-  // callbacks after this point.
-  ~AtExitManager();
-
-  // Registers the specified function to be called at exit. The prototype of
-  // the callback function is void func(void*).
-  static void RegisterCallback(AtExitCallbackType func, void* param);
-
-  // Registers the specified task to be called at exit.
-  static void RegisterTask(base::Closure task);
-
-  // Calls the functions registered with RegisterCallback in LIFO order. It
-  // is possible to register new callbacks after calling this function.
-  static void ProcessCallbacksNow();
-
-  // Disable all registered at-exit callbacks. This is used only in a single-
-  // process mode.
-  static void DisableAllAtExitManagers();
-
- protected:
-  // This constructor will allow this instance of AtExitManager to be created
-  // even if one already exists.  This should only be used for testing!
-  // AtExitManagers are kept on a global stack, and it will be removed during
-  // destruction.  This allows you to shadow another AtExitManager.
-  explicit AtExitManager(bool shadow);
-
- private:
-  base::Lock lock_;
-  base::stack<base::Closure> stack_;
-  bool processing_callbacks_;
-  AtExitManager* next_manager_;  // Stack of managers to allow shadowing.
-
-  DISALLOW_COPY_AND_ASSIGN(AtExitManager);
-};
-
-#if defined(UNIT_TEST)
-class ShadowingAtExitManager : public AtExitManager {
- public:
-  ShadowingAtExitManager() : AtExitManager(true) {}
-};
-#endif  // defined(UNIT_TEST)
-
-}  // namespace base
-
-#endif  // BASE_AT_EXIT_H_
diff --git a/native/zucchini/vendor/libchrome/base/atomic_ref_count.h b/native/zucchini/vendor/libchrome/base/atomic_ref_count.h
deleted file mode 100644
index 3ffa017..0000000
--- a/native/zucchini/vendor/libchrome/base/atomic_ref_count.h
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This is a low level implementation of atomic semantics for reference
-// counting.  Please use base/memory/ref_counted.h directly instead.
-
-#ifndef BASE_ATOMIC_REF_COUNT_H_
-#define BASE_ATOMIC_REF_COUNT_H_
-
-#include <atomic>
-
-namespace base {
-
-class AtomicRefCount {
- public:
-  constexpr AtomicRefCount() : ref_count_(0) {}
-  explicit constexpr AtomicRefCount(int initial_value)
-      : ref_count_(initial_value) {}
-
-  // Increment a reference count.
-  void Increment() { Increment(1); }
-
-  // Increment a reference count by "increment", which must exceed 0.
-  void Increment(int increment) {
-    ref_count_.fetch_add(increment, std::memory_order_relaxed);
-  }
-
-  // Decrement a reference count, and return whether the result is non-zero.
-  // Insert barriers to ensure that state written before the reference count
-  // became zero will be visible to a thread that has just made the count zero.
-  bool Decrement() {
-    // TODO(jbroman): Technically this doesn't need to be an acquire operation
-    // unless the result is 1 (i.e., the ref count did indeed reach zero).
-    // However, there are toolchain issues that make that not work as well at
-    // present (notably TSAN doesn't like it).
-    return ref_count_.fetch_sub(1, std::memory_order_acq_rel) != 1;
-  }
-
-  // Return whether the reference count is one.  If the reference count is used
-  // in the conventional way, a refrerence count of 1 implies that the current
-  // thread owns the reference and no other thread shares it.  This call
-  // performs the test for a reference count of one, and performs the memory
-  // barrier needed for the owning thread to act on the object, knowing that it
-  // has exclusive access to the object.
-  bool IsOne() const { return ref_count_.load(std::memory_order_acquire) == 1; }
-
-  // Return whether the reference count is zero.  With conventional object
-  // referencing counting, the object will be destroyed, so the reference count
-  // should never be zero.  Hence this is generally used for a debug check.
-  bool IsZero() const {
-    return ref_count_.load(std::memory_order_acquire) == 0;
-  }
-
-  // Returns the current reference count (with no barriers). This is subtle, and
-  // should be used only for debugging.
-  int SubtleRefCountForDebug() const {
-    return ref_count_.load(std::memory_order_relaxed);
-  }
-
- private:
-  std::atomic_int ref_count_;
-};
-
-}  // namespace base
-
-#endif  // BASE_ATOMIC_REF_COUNT_H_
diff --git a/native/zucchini/vendor/libchrome/base/atomic_sequence_num.h b/native/zucchini/vendor/libchrome/base/atomic_sequence_num.h
deleted file mode 100644
index 717e37a..0000000
--- a/native/zucchini/vendor/libchrome/base/atomic_sequence_num.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_ATOMIC_SEQUENCE_NUM_H_
-#define BASE_ATOMIC_SEQUENCE_NUM_H_
-
-#include <atomic>
-
-#include "base/macros.h"
-
-namespace base {
-
-// AtomicSequenceNumber is a thread safe increasing sequence number generator.
-// Its constructor doesn't emit a static initializer, so it's safe to use as a
-// global variable or static member.
-class AtomicSequenceNumber {
- public:
-  constexpr AtomicSequenceNumber() = default;
-
-  // Returns an increasing sequence number starts from 0 for each call.
-  // This function can be called from any thread without data race.
-  inline int GetNext() { return seq_.fetch_add(1, std::memory_order_relaxed); }
-
- private:
-  std::atomic_int seq_{0};
-
-  DISALLOW_COPY_AND_ASSIGN(AtomicSequenceNumber);
-};
-
-}  // namespace base
-
-#endif  // BASE_ATOMIC_SEQUENCE_NUM_H_
diff --git a/native/zucchini/vendor/libchrome/base/atomicops.h b/native/zucchini/vendor/libchrome/base/atomicops.h
deleted file mode 100644
index 4d8510e..0000000
--- a/native/zucchini/vendor/libchrome/base/atomicops.h
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// For atomic operations on reference counts, see atomic_refcount.h.
-// For atomic operations on sequence numbers, see atomic_sequence_num.h.
-
-// The routines exported by this module are subtle.  If you use them, even if
-// you get the code right, it will depend on careful reasoning about atomicity
-// and memory ordering; it will be less readable, and harder to maintain.  If
-// you plan to use these routines, you should have a good reason, such as solid
-// evidence that performance would otherwise suffer, or there being no
-// alternative.  You should assume only properties explicitly guaranteed by the
-// specifications in this file.  You are almost certainly _not_ writing code
-// just for the x86; if you assume x86 semantics, x86 hardware bugs and
-// implementations on other archtectures will cause your code to break.  If you
-// do not know what you are doing, avoid these routines, and use a Mutex.
-//
-// It is incorrect to make direct assignments to/from an atomic variable.
-// You should use one of the Load or Store routines.  The NoBarrier
-// versions are provided when no barriers are needed:
-//   NoBarrier_Store()
-//   NoBarrier_Load()
-// Although there are currently no compiler enforcement, you are encouraged
-// to use these.
-//
-
-#ifndef BASE_ATOMICOPS_H_
-#define BASE_ATOMICOPS_H_
-
-#include <stdint.h>
-
-// Small C++ header which defines implementation specific macros used to
-// identify the STL implementation.
-// - libc++: captures __config for _LIBCPP_VERSION
-// - libstdc++: captures bits/c++config.h for __GLIBCXX__
-#include <cstddef>
-
-#include "base/base_export.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN) && defined(ARCH_CPU_64_BITS)
-// windows.h #defines this (only on x64). This causes problems because the
-// public API also uses MemoryBarrier at the public name for this fence. So, on
-// X64, undef it, and call its documented
-// (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx)
-// implementation directly.
-#undef MemoryBarrier
-#endif
-
-namespace base {
-namespace subtle {
-
-typedef int32_t Atomic32;
-#ifdef ARCH_CPU_64_BITS
-// We need to be able to go between Atomic64 and AtomicWord implicitly.  This
-// means Atomic64 and AtomicWord should be the same type on 64-bit.
-#if defined(__ILP32__) || defined(OS_NACL)
-// NaCl's intptr_t is not actually 64-bits on 64-bit!
-// http://code.google.com/p/nativeclient/issues/detail?id=1162
-typedef int64_t Atomic64;
-#else
-typedef intptr_t Atomic64;
-#endif
-#endif
-
-// Use AtomicWord for a machine-sized pointer.  It will use the Atomic32 or
-// Atomic64 routines below, depending on your architecture.
-typedef intptr_t AtomicWord;
-
-// Atomically execute:
-//      result = *ptr;
-//      if (*ptr == old_value)
-//        *ptr = new_value;
-//      return result;
-//
-// I.e., replace "*ptr" with "new_value" if "*ptr" used to be "old_value".
-// Always return the old value of "*ptr"
-//
-// This routine implies no memory barriers.
-Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
-                                  Atomic32 old_value,
-                                  Atomic32 new_value);
-
-// Atomically store new_value into *ptr, returning the previous value held in
-// *ptr.  This routine implies no memory barriers.
-Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value);
-
-// Atomically increment *ptr by "increment".  Returns the new value of
-// *ptr with the increment applied.  This routine implies no memory barriers.
-Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);
-
-Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
-                                 Atomic32 increment);
-
-// These following lower-level operations are typically useful only to people
-// implementing higher-level synchronization operations like spinlocks,
-// mutexes, and condition-variables.  They combine CompareAndSwap(), a load, or
-// a store with appropriate memory-ordering instructions.  "Acquire" operations
-// ensure that no later memory access can be reordered ahead of the operation.
-// "Release" operations ensure that no previous memory access can be reordered
-// after the operation.  "Barrier" operations have both "Acquire" and "Release"
-// semantics.   A MemoryBarrier() has "Barrier" semantics, but does no memory
-// access.
-Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
-                                Atomic32 old_value,
-                                Atomic32 new_value);
-Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
-                                Atomic32 old_value,
-                                Atomic32 new_value);
-
-void MemoryBarrier();
-void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value);
-void Acquire_Store(volatile Atomic32* ptr, Atomic32 value);
-void Release_Store(volatile Atomic32* ptr, Atomic32 value);
-
-Atomic32 NoBarrier_Load(volatile const Atomic32* ptr);
-Atomic32 Acquire_Load(volatile const Atomic32* ptr);
-Atomic32 Release_Load(volatile const Atomic32* ptr);
-
-// 64-bit atomic operations (only available on 64-bit processors).
-#ifdef ARCH_CPU_64_BITS
-Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
-                                  Atomic64 old_value,
-                                  Atomic64 new_value);
-Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value);
-Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);
-Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);
-
-Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
-                                Atomic64 old_value,
-                                Atomic64 new_value);
-Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
-                                Atomic64 old_value,
-                                Atomic64 new_value);
-void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value);
-void Acquire_Store(volatile Atomic64* ptr, Atomic64 value);
-void Release_Store(volatile Atomic64* ptr, Atomic64 value);
-Atomic64 NoBarrier_Load(volatile const Atomic64* ptr);
-Atomic64 Acquire_Load(volatile const Atomic64* ptr);
-Atomic64 Release_Load(volatile const Atomic64* ptr);
-#endif  // ARCH_CPU_64_BITS
-
-}  // namespace subtle
-}  // namespace base
-
-#if defined(OS_WIN)
-// TODO(jfb): Try to use base/atomicops_internals_portable.h everywhere.
-// https://crbug.com/559247.
-#  include "base/atomicops_internals_x86_msvc.h"
-#else
-#  include "base/atomicops_internals_portable.h"
-#endif
-
-// On some platforms we need additional declarations to make
-// AtomicWord compatible with our other Atomic* types.
-#if defined(OS_MACOSX) || defined(OS_OPENBSD)
-#include "base/atomicops_internals_atomicword_compat.h"
-#endif
-
-#endif  // BASE_ATOMICOPS_H_
diff --git a/native/zucchini/vendor/libchrome/base/atomicops_internals_portable.h b/native/zucchini/vendor/libchrome/base/atomicops_internals_portable.h
deleted file mode 100644
index ee034de..0000000
--- a/native/zucchini/vendor/libchrome/base/atomicops_internals_portable.h
+++ /dev/null
@@ -1,229 +0,0 @@
-// Copyright (c) 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This file is an internal atomic implementation, use atomicops.h instead.
-//
-// This implementation uses C++11 atomics' member functions. The code base is
-// currently written assuming atomicity revolves around accesses instead of
-// C++11's memory locations. The burden is on the programmer to ensure that all
-// memory locations accessed atomically are never accessed non-atomically (tsan
-// should help with this).
-//
-// TODO(jfb) Modify the atomicops.h API and user code to declare atomic
-//           locations as truly atomic. See the static_assert below.
-//
-// Of note in this implementation:
-//  * All NoBarrier variants are implemented as relaxed.
-//  * All Barrier variants are implemented as sequentially-consistent.
-//  * Compare exchange's failure ordering is always the same as the success one
-//    (except for release, which fails as relaxed): using a weaker ordering is
-//    only valid under certain uses of compare exchange.
-//  * Acquire store doesn't exist in the C11 memory model, it is instead
-//    implemented as a relaxed store followed by a sequentially consistent
-//    fence.
-//  * Release load doesn't exist in the C11 memory model, it is instead
-//    implemented as sequentially consistent fence followed by a relaxed load.
-//  * Atomic increment is expected to return the post-incremented value, whereas
-//    C11 fetch add returns the previous value. The implementation therefore
-//    needs to increment twice (which the compiler should be able to detect and
-//    optimize).
-
-#ifndef BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
-#define BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
-
-#include <atomic>
-
-#include "build/build_config.h"
-
-namespace base {
-namespace subtle {
-
-// This implementation is transitional and maintains the original API for
-// atomicops.h. This requires casting memory locations to the atomic types, and
-// assumes that the API and the C++11 implementation are layout-compatible,
-// which isn't true for all implementations or hardware platforms. The static
-// assertion should detect this issue, were it to fire then this header
-// shouldn't be used.
-//
-// TODO(jfb) If this header manages to stay committed then the API should be
-//           modified, and all call sites updated.
-typedef volatile std::atomic<Atomic32>* AtomicLocation32;
-static_assert(sizeof(*(AtomicLocation32) nullptr) == sizeof(Atomic32),
-              "incompatible 32-bit atomic layout");
-
-inline void MemoryBarrier() {
-#if defined(__GLIBCXX__)
-  // Work around libstdc++ bug 51038 where atomic_thread_fence was declared but
-  // not defined, leading to the linker complaining about undefined references.
-  __atomic_thread_fence(std::memory_order_seq_cst);
-#else
-  std::atomic_thread_fence(std::memory_order_seq_cst);
-#endif
-}
-
-inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
-                                         Atomic32 old_value,
-                                         Atomic32 new_value) {
-  ((AtomicLocation32)ptr)
-      ->compare_exchange_strong(old_value,
-                                new_value,
-                                std::memory_order_relaxed,
-                                std::memory_order_relaxed);
-  return old_value;
-}
-
-inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
-                                         Atomic32 new_value) {
-  return ((AtomicLocation32)ptr)
-      ->exchange(new_value, std::memory_order_relaxed);
-}
-
-inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
-                                          Atomic32 increment) {
-  return increment +
-         ((AtomicLocation32)ptr)
-             ->fetch_add(increment, std::memory_order_relaxed);
-}
-
-inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
-                                        Atomic32 increment) {
-  return increment + ((AtomicLocation32)ptr)->fetch_add(increment);
-}
-
-inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  ((AtomicLocation32)ptr)
-      ->compare_exchange_strong(old_value,
-                                new_value,
-                                std::memory_order_acquire,
-                                std::memory_order_acquire);
-  return old_value;
-}
-
-inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value,
-                                       Atomic32 new_value) {
-  ((AtomicLocation32)ptr)
-      ->compare_exchange_strong(old_value,
-                                new_value,
-                                std::memory_order_release,
-                                std::memory_order_relaxed);
-  return old_value;
-}
-
-inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
-  ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed);
-}
-
-inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
-  ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed);
-  MemoryBarrier();
-}
-
-inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
-  ((AtomicLocation32)ptr)->store(value, std::memory_order_release);
-}
-
-inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
-  return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed);
-}
-
-inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
-  return ((AtomicLocation32)ptr)->load(std::memory_order_acquire);
-}
-
-inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
-  MemoryBarrier();
-  return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed);
-}
-
-#if defined(ARCH_CPU_64_BITS)
-
-typedef volatile std::atomic<Atomic64>* AtomicLocation64;
-static_assert(sizeof(*(AtomicLocation64) nullptr) == sizeof(Atomic64),
-              "incompatible 64-bit atomic layout");
-
-inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
-                                         Atomic64 old_value,
-                                         Atomic64 new_value) {
-  ((AtomicLocation64)ptr)
-      ->compare_exchange_strong(old_value,
-                                new_value,
-                                std::memory_order_relaxed,
-                                std::memory_order_relaxed);
-  return old_value;
-}
-
-inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
-                                         Atomic64 new_value) {
-  return ((AtomicLocation64)ptr)
-      ->exchange(new_value, std::memory_order_relaxed);
-}
-
-inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
-                                          Atomic64 increment) {
-  return increment +
-         ((AtomicLocation64)ptr)
-             ->fetch_add(increment, std::memory_order_relaxed);
-}
-
-inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
-                                        Atomic64 increment) {
-  return increment + ((AtomicLocation64)ptr)->fetch_add(increment);
-}
-
-inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value,
-                                       Atomic64 new_value) {
-  ((AtomicLocation64)ptr)
-      ->compare_exchange_strong(old_value,
-                                new_value,
-                                std::memory_order_acquire,
-                                std::memory_order_acquire);
-  return old_value;
-}
-
-inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value,
-                                       Atomic64 new_value) {
-  ((AtomicLocation64)ptr)
-      ->compare_exchange_strong(old_value,
-                                new_value,
-                                std::memory_order_release,
-                                std::memory_order_relaxed);
-  return old_value;
-}
-
-inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
-  ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed);
-}
-
-inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
-  ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed);
-  MemoryBarrier();
-}
-
-inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
-  ((AtomicLocation64)ptr)->store(value, std::memory_order_release);
-}
-
-inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
-  return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed);
-}
-
-inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
-  return ((AtomicLocation64)ptr)->load(std::memory_order_acquire);
-}
-
-inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
-  MemoryBarrier();
-  return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed);
-}
-
-#endif  // defined(ARCH_CPU_64_BITS)
-}  // namespace subtle
-}  // namespace base
-
-#endif  // BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/base_export.h b/native/zucchini/vendor/libchrome/base/base_export.h
deleted file mode 100644
index cf7ebd7..0000000
--- a/native/zucchini/vendor/libchrome/base/base_export.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_BASE_EXPORT_H_
-#define BASE_BASE_EXPORT_H_
-
-#if defined(COMPONENT_BUILD)
-#if defined(WIN32)
-
-#if defined(BASE_IMPLEMENTATION)
-#define BASE_EXPORT __declspec(dllexport)
-#else
-#define BASE_EXPORT __declspec(dllimport)
-#endif  // defined(BASE_IMPLEMENTATION)
-
-#else  // defined(WIN32)
-#if defined(BASE_IMPLEMENTATION)
-#define BASE_EXPORT __attribute__((visibility("default")))
-#else
-#define BASE_EXPORT
-#endif  // defined(BASE_IMPLEMENTATION)
-#endif
-
-#else  // defined(COMPONENT_BUILD)
-#define BASE_EXPORT
-#endif
-
-#endif  // BASE_BASE_EXPORT_H_
diff --git a/native/zucchini/vendor/libchrome/base/base_switches.h b/native/zucchini/vendor/libchrome/base/base_switches.h
deleted file mode 100644
index 4ef070d..0000000
--- a/native/zucchini/vendor/libchrome/base/base_switches.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Defines all the "base" command-line switches.
-
-#ifndef BASE_BASE_SWITCHES_H_
-#define BASE_BASE_SWITCHES_H_
-
-#include "build/build_config.h"
-
-namespace switches {
-
-extern const char kDisableBackgroundTasks[];
-extern const char kDisableBreakpad[];
-extern const char kDisableFeatures[];
-extern const char kDisableLowEndDeviceMode[];
-extern const char kEnableCrashReporter[];
-extern const char kEnableFeatures[];
-extern const char kEnableLowEndDeviceMode[];
-extern const char kForceFieldTrials[];
-extern const char kFullMemoryCrashReport[];
-extern const char kNoErrorDialogs[];
-extern const char kProfilingFile[];
-extern const char kTestChildProcess[];
-extern const char kTestDoNotInitializeIcu[];
-extern const char kTraceToFile[];
-extern const char kTraceToFileName[];
-extern const char kV[];
-extern const char kVModule[];
-extern const char kWaitForDebugger[];
-
-#if defined(OS_WIN)
-extern const char kDisableUsbKeyboardDetect[];
-#endif
-
-#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
-extern const char kDisableDevShmUsage[];
-#endif
-
-#if defined(OS_POSIX)
-extern const char kEnableCrashReporterForTesting[];
-#endif
-
-#if defined(OS_ANDROID)
-extern const char kOrderfileMemoryOptimization[];
-#endif
-
-}  // namespace switches
-
-#endif  // BASE_BASE_SWITCHES_H_
diff --git a/native/zucchini/vendor/libchrome/base/bind.h b/native/zucchini/vendor/libchrome/base/bind.h
deleted file mode 100644
index 66d5d82..0000000
--- a/native/zucchini/vendor/libchrome/base/bind.h
+++ /dev/null
@@ -1,482 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_BIND_H_
-#define BASE_BIND_H_
-
-#include <utility>
-
-#include "base/bind_internal.h"
-#include "base/compiler_specific.h"
-#include "build/build_config.h"
-
-#if defined(OS_MACOSX) && !HAS_FEATURE(objc_arc)
-#include "base/mac/scoped_block.h"
-#endif
-
-// -----------------------------------------------------------------------------
-// Usage documentation
-// -----------------------------------------------------------------------------
-//
-// Overview:
-// base::BindOnce() and base::BindRepeating() are helpers for creating
-// base::OnceCallback and base::RepeatingCallback objects respectively.
-//
-// For a runnable object of n-arity, the base::Bind*() family allows partial
-// application of the first m arguments. The remaining n - m arguments must be
-// passed when invoking the callback with Run().
-//
-//   // The first argument is bound at callback creation; the remaining
-//   // two must be passed when calling Run() on the callback object.
-//   base::OnceCallback<void(int, long)> cb = base::BindOnce(
-//       [](short x, int y, long z) { return x * y * z; }, 42);
-//
-// When binding to a method, the receiver object must also be specified at
-// callback creation time. When Run() is invoked, the method will be invoked on
-// the specified receiver object.
-//
-//   class C : public base::RefCounted<C> { void F(); };
-//   auto instance = base::MakeRefCounted<C>();
-//   auto cb = base::BindOnce(&C::F, instance);
-//   cb.Run();  // Identical to instance->F()
-//
-// base::Bind is currently a type alias for base::BindRepeating(). In the
-// future, we expect to flip this to default to base::BindOnce().
-//
-// See //docs/callback.md for the full documentation.
-//
-// -----------------------------------------------------------------------------
-// Implementation notes
-// -----------------------------------------------------------------------------
-//
-// If you're reading the implementation, before proceeding further, you should
-// read the top comment of base/bind_internal.h for a definition of common
-// terms and concepts.
-
-namespace base {
-
-namespace internal {
-
-// IsOnceCallback<T> is a std::true_type if |T| is a OnceCallback.
-template <typename T>
-struct IsOnceCallback : std::false_type {};
-
-template <typename Signature>
-struct IsOnceCallback<OnceCallback<Signature>> : std::true_type {};
-
-// Helper to assert that parameter |i| of type |Arg| can be bound, which means:
-// - |Arg| can be retained internally as |Storage|.
-// - |Arg| can be forwarded as |Unwrapped| to |Param|.
-template <size_t i,
-          typename Arg,
-          typename Storage,
-          typename Unwrapped,
-          typename Param>
-struct AssertConstructible {
- private:
-  static constexpr bool param_is_forwardable =
-      std::is_constructible<Param, Unwrapped>::value;
-  // Unlike the check for binding into storage below, the check for
-  // forwardability drops the const qualifier for repeating callbacks. This is
-  // to try to catch instances where std::move()--which forwards as a const
-  // reference with repeating callbacks--is used instead of base::Passed().
-  static_assert(
-      param_is_forwardable ||
-          !std::is_constructible<Param, std::decay_t<Unwrapped>&&>::value,
-      "Bound argument |i| is move-only but will be forwarded by copy. "
-      "Ensure |Arg| is bound using base::Passed(), not std::move().");
-  static_assert(
-      param_is_forwardable,
-      "Bound argument |i| of type |Arg| cannot be forwarded as "
-      "|Unwrapped| to the bound functor, which declares it as |Param|.");
-
-  static constexpr bool arg_is_storable =
-      std::is_constructible<Storage, Arg>::value;
-  static_assert(arg_is_storable ||
-                    !std::is_constructible<Storage, std::decay_t<Arg>&&>::value,
-                "Bound argument |i| is move-only but will be bound by copy. "
-                "Ensure |Arg| is mutable and bound using std::move().");
-  static_assert(arg_is_storable,
-                "Bound argument |i| of type |Arg| cannot be converted and "
-                "bound as |Storage|.");
-};
-
-// Takes three same-length TypeLists, and applies AssertConstructible for each
-// triples.
-template <typename Index,
-          typename Args,
-          typename UnwrappedTypeList,
-          typename ParamsList>
-struct AssertBindArgsValidity;
-
-template <size_t... Ns,
-          typename... Args,
-          typename... Unwrapped,
-          typename... Params>
-struct AssertBindArgsValidity<std::index_sequence<Ns...>,
-                              TypeList<Args...>,
-                              TypeList<Unwrapped...>,
-                              TypeList<Params...>>
-    : AssertConstructible<Ns, Args, std::decay_t<Args>, Unwrapped, Params>... {
-  static constexpr bool ok = true;
-};
-
-// The implementation of TransformToUnwrappedType below.
-template <bool is_once, typename T>
-struct TransformToUnwrappedTypeImpl;
-
-template <typename T>
-struct TransformToUnwrappedTypeImpl<true, T> {
-  using StoredType = std::decay_t<T>;
-  using ForwardType = StoredType&&;
-  using Unwrapped = decltype(Unwrap(std::declval<ForwardType>()));
-};
-
-template <typename T>
-struct TransformToUnwrappedTypeImpl<false, T> {
-  using StoredType = std::decay_t<T>;
-  using ForwardType = const StoredType&;
-  using Unwrapped = decltype(Unwrap(std::declval<ForwardType>()));
-};
-
-// Transform |T| into `Unwrapped` type, which is passed to the target function.
-// Example:
-//   In is_once == true case,
-//     `int&&` -> `int&&`,
-//     `const int&` -> `int&&`,
-//     `OwnedWrapper<int>&` -> `int*&&`.
-//   In is_once == false case,
-//     `int&&` -> `const int&`,
-//     `const int&` -> `const int&`,
-//     `OwnedWrapper<int>&` -> `int* const &`.
-template <bool is_once, typename T>
-using TransformToUnwrappedType =
-    typename TransformToUnwrappedTypeImpl<is_once, T>::Unwrapped;
-
-// Transforms |Args| into `Unwrapped` types, and packs them into a TypeList.
-// If |is_method| is true, tries to dereference the first argument to support
-// smart pointers.
-template <bool is_once, bool is_method, typename... Args>
-struct MakeUnwrappedTypeListImpl {
-  using Type = TypeList<TransformToUnwrappedType<is_once, Args>...>;
-};
-
-// Performs special handling for this pointers.
-// Example:
-//   int* -> int*,
-//   std::unique_ptr<int> -> int*.
-template <bool is_once, typename Receiver, typename... Args>
-struct MakeUnwrappedTypeListImpl<is_once, true, Receiver, Args...> {
-  using UnwrappedReceiver = TransformToUnwrappedType<is_once, Receiver>;
-  using Type = TypeList<decltype(&*std::declval<UnwrappedReceiver>()),
-                        TransformToUnwrappedType<is_once, Args>...>;
-};
-
-template <bool is_once, bool is_method, typename... Args>
-using MakeUnwrappedTypeList =
-    typename MakeUnwrappedTypeListImpl<is_once, is_method, Args...>::Type;
-
-}  // namespace internal
-
-// Bind as OnceCallback.
-template <typename Functor, typename... Args>
-inline OnceCallback<MakeUnboundRunType<Functor, Args...>>
-BindOnce(Functor&& functor, Args&&... args) {
-  static_assert(!internal::IsOnceCallback<std::decay_t<Functor>>() ||
-                    (std::is_rvalue_reference<Functor&&>() &&
-                     !std::is_const<std::remove_reference_t<Functor>>()),
-                "BindOnce requires non-const rvalue for OnceCallback binding."
-                " I.e.: base::BindOnce(std::move(callback)).");
-
-  // This block checks if each |args| matches to the corresponding params of the
-  // target function. This check does not affect the behavior of Bind, but its
-  // error message should be more readable.
-  using Helper = internal::BindTypeHelper<Functor, Args...>;
-  using FunctorTraits = typename Helper::FunctorTraits;
-  using BoundArgsList = typename Helper::BoundArgsList;
-  using UnwrappedArgsList =
-      internal::MakeUnwrappedTypeList<true, FunctorTraits::is_method,
-                                      Args&&...>;
-  using BoundParamsList = typename Helper::BoundParamsList;
-  static_assert(internal::AssertBindArgsValidity<
-                    std::make_index_sequence<Helper::num_bounds>, BoundArgsList,
-                    UnwrappedArgsList, BoundParamsList>::ok,
-                "The bound args need to be convertible to the target params.");
-
-  using BindState = internal::MakeBindStateType<Functor, Args...>;
-  using UnboundRunType = MakeUnboundRunType<Functor, Args...>;
-  using Invoker = internal::Invoker<BindState, UnboundRunType>;
-  using CallbackType = OnceCallback<UnboundRunType>;
-
-  // Store the invoke func into PolymorphicInvoke before casting it to
-  // InvokeFuncStorage, so that we can ensure its type matches to
-  // PolymorphicInvoke, to which CallbackType will cast back.
-  using PolymorphicInvoke = typename CallbackType::PolymorphicInvoke;
-  PolymorphicInvoke invoke_func = &Invoker::RunOnce;
-
-  using InvokeFuncStorage = internal::BindStateBase::InvokeFuncStorage;
-  return CallbackType(new BindState(
-      reinterpret_cast<InvokeFuncStorage>(invoke_func),
-      std::forward<Functor>(functor),
-      std::forward<Args>(args)...));
-}
-
-// Bind as RepeatingCallback.
-template <typename Functor, typename... Args>
-inline RepeatingCallback<MakeUnboundRunType<Functor, Args...>>
-BindRepeating(Functor&& functor, Args&&... args) {
-  static_assert(
-      !internal::IsOnceCallback<std::decay_t<Functor>>(),
-      "BindRepeating cannot bind OnceCallback. Use BindOnce with std::move().");
-
-  // This block checks if each |args| matches to the corresponding params of the
-  // target function. This check does not affect the behavior of Bind, but its
-  // error message should be more readable.
-  using Helper = internal::BindTypeHelper<Functor, Args...>;
-  using FunctorTraits = typename Helper::FunctorTraits;
-  using BoundArgsList = typename Helper::BoundArgsList;
-  using UnwrappedArgsList =
-      internal::MakeUnwrappedTypeList<false, FunctorTraits::is_method,
-                                      Args&&...>;
-  using BoundParamsList = typename Helper::BoundParamsList;
-  static_assert(internal::AssertBindArgsValidity<
-                    std::make_index_sequence<Helper::num_bounds>, BoundArgsList,
-                    UnwrappedArgsList, BoundParamsList>::ok,
-                "The bound args need to be convertible to the target params.");
-
-  using BindState = internal::MakeBindStateType<Functor, Args...>;
-  using UnboundRunType = MakeUnboundRunType<Functor, Args...>;
-  using Invoker = internal::Invoker<BindState, UnboundRunType>;
-  using CallbackType = RepeatingCallback<UnboundRunType>;
-
-  // Store the invoke func into PolymorphicInvoke before casting it to
-  // InvokeFuncStorage, so that we can ensure its type matches to
-  // PolymorphicInvoke, to which CallbackType will cast back.
-  using PolymorphicInvoke = typename CallbackType::PolymorphicInvoke;
-  PolymorphicInvoke invoke_func = &Invoker::Run;
-
-  using InvokeFuncStorage = internal::BindStateBase::InvokeFuncStorage;
-  return CallbackType(new BindState(
-      reinterpret_cast<InvokeFuncStorage>(invoke_func),
-      std::forward<Functor>(functor),
-      std::forward<Args>(args)...));
-}
-
-// Unannotated Bind.
-// TODO(tzik): Deprecate this and migrate to OnceCallback and
-// RepeatingCallback, once they get ready.
-template <typename Functor, typename... Args>
-inline Callback<MakeUnboundRunType<Functor, Args...>>
-Bind(Functor&& functor, Args&&... args) {
-  return base::BindRepeating(std::forward<Functor>(functor),
-                             std::forward<Args>(args)...);
-}
-
-// Special cases for binding to a base::Callback without extra bound arguments.
-template <typename Signature>
-OnceCallback<Signature> BindOnce(OnceCallback<Signature> closure) {
-  return closure;
-}
-
-template <typename Signature>
-RepeatingCallback<Signature> BindRepeating(
-    RepeatingCallback<Signature> closure) {
-  return closure;
-}
-
-template <typename Signature>
-Callback<Signature> Bind(Callback<Signature> closure) {
-  return closure;
-}
-
-// Unretained() allows Bind() to bind a non-refcounted class, and to disable
-// refcounting on arguments that are refcounted objects.
-//
-// EXAMPLE OF Unretained():
-//
-//   class Foo {
-//    public:
-//     void func() { cout << "Foo:f" << endl; }
-//   };
-//
-//   // In some function somewhere.
-//   Foo foo;
-//   Closure foo_callback =
-//       Bind(&Foo::func, Unretained(&foo));
-//   foo_callback.Run();  // Prints "Foo:f".
-//
-// Without the Unretained() wrapper on |&foo|, the above call would fail
-// to compile because Foo does not support the AddRef() and Release() methods.
-template <typename T>
-static inline internal::UnretainedWrapper<T> Unretained(T* o) {
-  return internal::UnretainedWrapper<T>(o);
-}
-
-// RetainedRef() accepts a ref counted object and retains a reference to it.
-// When the callback is called, the object is passed as a raw pointer.
-//
-// EXAMPLE OF RetainedRef():
-//
-//    void foo(RefCountedBytes* bytes) {}
-//
-//    scoped_refptr<RefCountedBytes> bytes = ...;
-//    Closure callback = Bind(&foo, base::RetainedRef(bytes));
-//    callback.Run();
-//
-// Without RetainedRef, the scoped_refptr would try to implicitly convert to
-// a raw pointer and fail compilation:
-//
-//    Closure callback = Bind(&foo, bytes); // ERROR!
-template <typename T>
-static inline internal::RetainedRefWrapper<T> RetainedRef(T* o) {
-  return internal::RetainedRefWrapper<T>(o);
-}
-template <typename T>
-static inline internal::RetainedRefWrapper<T> RetainedRef(scoped_refptr<T> o) {
-  return internal::RetainedRefWrapper<T>(std::move(o));
-}
-
-// ConstRef() allows binding a constant reference to an argument rather
-// than a copy.
-//
-// EXAMPLE OF ConstRef():
-//
-//   void foo(int arg) { cout << arg << endl }
-//
-//   int n = 1;
-//   Closure no_ref = Bind(&foo, n);
-//   Closure has_ref = Bind(&foo, ConstRef(n));
-//
-//   no_ref.Run();  // Prints "1"
-//   has_ref.Run();  // Prints "1"
-//
-//   n = 2;
-//   no_ref.Run();  // Prints "1"
-//   has_ref.Run();  // Prints "2"
-//
-// Note that because ConstRef() takes a reference on |n|, |n| must outlive all
-// its bound callbacks.
-template <typename T>
-static inline internal::ConstRefWrapper<T> ConstRef(const T& o) {
-  return internal::ConstRefWrapper<T>(o);
-}
-
-// Owned() transfers ownership of an object to the Callback resulting from
-// bind; the object will be deleted when the Callback is deleted.
-//
-// EXAMPLE OF Owned():
-//
-//   void foo(int* arg) { cout << *arg << endl }
-//
-//   int* pn = new int(1);
-//   Closure foo_callback = Bind(&foo, Owned(pn));
-//
-//   foo_callback.Run();  // Prints "1"
-//   foo_callback.Run();  // Prints "1"
-//   *n = 2;
-//   foo_callback.Run();  // Prints "2"
-//
-//   foo_callback.Reset();  // |pn| is deleted.  Also will happen when
-//                          // |foo_callback| goes out of scope.
-//
-// Without Owned(), someone would have to know to delete |pn| when the last
-// reference to the Callback is deleted.
-template <typename T>
-static inline internal::OwnedWrapper<T> Owned(T* o) {
-  return internal::OwnedWrapper<T>(o);
-}
-
-// Passed() is for transferring movable-but-not-copyable types (eg. unique_ptr)
-// through a Callback. Logically, this signifies a destructive transfer of
-// the state of the argument into the target function.  Invoking
-// Callback::Run() twice on a Callback that was created with a Passed()
-// argument will CHECK() because the first invocation would have already
-// transferred ownership to the target function.
-//
-// Note that Passed() is not necessary with BindOnce(), as std::move() does the
-// same thing. Avoid Passed() in favor of std::move() with BindOnce().
-//
-// EXAMPLE OF Passed():
-//
-//   void TakesOwnership(std::unique_ptr<Foo> arg) { }
-//   std::unique_ptr<Foo> CreateFoo() { return std::make_unique<Foo>();
-//   }
-//
-//   auto f = std::make_unique<Foo>();
-//
-//   // |cb| is given ownership of Foo(). |f| is now NULL.
-//   // You can use std::move(f) in place of &f, but it's more verbose.
-//   Closure cb = Bind(&TakesOwnership, Passed(&f));
-//
-//   // Run was never called so |cb| still owns Foo() and deletes
-//   // it on Reset().
-//   cb.Reset();
-//
-//   // |cb| is given a new Foo created by CreateFoo().
-//   cb = Bind(&TakesOwnership, Passed(CreateFoo()));
-//
-//   // |arg| in TakesOwnership() is given ownership of Foo(). |cb|
-//   // no longer owns Foo() and, if reset, would not delete Foo().
-//   cb.Run();  // Foo() is now transferred to |arg| and deleted.
-//   cb.Run();  // This CHECK()s since Foo() already been used once.
-//
-// We offer 2 syntaxes for calling Passed().  The first takes an rvalue and
-// is best suited for use with the return value of a function or other temporary
-// rvalues. The second takes a pointer to the scoper and is just syntactic sugar
-// to avoid having to write Passed(std::move(scoper)).
-//
-// Both versions of Passed() prevent T from being an lvalue reference. The first
-// via use of enable_if, and the second takes a T* which will not bind to T&.
-template <typename T,
-          std::enable_if_t<!std::is_lvalue_reference<T>::value>* = nullptr>
-static inline internal::PassedWrapper<T> Passed(T&& scoper) {
-  return internal::PassedWrapper<T>(std::move(scoper));
-}
-template <typename T>
-static inline internal::PassedWrapper<T> Passed(T* scoper) {
-  return internal::PassedWrapper<T>(std::move(*scoper));
-}
-
-// IgnoreResult() is used to adapt a function or Callback with a return type to
-// one with a void return. This is most useful if you have a function with,
-// say, a pesky ignorable bool return that you want to use with PostTask or
-// something else that expect a Callback with a void return.
-//
-// EXAMPLE OF IgnoreResult():
-//
-//   int DoSomething(int arg) { cout << arg << endl; }
-//
-//   // Assign to a Callback with a void return type.
-//   Callback<void(int)> cb = Bind(IgnoreResult(&DoSomething));
-//   cb->Run(1);  // Prints "1".
-//
-//   // Prints "1" on |ml|.
-//   ml->PostTask(FROM_HERE, Bind(IgnoreResult(&DoSomething), 1);
-template <typename T>
-static inline internal::IgnoreResultHelper<T> IgnoreResult(T data) {
-  return internal::IgnoreResultHelper<T>(std::move(data));
-}
-
-#if defined(OS_MACOSX) && !HAS_FEATURE(objc_arc)
-
-// RetainBlock() is used to adapt an Objective-C block when Automated Reference
-// Counting (ARC) is disabled. This is unnecessary when ARC is enabled, as the
-// BindOnce and BindRepeating already support blocks then.
-//
-// EXAMPLE OF RetainBlock():
-//
-//   // Wrap the block and bind it to a callback.
-//   Callback<void(int)> cb = Bind(RetainBlock(^(int n) { NSLog(@"%d", n); }));
-//   cb.Run(1);  // Logs "1".
-template <typename R, typename... Args>
-base::mac::ScopedBlock<R (^)(Args...)> RetainBlock(R (^block)(Args...)) {
-  return base::mac::ScopedBlock<R (^)(Args...)>(block,
-                                                base::scoped_policy::RETAIN);
-}
-
-#endif  // defined(OS_MACOSX) && !HAS_FEATURE(objc_arc)
-
-}  // namespace base
-
-#endif  // BASE_BIND_H_
diff --git a/native/zucchini/vendor/libchrome/base/bind_internal.h b/native/zucchini/vendor/libchrome/base/bind_internal.h
deleted file mode 100644
index 4ebecfa..0000000
--- a/native/zucchini/vendor/libchrome/base/bind_internal.h
+++ /dev/null
@@ -1,971 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_BIND_INTERNAL_H_
-#define BASE_BIND_INTERNAL_H_
-
-#include <stddef.h>
-
-#include <type_traits>
-#include <utility>
-
-#include "base/callback_internal.h"
-#include "base/compiler_specific.h"
-#include "base/memory/raw_scoped_refptr_mismatch_checker.h"
-#include "base/memory/weak_ptr.h"
-#include "base/template_util.h"
-#include "build/build_config.h"
-
-#if defined(OS_MACOSX) && !HAS_FEATURE(objc_arc)
-#include "base/mac/scoped_block.h"
-#endif
-
-// See base/callback.h for user documentation.
-//
-//
-// CONCEPTS:
-//  Functor -- A movable type representing something that should be called.
-//             All function pointers and Callback<> are functors even if the
-//             invocation syntax differs.
-//  RunType -- A function type (as opposed to function _pointer_ type) for
-//             a Callback<>::Run().  Usually just a convenience typedef.
-//  (Bound)Args -- A set of types that stores the arguments.
-//
-// Types:
-//  ForceVoidReturn<> -- Helper class for translating function signatures to
-//                       equivalent forms with a "void" return type.
-//  FunctorTraits<> -- Type traits used to determine the correct RunType and
-//                     invocation manner for a Functor.  This is where function
-//                     signature adapters are applied.
-//  InvokeHelper<> -- Take a Functor + arguments and actully invokes it.
-//                    Handle the differing syntaxes needed for WeakPtr<>
-//                    support.  This is separate from Invoker to avoid creating
-//                    multiple version of Invoker<>.
-//  Invoker<> -- Unwraps the curried parameters and executes the Functor.
-//  BindState<> -- Stores the curried parameters, and is the main entry point
-//                 into the Bind() system.
-
-namespace base {
-
-template <typename T>
-struct IsWeakReceiver;
-
-template <typename>
-struct BindUnwrapTraits;
-
-template <typename Functor, typename BoundArgsTuple, typename SFINAE = void>
-struct CallbackCancellationTraits;
-
-namespace internal {
-
-template <typename Functor, typename SFINAE = void>
-struct FunctorTraits;
-
-template <typename T>
-class UnretainedWrapper {
- public:
-  explicit UnretainedWrapper(T* o) : ptr_(o) {}
-  T* get() const { return ptr_; }
-
- private:
-  T* ptr_;
-};
-
-template <typename T>
-class ConstRefWrapper {
- public:
-  explicit ConstRefWrapper(const T& o) : ptr_(&o) {}
-  const T& get() const { return *ptr_; }
-
- private:
-  const T* ptr_;
-};
-
-template <typename T>
-class RetainedRefWrapper {
- public:
-  explicit RetainedRefWrapper(T* o) : ptr_(o) {}
-  explicit RetainedRefWrapper(scoped_refptr<T> o) : ptr_(std::move(o)) {}
-  T* get() const { return ptr_.get(); }
-
- private:
-  scoped_refptr<T> ptr_;
-};
-
-template <typename T>
-struct IgnoreResultHelper {
-  explicit IgnoreResultHelper(T functor) : functor_(std::move(functor)) {}
-  explicit operator bool() const { return !!functor_; }
-
-  T functor_;
-};
-
-// An alternate implementation is to avoid the destructive copy, and instead
-// specialize ParamTraits<> for OwnedWrapper<> to change the StorageType to
-// a class that is essentially a std::unique_ptr<>.
-//
-// The current implementation has the benefit though of leaving ParamTraits<>
-// fully in callback_internal.h as well as avoiding type conversions during
-// storage.
-template <typename T>
-class OwnedWrapper {
- public:
-  explicit OwnedWrapper(T* o) : ptr_(o) {}
-  ~OwnedWrapper() { delete ptr_; }
-  T* get() const { return ptr_; }
-  OwnedWrapper(OwnedWrapper&& other) {
-    ptr_ = other.ptr_;
-    other.ptr_ = NULL;
-  }
-
- private:
-  mutable T* ptr_;
-};
-
-// PassedWrapper is a copyable adapter for a scoper that ignores const.
-//
-// It is needed to get around the fact that Bind() takes a const reference to
-// all its arguments.  Because Bind() takes a const reference to avoid
-// unnecessary copies, it is incompatible with movable-but-not-copyable
-// types; doing a destructive "move" of the type into Bind() would violate
-// the const correctness.
-//
-// This conundrum cannot be solved without either C++11 rvalue references or
-// a O(2^n) blowup of Bind() templates to handle each combination of regular
-// types and movable-but-not-copyable types.  Thus we introduce a wrapper type
-// that is copyable to transmit the correct type information down into
-// BindState<>. Ignoring const in this type makes sense because it is only
-// created when we are explicitly trying to do a destructive move.
-//
-// Two notes:
-//  1) PassedWrapper supports any type that has a move constructor, however
-//     the type will need to be specifically whitelisted in order for it to be
-//     bound to a Callback. We guard this explicitly at the call of Passed()
-//     to make for clear errors. Things not given to Passed() will be forwarded
-//     and stored by value which will not work for general move-only types.
-//  2) is_valid_ is distinct from NULL because it is valid to bind a "NULL"
-//     scoper to a Callback and allow the Callback to execute once.
-template <typename T>
-class PassedWrapper {
- public:
-  explicit PassedWrapper(T&& scoper)
-      : is_valid_(true), scoper_(std::move(scoper)) {}
-  PassedWrapper(PassedWrapper&& other)
-      : is_valid_(other.is_valid_), scoper_(std::move(other.scoper_)) {}
-  T Take() const {
-    CHECK(is_valid_);
-    is_valid_ = false;
-    return std::move(scoper_);
-  }
-
- private:
-  mutable bool is_valid_;
-  mutable T scoper_;
-};
-
-template <typename T>
-using Unwrapper = BindUnwrapTraits<std::decay_t<T>>;
-
-template <typename T>
-decltype(auto) Unwrap(T&& o) {
-  return Unwrapper<T>::Unwrap(std::forward<T>(o));
-}
-
-// IsWeakMethod is a helper that determine if we are binding a WeakPtr<> to a
-// method.  It is used internally by Bind() to select the correct
-// InvokeHelper that will no-op itself in the event the WeakPtr<> for
-// the target object is invalidated.
-//
-// The first argument should be the type of the object that will be received by
-// the method.
-template <bool is_method, typename... Args>
-struct IsWeakMethod : std::false_type {};
-
-template <typename T, typename... Args>
-struct IsWeakMethod<true, T, Args...> : IsWeakReceiver<T> {};
-
-// Packs a list of types to hold them in a single type.
-template <typename... Types>
-struct TypeList {};
-
-// Used for DropTypeListItem implementation.
-template <size_t n, typename List>
-struct DropTypeListItemImpl;
-
-// Do not use enable_if and SFINAE here to avoid MSVC2013 compile failure.
-template <size_t n, typename T, typename... List>
-struct DropTypeListItemImpl<n, TypeList<T, List...>>
-    : DropTypeListItemImpl<n - 1, TypeList<List...>> {};
-
-template <typename T, typename... List>
-struct DropTypeListItemImpl<0, TypeList<T, List...>> {
-  using Type = TypeList<T, List...>;
-};
-
-template <>
-struct DropTypeListItemImpl<0, TypeList<>> {
-  using Type = TypeList<>;
-};
-
-// A type-level function that drops |n| list item from given TypeList.
-template <size_t n, typename List>
-using DropTypeListItem = typename DropTypeListItemImpl<n, List>::Type;
-
-// Used for TakeTypeListItem implementation.
-template <size_t n, typename List, typename... Accum>
-struct TakeTypeListItemImpl;
-
-// Do not use enable_if and SFINAE here to avoid MSVC2013 compile failure.
-template <size_t n, typename T, typename... List, typename... Accum>
-struct TakeTypeListItemImpl<n, TypeList<T, List...>, Accum...>
-    : TakeTypeListItemImpl<n - 1, TypeList<List...>, Accum..., T> {};
-
-template <typename T, typename... List, typename... Accum>
-struct TakeTypeListItemImpl<0, TypeList<T, List...>, Accum...> {
-  using Type = TypeList<Accum...>;
-};
-
-template <typename... Accum>
-struct TakeTypeListItemImpl<0, TypeList<>, Accum...> {
-  using Type = TypeList<Accum...>;
-};
-
-// A type-level function that takes first |n| list item from given TypeList.
-// E.g. TakeTypeListItem<3, TypeList<A, B, C, D>> is evaluated to
-// TypeList<A, B, C>.
-template <size_t n, typename List>
-using TakeTypeListItem = typename TakeTypeListItemImpl<n, List>::Type;
-
-// Used for ConcatTypeLists implementation.
-template <typename List1, typename List2>
-struct ConcatTypeListsImpl;
-
-template <typename... Types1, typename... Types2>
-struct ConcatTypeListsImpl<TypeList<Types1...>, TypeList<Types2...>> {
-  using Type = TypeList<Types1..., Types2...>;
-};
-
-// A type-level function that concats two TypeLists.
-template <typename List1, typename List2>
-using ConcatTypeLists = typename ConcatTypeListsImpl<List1, List2>::Type;
-
-// Used for MakeFunctionType implementation.
-template <typename R, typename ArgList>
-struct MakeFunctionTypeImpl;
-
-template <typename R, typename... Args>
-struct MakeFunctionTypeImpl<R, TypeList<Args...>> {
-  // MSVC 2013 doesn't support Type Alias of function types.
-  // Revisit this after we update it to newer version.
-  typedef R Type(Args...);
-};
-
-// A type-level function that constructs a function type that has |R| as its
-// return type and has TypeLists items as its arguments.
-template <typename R, typename ArgList>
-using MakeFunctionType = typename MakeFunctionTypeImpl<R, ArgList>::Type;
-
-// Used for ExtractArgs and ExtractReturnType.
-template <typename Signature>
-struct ExtractArgsImpl;
-
-template <typename R, typename... Args>
-struct ExtractArgsImpl<R(Args...)> {
-  using ReturnType = R;
-  using ArgsList = TypeList<Args...>;
-};
-
-// A type-level function that extracts function arguments into a TypeList.
-// E.g. ExtractArgs<R(A, B, C)> is evaluated to TypeList<A, B, C>.
-template <typename Signature>
-using ExtractArgs = typename ExtractArgsImpl<Signature>::ArgsList;
-
-// A type-level function that extracts the return type of a function.
-// E.g. ExtractReturnType<R(A, B, C)> is evaluated to R.
-template <typename Signature>
-using ExtractReturnType = typename ExtractArgsImpl<Signature>::ReturnType;
-
-template <typename Callable,
-          typename Signature = decltype(&Callable::operator())>
-struct ExtractCallableRunTypeImpl;
-
-template <typename Callable, typename R, typename... Args>
-struct ExtractCallableRunTypeImpl<Callable, R (Callable::*)(Args...)> {
-  using Type = R(Args...);
-};
-
-template <typename Callable, typename R, typename... Args>
-struct ExtractCallableRunTypeImpl<Callable, R (Callable::*)(Args...) const> {
-  using Type = R(Args...);
-};
-
-// Evaluated to RunType of the given callable type.
-// Example:
-//   auto f = [](int, char*) { return 0.1; };
-//   ExtractCallableRunType<decltype(f)>
-//   is evaluated to
-//   double(int, char*);
-template <typename Callable>
-using ExtractCallableRunType =
-    typename ExtractCallableRunTypeImpl<Callable>::Type;
-
-// IsCallableObject<Functor> is std::true_type if |Functor| has operator().
-// Otherwise, it's std::false_type.
-// Example:
-//   IsCallableObject<void(*)()>::value is false.
-//
-//   struct Foo {};
-//   IsCallableObject<void(Foo::*)()>::value is false.
-//
-//   int i = 0;
-//   auto f = [i]() {};
-//   IsCallableObject<decltype(f)>::value is false.
-template <typename Functor, typename SFINAE = void>
-struct IsCallableObject : std::false_type {};
-
-template <typename Callable>
-struct IsCallableObject<Callable, void_t<decltype(&Callable::operator())>>
-    : std::true_type {};
-
-// HasRefCountedTypeAsRawPtr selects true_type when any of the |Args| is a raw
-// pointer to a RefCounted type.
-// Implementation note: This non-specialized case handles zero-arity case only.
-// Non-zero-arity cases should be handled by the specialization below.
-template <typename... Args>
-struct HasRefCountedTypeAsRawPtr : std::false_type {};
-
-// Implementation note: Select true_type if the first parameter is a raw pointer
-// to a RefCounted type. Otherwise, skip the first parameter and check rest of
-// parameters recursively.
-template <typename T, typename... Args>
-struct HasRefCountedTypeAsRawPtr<T, Args...>
-    : std::conditional_t<NeedsScopedRefptrButGetsRawPtr<T>::value,
-                         std::true_type,
-                         HasRefCountedTypeAsRawPtr<Args...>> {};
-
-// ForceVoidReturn<>
-//
-// Set of templates that support forcing the function return type to void.
-template <typename Sig>
-struct ForceVoidReturn;
-
-template <typename R, typename... Args>
-struct ForceVoidReturn<R(Args...)> {
-  using RunType = void(Args...);
-};
-
-// FunctorTraits<>
-//
-// See description at top of file.
-template <typename Functor, typename SFINAE>
-struct FunctorTraits;
-
-// For empty callable types.
-// This specialization is intended to allow binding captureless lambdas by
-// base::Bind(), based on the fact that captureless lambdas are empty while
-// capturing lambdas are not. This also allows any functors as far as it's an
-// empty class.
-// Example:
-//
-//   // Captureless lambdas are allowed.
-//   []() {return 42;};
-//
-//   // Capturing lambdas are *not* allowed.
-//   int x;
-//   [x]() {return x;};
-//
-//   // Any empty class with operator() is allowed.
-//   struct Foo {
-//     void operator()() const {}
-//     // No non-static member variable and no virtual functions.
-//   };
-template <typename Functor>
-struct FunctorTraits<Functor,
-                     std::enable_if_t<IsCallableObject<Functor>::value &&
-                                      std::is_empty<Functor>::value>> {
-  using RunType = ExtractCallableRunType<Functor>;
-  static constexpr bool is_method = false;
-  static constexpr bool is_nullable = false;
-
-  template <typename RunFunctor, typename... RunArgs>
-  static ExtractReturnType<RunType> Invoke(RunFunctor&& functor,
-                                           RunArgs&&... args) {
-    return std::forward<RunFunctor>(functor)(std::forward<RunArgs>(args)...);
-  }
-};
-
-// For functions.
-template <typename R, typename... Args>
-struct FunctorTraits<R (*)(Args...)> {
-  using RunType = R(Args...);
-  static constexpr bool is_method = false;
-  static constexpr bool is_nullable = true;
-
-  template <typename Function, typename... RunArgs>
-  static R Invoke(Function&& function, RunArgs&&... args) {
-    return std::forward<Function>(function)(std::forward<RunArgs>(args)...);
-  }
-};
-
-#if defined(OS_WIN) && !defined(ARCH_CPU_X86_64)
-
-// For functions.
-template <typename R, typename... Args>
-struct FunctorTraits<R(__stdcall*)(Args...)> {
-  using RunType = R(Args...);
-  static constexpr bool is_method = false;
-  static constexpr bool is_nullable = true;
-
-  template <typename... RunArgs>
-  static R Invoke(R(__stdcall* function)(Args...), RunArgs&&... args) {
-    return function(std::forward<RunArgs>(args)...);
-  }
-};
-
-// For functions.
-template <typename R, typename... Args>
-struct FunctorTraits<R(__fastcall*)(Args...)> {
-  using RunType = R(Args...);
-  static constexpr bool is_method = false;
-  static constexpr bool is_nullable = true;
-
-  template <typename... RunArgs>
-  static R Invoke(R(__fastcall* function)(Args...), RunArgs&&... args) {
-    return function(std::forward<RunArgs>(args)...);
-  }
-};
-
-#endif  // defined(OS_WIN) && !defined(ARCH_CPU_X86_64)
-
-#if defined(OS_MACOSX)
-
-// Support for Objective-C blocks. There are two implementation depending
-// on whether Automated Reference Counting (ARC) is enabled. When ARC is
-// enabled, then the block itself can be bound as the compiler will ensure
-// its lifetime will be correctly managed. Otherwise, require the block to
-// be wrapped in a base::mac::ScopedBlock (via base::RetainBlock) that will
-// correctly manage the block lifetime.
-//
-// The two implementation ensure that the One Definition Rule (ODR) is not
-// broken (it is not possible to write a template base::RetainBlock that would
-// work correctly both with ARC enabled and disabled).
-
-#if HAS_FEATURE(objc_arc)
-
-template <typename R, typename... Args>
-struct FunctorTraits<R (^)(Args...)> {
-  using RunType = R(Args...);
-  static constexpr bool is_method = false;
-  static constexpr bool is_nullable = true;
-
-  template <typename BlockType, typename... RunArgs>
-  static R Invoke(BlockType&& block, RunArgs&&... args) {
-    // According to LLVM documentation (§ 6.3), "local variables of automatic
-    // storage duration do not have precise lifetime." Use objc_precise_lifetime
-    // to ensure that the Objective-C block is not deallocated until it has
-    // finished executing even if the Callback<> is destroyed during the block
-    // execution.
-    // https://clang.llvm.org/docs/AutomaticReferenceCounting.html#precise-lifetime-semantics
-    __attribute__((objc_precise_lifetime)) R (^scoped_block)(Args...) = block;
-    return scoped_block(std::forward<RunArgs>(args)...);
-  }
-};
-
-#else  // HAS_FEATURE(objc_arc)
-
-template <typename R, typename... Args>
-struct FunctorTraits<base::mac::ScopedBlock<R (^)(Args...)>> {
-  using RunType = R(Args...);
-  static constexpr bool is_method = false;
-  static constexpr bool is_nullable = true;
-
-  template <typename BlockType, typename... RunArgs>
-  static R Invoke(BlockType&& block, RunArgs&&... args) {
-    // Copy the block to ensure that the Objective-C block is not deallocated
-    // until it has finished executing even if the Callback<> is destroyed
-    // during the block execution.
-    base::mac::ScopedBlock<R (^)(Args...)> scoped_block(block);
-    return scoped_block.get()(std::forward<RunArgs>(args)...);
-  }
-};
-
-#endif  // HAS_FEATURE(objc_arc)
-#endif  // defined(OS_MACOSX)
-
-// For methods.
-template <typename R, typename Receiver, typename... Args>
-struct FunctorTraits<R (Receiver::*)(Args...)> {
-  using RunType = R(Receiver*, Args...);
-  static constexpr bool is_method = true;
-  static constexpr bool is_nullable = true;
-
-  template <typename Method, typename ReceiverPtr, typename... RunArgs>
-  static R Invoke(Method method,
-                  ReceiverPtr&& receiver_ptr,
-                  RunArgs&&... args) {
-    return ((*receiver_ptr).*method)(std::forward<RunArgs>(args)...);
-  }
-};
-
-// For const methods.
-template <typename R, typename Receiver, typename... Args>
-struct FunctorTraits<R (Receiver::*)(Args...) const> {
-  using RunType = R(const Receiver*, Args...);
-  static constexpr bool is_method = true;
-  static constexpr bool is_nullable = true;
-
-  template <typename Method, typename ReceiverPtr, typename... RunArgs>
-  static R Invoke(Method method,
-                  ReceiverPtr&& receiver_ptr,
-                  RunArgs&&... args) {
-    return ((*receiver_ptr).*method)(std::forward<RunArgs>(args)...);
-  }
-};
-
-#ifdef __cpp_noexcept_function_type
-// noexcept makes a distinct function type in C++17.
-// I.e. `void(*)()` and `void(*)() noexcept` are same in pre-C++17, and
-// different in C++17.
-template <typename R, typename... Args>
-struct FunctorTraits<R (*)(Args...) noexcept> : FunctorTraits<R (*)(Args...)> {
-};
-
-template <typename R, typename Receiver, typename... Args>
-struct FunctorTraits<R (Receiver::*)(Args...) noexcept>
-    : FunctorTraits<R (Receiver::*)(Args...)> {};
-
-template <typename R, typename Receiver, typename... Args>
-struct FunctorTraits<R (Receiver::*)(Args...) const noexcept>
-    : FunctorTraits<R (Receiver::*)(Args...) const> {};
-#endif
-
-// For IgnoreResults.
-template <typename T>
-struct FunctorTraits<IgnoreResultHelper<T>> : FunctorTraits<T> {
-  using RunType =
-      typename ForceVoidReturn<typename FunctorTraits<T>::RunType>::RunType;
-
-  template <typename IgnoreResultType, typename... RunArgs>
-  static void Invoke(IgnoreResultType&& ignore_result_helper,
-                     RunArgs&&... args) {
-    FunctorTraits<T>::Invoke(
-        std::forward<IgnoreResultType>(ignore_result_helper).functor_,
-        std::forward<RunArgs>(args)...);
-  }
-};
-
-// For OnceCallbacks.
-template <typename R, typename... Args>
-struct FunctorTraits<OnceCallback<R(Args...)>> {
-  using RunType = R(Args...);
-  static constexpr bool is_method = false;
-  static constexpr bool is_nullable = true;
-
-  template <typename CallbackType, typename... RunArgs>
-  static R Invoke(CallbackType&& callback, RunArgs&&... args) {
-    DCHECK(!callback.is_null());
-    return std::forward<CallbackType>(callback).Run(
-        std::forward<RunArgs>(args)...);
-  }
-};
-
-// For RepeatingCallbacks.
-template <typename R, typename... Args>
-struct FunctorTraits<RepeatingCallback<R(Args...)>> {
-  using RunType = R(Args...);
-  static constexpr bool is_method = false;
-  static constexpr bool is_nullable = true;
-
-  template <typename CallbackType, typename... RunArgs>
-  static R Invoke(CallbackType&& callback, RunArgs&&... args) {
-    DCHECK(!callback.is_null());
-    return std::forward<CallbackType>(callback).Run(
-        std::forward<RunArgs>(args)...);
-  }
-};
-
-template <typename Functor>
-using MakeFunctorTraits = FunctorTraits<std::decay_t<Functor>>;
-
-// InvokeHelper<>
-//
-// There are 2 logical InvokeHelper<> specializations: normal, WeakCalls.
-//
-// The normal type just calls the underlying runnable.
-//
-// WeakCalls need special syntax that is applied to the first argument to check
-// if they should no-op themselves.
-template <bool is_weak_call, typename ReturnType>
-struct InvokeHelper;
-
-template <typename ReturnType>
-struct InvokeHelper<false, ReturnType> {
-  template <typename Functor, typename... RunArgs>
-  static inline ReturnType MakeItSo(Functor&& functor, RunArgs&&... args) {
-    using Traits = MakeFunctorTraits<Functor>;
-    return Traits::Invoke(std::forward<Functor>(functor),
-                          std::forward<RunArgs>(args)...);
-  }
-};
-
-template <typename ReturnType>
-struct InvokeHelper<true, ReturnType> {
-  // WeakCalls are only supported for functions with a void return type.
-  // Otherwise, the function result would be undefined if the the WeakPtr<>
-  // is invalidated.
-  static_assert(std::is_void<ReturnType>::value,
-                "weak_ptrs can only bind to methods without return values");
-
-  template <typename Functor, typename BoundWeakPtr, typename... RunArgs>
-  static inline void MakeItSo(Functor&& functor,
-                              BoundWeakPtr&& weak_ptr,
-                              RunArgs&&... args) {
-    if (!weak_ptr)
-      return;
-    using Traits = MakeFunctorTraits<Functor>;
-    Traits::Invoke(std::forward<Functor>(functor),
-                   std::forward<BoundWeakPtr>(weak_ptr),
-                   std::forward<RunArgs>(args)...);
-  }
-};
-
-// Invoker<>
-//
-// See description at the top of the file.
-template <typename StorageType, typename UnboundRunType>
-struct Invoker;
-
-template <typename StorageType, typename R, typename... UnboundArgs>
-struct Invoker<StorageType, R(UnboundArgs...)> {
-  static R RunOnce(BindStateBase* base,
-                   PassingType<UnboundArgs>... unbound_args) {
-    // Local references to make debugger stepping easier. If in a debugger,
-    // you really want to warp ahead and step through the
-    // InvokeHelper<>::MakeItSo() call below.
-    StorageType* storage = static_cast<StorageType*>(base);
-    static constexpr size_t num_bound_args =
-        std::tuple_size<decltype(storage->bound_args_)>::value;
-    return RunImpl(std::move(storage->functor_),
-                   std::move(storage->bound_args_),
-                   std::make_index_sequence<num_bound_args>(),
-                   std::forward<UnboundArgs>(unbound_args)...);
-  }
-
-  static R Run(BindStateBase* base, PassingType<UnboundArgs>... unbound_args) {
-    // Local references to make debugger stepping easier. If in a debugger,
-    // you really want to warp ahead and step through the
-    // InvokeHelper<>::MakeItSo() call below.
-    const StorageType* storage = static_cast<StorageType*>(base);
-    static constexpr size_t num_bound_args =
-        std::tuple_size<decltype(storage->bound_args_)>::value;
-    return RunImpl(storage->functor_, storage->bound_args_,
-                   std::make_index_sequence<num_bound_args>(),
-                   std::forward<UnboundArgs>(unbound_args)...);
-  }
-
- private:
-  template <typename Functor, typename BoundArgsTuple, size_t... indices>
-  static inline R RunImpl(Functor&& functor,
-                          BoundArgsTuple&& bound,
-                          std::index_sequence<indices...>,
-                          UnboundArgs&&... unbound_args) {
-    static constexpr bool is_method = MakeFunctorTraits<Functor>::is_method;
-
-    using DecayedArgsTuple = std::decay_t<BoundArgsTuple>;
-    static constexpr bool is_weak_call =
-        IsWeakMethod<is_method,
-                     std::tuple_element_t<indices, DecayedArgsTuple>...>();
-
-    return InvokeHelper<is_weak_call, R>::MakeItSo(
-        std::forward<Functor>(functor),
-        Unwrap(std::get<indices>(std::forward<BoundArgsTuple>(bound)))...,
-        std::forward<UnboundArgs>(unbound_args)...);
-  }
-};
-
-// Extracts necessary type info from Functor and BoundArgs.
-// Used to implement MakeUnboundRunType, BindOnce and BindRepeating.
-template <typename Functor, typename... BoundArgs>
-struct BindTypeHelper {
-  static constexpr size_t num_bounds = sizeof...(BoundArgs);
-  using FunctorTraits = MakeFunctorTraits<Functor>;
-
-  // Example:
-  //   When Functor is `double (Foo::*)(int, const std::string&)`, and BoundArgs
-  //   is a template pack of `Foo*` and `int16_t`:
-  //    - RunType is `double(Foo*, int, const std::string&)`,
-  //    - ReturnType is `double`,
-  //    - RunParamsList is `TypeList<Foo*, int, const std::string&>`,
-  //    - BoundParamsList is `TypeList<Foo*, int>`,
-  //    - UnboundParamsList is `TypeList<const std::string&>`,
-  //    - BoundArgsList is `TypeList<Foo*, int16_t>`,
-  //    - UnboundRunType is `double(const std::string&)`.
-  using RunType = typename FunctorTraits::RunType;
-  using ReturnType = ExtractReturnType<RunType>;
-
-  using RunParamsList = ExtractArgs<RunType>;
-  using BoundParamsList = TakeTypeListItem<num_bounds, RunParamsList>;
-  using UnboundParamsList = DropTypeListItem<num_bounds, RunParamsList>;
-
-  using BoundArgsList = TypeList<BoundArgs...>;
-
-  using UnboundRunType = MakeFunctionType<ReturnType, UnboundParamsList>;
-};
-
-template <typename Functor>
-std::enable_if_t<FunctorTraits<Functor>::is_nullable, bool> IsNull(
-    const Functor& functor) {
-  return !functor;
-}
-
-template <typename Functor>
-std::enable_if_t<!FunctorTraits<Functor>::is_nullable, bool> IsNull(
-    const Functor&) {
-  return false;
-}
-
-// Used by ApplyCancellationTraits below.
-template <typename Functor, typename BoundArgsTuple, size_t... indices>
-bool ApplyCancellationTraitsImpl(const Functor& functor,
-                                 const BoundArgsTuple& bound_args,
-                                 std::index_sequence<indices...>) {
-  return CallbackCancellationTraits<Functor, BoundArgsTuple>::IsCancelled(
-      functor, std::get<indices>(bound_args)...);
-}
-
-// Relays |base| to corresponding CallbackCancellationTraits<>::Run(). Returns
-// true if the callback |base| represents is canceled.
-template <typename BindStateType>
-bool ApplyCancellationTraits(const BindStateBase* base) {
-  const BindStateType* storage = static_cast<const BindStateType*>(base);
-  static constexpr size_t num_bound_args =
-      std::tuple_size<decltype(storage->bound_args_)>::value;
-  return ApplyCancellationTraitsImpl(
-      storage->functor_, storage->bound_args_,
-      std::make_index_sequence<num_bound_args>());
-};
-
-// BindState<>
-//
-// This stores all the state passed into Bind().
-template <typename Functor, typename... BoundArgs>
-struct BindState final : BindStateBase {
-  using IsCancellable = std::integral_constant<
-      bool,
-      CallbackCancellationTraits<Functor,
-                                 std::tuple<BoundArgs...>>::is_cancellable>;
-
-  template <typename ForwardFunctor, typename... ForwardBoundArgs>
-  explicit BindState(BindStateBase::InvokeFuncStorage invoke_func,
-                     ForwardFunctor&& functor,
-                     ForwardBoundArgs&&... bound_args)
-      // IsCancellable is std::false_type if
-      // CallbackCancellationTraits<>::IsCancelled returns always false.
-      // Otherwise, it's std::true_type.
-      : BindState(IsCancellable{},
-                  invoke_func,
-                  std::forward<ForwardFunctor>(functor),
-                  std::forward<ForwardBoundArgs>(bound_args)...) {}
-
-  Functor functor_;
-  std::tuple<BoundArgs...> bound_args_;
-
- private:
-  template <typename ForwardFunctor, typename... ForwardBoundArgs>
-  explicit BindState(std::true_type,
-                     BindStateBase::InvokeFuncStorage invoke_func,
-                     ForwardFunctor&& functor,
-                     ForwardBoundArgs&&... bound_args)
-      : BindStateBase(invoke_func,
-                      &Destroy,
-                      &ApplyCancellationTraits<BindState>),
-        functor_(std::forward<ForwardFunctor>(functor)),
-        bound_args_(std::forward<ForwardBoundArgs>(bound_args)...) {
-    DCHECK(!IsNull(functor_));
-  }
-
-  template <typename ForwardFunctor, typename... ForwardBoundArgs>
-  explicit BindState(std::false_type,
-                     BindStateBase::InvokeFuncStorage invoke_func,
-                     ForwardFunctor&& functor,
-                     ForwardBoundArgs&&... bound_args)
-      : BindStateBase(invoke_func, &Destroy),
-        functor_(std::forward<ForwardFunctor>(functor)),
-        bound_args_(std::forward<ForwardBoundArgs>(bound_args)...) {
-    DCHECK(!IsNull(functor_));
-  }
-
-  ~BindState() = default;
-
-  static void Destroy(const BindStateBase* self) {
-    delete static_cast<const BindState*>(self);
-  }
-};
-
-// Used to implement MakeBindStateType.
-template <bool is_method, typename Functor, typename... BoundArgs>
-struct MakeBindStateTypeImpl;
-
-template <typename Functor, typename... BoundArgs>
-struct MakeBindStateTypeImpl<false, Functor, BoundArgs...> {
-  static_assert(!HasRefCountedTypeAsRawPtr<std::decay_t<BoundArgs>...>::value,
-                "A parameter is a refcounted type and needs scoped_refptr.");
-  using Type = BindState<std::decay_t<Functor>, std::decay_t<BoundArgs>...>;
-};
-
-template <typename Functor>
-struct MakeBindStateTypeImpl<true, Functor> {
-  using Type = BindState<std::decay_t<Functor>>;
-};
-
-template <typename Functor, typename Receiver, typename... BoundArgs>
-struct MakeBindStateTypeImpl<true, Functor, Receiver, BoundArgs...> {
- private:
-  using DecayedReceiver = std::decay_t<Receiver>;
-
-  static_assert(!std::is_array<std::remove_reference_t<Receiver>>::value,
-                "First bound argument to a method cannot be an array.");
-  static_assert(
-      !std::is_pointer<DecayedReceiver>::value ||
-          IsRefCountedType<std::remove_pointer_t<DecayedReceiver>>::value,
-      "Receivers may not be raw pointers. If using a raw pointer here is safe"
-      " and has no lifetime concerns, use base::Unretained() and document why"
-      " it's safe.");
-  static_assert(!HasRefCountedTypeAsRawPtr<std::decay_t<BoundArgs>...>::value,
-                "A parameter is a refcounted type and needs scoped_refptr.");
-
- public:
-  using Type = BindState<
-      std::decay_t<Functor>,
-      std::conditional_t<std::is_pointer<DecayedReceiver>::value,
-                         scoped_refptr<std::remove_pointer_t<DecayedReceiver>>,
-                         DecayedReceiver>,
-      std::decay_t<BoundArgs>...>;
-};
-
-template <typename Functor, typename... BoundArgs>
-using MakeBindStateType =
-    typename MakeBindStateTypeImpl<MakeFunctorTraits<Functor>::is_method,
-                                   Functor,
-                                   BoundArgs...>::Type;
-
-}  // namespace internal
-
-// An injection point to control |this| pointer behavior on a method invocation.
-// If IsWeakReceiver<> is true_type for |T| and |T| is used for a receiver of a
-// method, base::Bind cancels the method invocation if the receiver is tested as
-// false.
-// E.g. Foo::bar() is not called:
-//   struct Foo : base::SupportsWeakPtr<Foo> {
-//     void bar() {}
-//   };
-//
-//   WeakPtr<Foo> oo = nullptr;
-//   base::Bind(&Foo::bar, oo).Run();
-template <typename T>
-struct IsWeakReceiver : std::false_type {};
-
-template <typename T>
-struct IsWeakReceiver<internal::ConstRefWrapper<T>> : IsWeakReceiver<T> {};
-
-template <typename T>
-struct IsWeakReceiver<WeakPtr<T>> : std::true_type {};
-
-// An injection point to control how bound objects passed to the target
-// function. BindUnwrapTraits<>::Unwrap() is called for each bound objects right
-// before the target function is invoked.
-template <typename>
-struct BindUnwrapTraits {
-  template <typename T>
-  static T&& Unwrap(T&& o) {
-    return std::forward<T>(o);
-  }
-};
-
-template <typename T>
-struct BindUnwrapTraits<internal::UnretainedWrapper<T>> {
-  static T* Unwrap(const internal::UnretainedWrapper<T>& o) { return o.get(); }
-};
-
-template <typename T>
-struct BindUnwrapTraits<internal::ConstRefWrapper<T>> {
-  static const T& Unwrap(const internal::ConstRefWrapper<T>& o) {
-    return o.get();
-  }
-};
-
-template <typename T>
-struct BindUnwrapTraits<internal::RetainedRefWrapper<T>> {
-  static T* Unwrap(const internal::RetainedRefWrapper<T>& o) { return o.get(); }
-};
-
-template <typename T>
-struct BindUnwrapTraits<internal::OwnedWrapper<T>> {
-  static T* Unwrap(const internal::OwnedWrapper<T>& o) { return o.get(); }
-};
-
-template <typename T>
-struct BindUnwrapTraits<internal::PassedWrapper<T>> {
-  static T Unwrap(const internal::PassedWrapper<T>& o) { return o.Take(); }
-};
-
-// CallbackCancellationTraits allows customization of Callback's cancellation
-// semantics. By default, callbacks are not cancellable. A specialization should
-// set is_cancellable = true and implement an IsCancelled() that returns if the
-// callback should be cancelled.
-template <typename Functor, typename BoundArgsTuple, typename SFINAE>
-struct CallbackCancellationTraits {
-  static constexpr bool is_cancellable = false;
-};
-
-// Specialization for method bound to weak pointer receiver.
-template <typename Functor, typename... BoundArgs>
-struct CallbackCancellationTraits<
-    Functor,
-    std::tuple<BoundArgs...>,
-    std::enable_if_t<
-        internal::IsWeakMethod<internal::FunctorTraits<Functor>::is_method,
-                               BoundArgs...>::value>> {
-  static constexpr bool is_cancellable = true;
-
-  template <typename Receiver, typename... Args>
-  static bool IsCancelled(const Functor&,
-                          const Receiver& receiver,
-                          const Args&...) {
-    return !receiver;
-  }
-};
-
-// Specialization for a nested bind.
-template <typename Signature, typename... BoundArgs>
-struct CallbackCancellationTraits<OnceCallback<Signature>,
-                                  std::tuple<BoundArgs...>> {
-  static constexpr bool is_cancellable = true;
-
-  template <typename Functor>
-  static bool IsCancelled(const Functor& functor, const BoundArgs&...) {
-    return functor.IsCancelled();
-  }
-};
-
-template <typename Signature, typename... BoundArgs>
-struct CallbackCancellationTraits<RepeatingCallback<Signature>,
-                                  std::tuple<BoundArgs...>> {
-  static constexpr bool is_cancellable = true;
-
-  template <typename Functor>
-  static bool IsCancelled(const Functor& functor, const BoundArgs&...) {
-    return functor.IsCancelled();
-  }
-};
-
-// Returns a RunType of bound functor.
-// E.g. MakeUnboundRunType<R(A, B, C), A, B> is evaluated to R(C).
-template <typename Functor, typename... BoundArgs>
-using MakeUnboundRunType =
-    typename internal::BindTypeHelper<Functor, BoundArgs...>::UnboundRunType;
-
-}  // namespace base
-
-#endif  // BASE_BIND_INTERNAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/callback.h b/native/zucchini/vendor/libchrome/base/callback.h
deleted file mode 100644
index bcda5af..0000000
--- a/native/zucchini/vendor/libchrome/base/callback.h
+++ /dev/null
@@ -1,146 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-// NOTE: Header files that do not require the full definition of Callback or
-// Closure should #include "base/callback_forward.h" instead of this file.
-
-#ifndef BASE_CALLBACK_H_
-#define BASE_CALLBACK_H_
-
-#include <stddef.h>
-
-#include "base/callback_forward.h"
-#include "base/callback_internal.h"
-
-// -----------------------------------------------------------------------------
-// Usage documentation
-// -----------------------------------------------------------------------------
-//
-// Overview:
-// A callback is similar in concept to a function pointer: it wraps a runnable
-// object such as a function, method, lambda, or even another callback, allowing
-// the runnable object to be invoked later via the callback object.
-//
-// Unlike function pointers, callbacks are created with base::BindOnce() or
-// base::BindRepeating() and support partial function application.
-//
-// A base::OnceCallback may be Run() at most once; a base::RepeatingCallback may
-// be Run() any number of times. |is_null()| is guaranteed to return true for a
-// moved-from callback.
-//
-//   // The lambda takes two arguments, but the first argument |x| is bound at
-//   // callback creation.
-//   base::OnceCallback<int(int)> cb = base::BindOnce([] (int x, int y) {
-//     return x + y;
-//   }, 1);
-//   // Run() only needs the remaining unbound argument |y|.
-//   printf("1 + 2 = %d\n", std::move(cb).Run(2));  // Prints 3
-//   printf("cb is null? %s\n",
-//          cb.is_null() ? "true" : "false");  // Prints true
-//   std::move(cb).Run(2);  // Crashes since |cb| has already run.
-//
-// Callbacks also support cancellation. A common use is binding the receiver
-// object as a WeakPtr<T>. If that weak pointer is invalidated, calling Run()
-// will be a no-op. Note that |is_cancelled()| and |is_null()| are distinct:
-// simply cancelling a callback will not also make it null.
-//
-// base::Callback is currently a type alias for base::RepeatingCallback. In the
-// future, we expect to flip this to default to base::OnceCallback.
-//
-// See //docs/callback.md for the full documentation.
-
-namespace base {
-
-template <typename R, typename... Args>
-class OnceCallback<R(Args...)> : public internal::CallbackBase {
- public:
-  using RunType = R(Args...);
-  using PolymorphicInvoke = R (*)(internal::BindStateBase*,
-                                  internal::PassingType<Args>...);
-
-  constexpr OnceCallback() = default;
-  OnceCallback(std::nullptr_t) = delete;
-
-  explicit OnceCallback(internal::BindStateBase* bind_state)
-      : internal::CallbackBase(bind_state) {}
-
-  OnceCallback(const OnceCallback&) = delete;
-  OnceCallback& operator=(const OnceCallback&) = delete;
-
-  OnceCallback(OnceCallback&&) noexcept = default;
-  OnceCallback& operator=(OnceCallback&&) noexcept = default;
-
-  OnceCallback(RepeatingCallback<RunType> other)
-      : internal::CallbackBase(std::move(other)) {}
-
-  OnceCallback& operator=(RepeatingCallback<RunType> other) {
-    static_cast<internal::CallbackBase&>(*this) = std::move(other);
-    return *this;
-  }
-
-  bool Equals(const OnceCallback& other) const { return EqualsInternal(other); }
-
-  R Run(Args... args) const & {
-    static_assert(!sizeof(*this),
-                  "OnceCallback::Run() may only be invoked on a non-const "
-                  "rvalue, i.e. std::move(callback).Run().");
-    NOTREACHED();
-  }
-
-  R Run(Args... args) && {
-    // Move the callback instance into a local variable before the invocation,
-    // that ensures the internal state is cleared after the invocation.
-    // It's not safe to touch |this| after the invocation, since running the
-    // bound function may destroy |this|.
-    OnceCallback cb = std::move(*this);
-    PolymorphicInvoke f =
-        reinterpret_cast<PolymorphicInvoke>(cb.polymorphic_invoke());
-    return f(cb.bind_state_.get(), std::forward<Args>(args)...);
-  }
-};
-
-template <typename R, typename... Args>
-class RepeatingCallback<R(Args...)> : public internal::CallbackBaseCopyable {
- public:
-  using RunType = R(Args...);
-  using PolymorphicInvoke = R (*)(internal::BindStateBase*,
-                                  internal::PassingType<Args>...);
-
-  constexpr RepeatingCallback() = default;
-  RepeatingCallback(std::nullptr_t) = delete;
-
-  explicit RepeatingCallback(internal::BindStateBase* bind_state)
-      : internal::CallbackBaseCopyable(bind_state) {}
-
-  // Copyable and movable.
-  RepeatingCallback(const RepeatingCallback&) = default;
-  RepeatingCallback& operator=(const RepeatingCallback&) = default;
-  RepeatingCallback(RepeatingCallback&&) noexcept = default;
-  RepeatingCallback& operator=(RepeatingCallback&&) noexcept = default;
-
-  bool Equals(const RepeatingCallback& other) const {
-    return EqualsInternal(other);
-  }
-
-  R Run(Args... args) const & {
-    PolymorphicInvoke f =
-        reinterpret_cast<PolymorphicInvoke>(this->polymorphic_invoke());
-    return f(this->bind_state_.get(), std::forward<Args>(args)...);
-  }
-
-  R Run(Args... args) && {
-    // Move the callback instance into a local variable before the invocation,
-    // that ensures the internal state is cleared after the invocation.
-    // It's not safe to touch |this| after the invocation, since running the
-    // bound function may destroy |this|.
-    RepeatingCallback cb = std::move(*this);
-    PolymorphicInvoke f =
-        reinterpret_cast<PolymorphicInvoke>(cb.polymorphic_invoke());
-    return f(cb.bind_state_.get(), std::forward<Args>(args)...);
-  }
-};
-
-}  // namespace base
-
-#endif  // BASE_CALLBACK_H_
diff --git a/native/zucchini/vendor/libchrome/base/callback_forward.h b/native/zucchini/vendor/libchrome/base/callback_forward.h
deleted file mode 100644
index f1851c4..0000000
--- a/native/zucchini/vendor/libchrome/base/callback_forward.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CALLBACK_FORWARD_H_
-#define BASE_CALLBACK_FORWARD_H_
-
-namespace base {
-
-template <typename Signature>
-class OnceCallback;
-
-template <typename Signature>
-class RepeatingCallback;
-
-template <typename Signature>
-using Callback = RepeatingCallback<Signature>;
-
-// Syntactic sugar to make Callback<void()> easier to declare since it
-// will be used in a lot of APIs with delayed execution.
-using OnceClosure = OnceCallback<void()>;
-using RepeatingClosure = RepeatingCallback<void()>;
-using Closure = Callback<void()>;
-
-}  // namespace base
-
-#endif  // BASE_CALLBACK_FORWARD_H_
diff --git a/native/zucchini/vendor/libchrome/base/callback_helpers.h b/native/zucchini/vendor/libchrome/base/callback_helpers.h
deleted file mode 100644
index 0cdda6d..0000000
--- a/native/zucchini/vendor/libchrome/base/callback_helpers.h
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This defines helpful methods for dealing with Callbacks.  Because Callbacks
-// are implemented using templates, with a class per callback signature, adding
-// methods to Callback<> itself is unattractive (lots of extra code gets
-// generated).  Instead, consider adding methods here.
-
-#ifndef BASE_CALLBACK_HELPERS_H_
-#define BASE_CALLBACK_HELPERS_H_
-
-#include <utility>
-
-#include "base/atomicops.h"
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/memory/ptr_util.h"
-
-namespace base {
-
-// Prefer std::move() over ResetAndReturn().
-template <typename CallbackType>
-CallbackType ResetAndReturn(CallbackType* cb) {
-  CallbackType ret(std::move(*cb));
-  DCHECK(!*cb);
-  return ret;
-}
-
-namespace internal {
-
-template <typename... Args>
-class AdaptCallbackForRepeatingHelper final {
- public:
-  explicit AdaptCallbackForRepeatingHelper(OnceCallback<void(Args...)> callback)
-      : callback_(std::move(callback)) {
-    DCHECK(callback_);
-  }
-
-  void Run(Args... args) {
-    if (subtle::NoBarrier_AtomicExchange(&has_run_, 1))
-      return;
-    DCHECK(callback_);
-    std::move(callback_).Run(std::forward<Args>(args)...);
-  }
-
- private:
-  volatile subtle::Atomic32 has_run_ = 0;
-  base::OnceCallback<void(Args...)> callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(AdaptCallbackForRepeatingHelper);
-};
-
-}  // namespace internal
-
-// Wraps the given OnceCallback into a RepeatingCallback that relays its
-// invocation to the original OnceCallback on the first invocation. The
-// following invocations are just ignored.
-//
-// Note that this deliberately subverts the Once/Repeating paradigm of Callbacks
-// but helps ease the migration from old-style Callbacks. Avoid if possible; use
-// if necessary for migration. TODO(tzik): Remove it. https://crbug.com/730593
-template <typename... Args>
-RepeatingCallback<void(Args...)> AdaptCallbackForRepeating(
-    OnceCallback<void(Args...)> callback) {
-  using Helper = internal::AdaptCallbackForRepeatingHelper<Args...>;
-  return base::BindRepeating(&Helper::Run,
-                             std::make_unique<Helper>(std::move(callback)));
-}
-
-// ScopedClosureRunner is akin to std::unique_ptr<> for Closures. It ensures
-// that the Closure is executed no matter how the current scope exits.
-class BASE_EXPORT ScopedClosureRunner {
- public:
-  ScopedClosureRunner();
-  explicit ScopedClosureRunner(OnceClosure closure);
-  ~ScopedClosureRunner();
-
-  ScopedClosureRunner(ScopedClosureRunner&& other);
-
-  // Releases the current closure if it's set and replaces it with the closure
-  // from |other|.
-  ScopedClosureRunner& operator=(ScopedClosureRunner&& other);
-
-  // Calls the current closure and resets it, so it wont be called again.
-  void RunAndReset();
-
-  // Replaces closure with the new one releasing the old one without calling it.
-  void ReplaceClosure(OnceClosure closure);
-
-  // Releases the Closure without calling.
-  OnceClosure Release() WARN_UNUSED_RESULT;
-
- private:
-  OnceClosure closure_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedClosureRunner);
-};
-
-}  // namespace base
-
-#endif  // BASE_CALLBACK_HELPERS_H_
diff --git a/native/zucchini/vendor/libchrome/base/callback_internal.cc b/native/zucchini/vendor/libchrome/base/callback_internal.cc
deleted file mode 100644
index dd000ca..0000000
--- a/native/zucchini/vendor/libchrome/base/callback_internal.cc
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/callback_internal.h"
-
-#include "base/logging.h"
-
-namespace base {
-namespace internal {
-
-namespace {
-
-bool ReturnFalse(const BindStateBase*) {
-  return false;
-}
-
-}  // namespace
-
-void BindStateBaseRefCountTraits::Destruct(const BindStateBase* bind_state) {
-  bind_state->destructor_(bind_state);
-}
-
-BindStateBase::BindStateBase(InvokeFuncStorage polymorphic_invoke,
-                             void (*destructor)(const BindStateBase*))
-    : BindStateBase(polymorphic_invoke, destructor, &ReturnFalse) {
-}
-
-BindStateBase::BindStateBase(InvokeFuncStorage polymorphic_invoke,
-                             void (*destructor)(const BindStateBase*),
-                             bool (*is_cancelled)(const BindStateBase*))
-    : polymorphic_invoke_(polymorphic_invoke),
-      destructor_(destructor),
-      is_cancelled_(is_cancelled) {}
-
-CallbackBase& CallbackBase::operator=(CallbackBase&& c) noexcept = default;
-CallbackBase::CallbackBase(const CallbackBaseCopyable& c)
-    : bind_state_(c.bind_state_) {}
-
-CallbackBase& CallbackBase::operator=(const CallbackBaseCopyable& c) {
-  bind_state_ = c.bind_state_;
-  return *this;
-}
-
-CallbackBase::CallbackBase(CallbackBaseCopyable&& c) noexcept
-    : bind_state_(std::move(c.bind_state_)) {}
-
-CallbackBase& CallbackBase::operator=(CallbackBaseCopyable&& c) noexcept {
-  bind_state_ = std::move(c.bind_state_);
-  return *this;
-}
-
-void CallbackBase::Reset() {
-  // NULL the bind_state_ last, since it may be holding the last ref to whatever
-  // object owns us, and we may be deleted after that.
-  bind_state_ = nullptr;
-}
-
-bool CallbackBase::IsCancelled() const {
-  DCHECK(bind_state_);
-  return bind_state_->IsCancelled();
-}
-
-bool CallbackBase::EqualsInternal(const CallbackBase& other) const {
-  return bind_state_ == other.bind_state_;
-}
-
-CallbackBase::~CallbackBase() = default;
-
-CallbackBaseCopyable::CallbackBaseCopyable(const CallbackBaseCopyable& c) {
-  bind_state_ = c.bind_state_;
-}
-
-CallbackBaseCopyable& CallbackBaseCopyable::operator=(
-    const CallbackBaseCopyable& c) {
-  bind_state_ = c.bind_state_;
-  return *this;
-}
-
-CallbackBaseCopyable& CallbackBaseCopyable::operator=(
-    CallbackBaseCopyable&& c) noexcept = default;
-
-}  // namespace internal
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/callback_internal.h b/native/zucchini/vendor/libchrome/base/callback_internal.h
deleted file mode 100644
index 1215e3e..0000000
--- a/native/zucchini/vendor/libchrome/base/callback_internal.h
+++ /dev/null
@@ -1,165 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This file contains utility functions and classes that help the
-// implementation, and management of the Callback objects.
-
-#ifndef BASE_CALLBACK_INTERNAL_H_
-#define BASE_CALLBACK_INTERNAL_H_
-
-#include "base/base_export.h"
-#include "base/callback_forward.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-
-namespace base {
-
-struct FakeBindState;
-
-namespace internal {
-
-class CallbackBase;
-class CallbackBaseCopyable;
-
-class BindStateBase;
-
-template <typename Functor, typename... BoundArgs>
-struct BindState;
-
-struct BindStateBaseRefCountTraits {
-  static void Destruct(const BindStateBase*);
-};
-
-template <typename T>
-using PassingType = std::conditional_t<std::is_scalar<T>::value, T, T&&>;
-
-// BindStateBase is used to provide an opaque handle that the Callback
-// class can use to represent a function object with bound arguments.  It
-// behaves as an existential type that is used by a corresponding
-// DoInvoke function to perform the function execution.  This allows
-// us to shield the Callback class from the types of the bound argument via
-// "type erasure."
-// At the base level, the only task is to add reference counting data. Don't use
-// RefCountedThreadSafe since it requires the destructor to be a virtual method.
-// Creating a vtable for every BindState template instantiation results in a lot
-// of bloat. Its only task is to call the destructor which can be done with a
-// function pointer.
-class BASE_EXPORT BindStateBase
-    : public RefCountedThreadSafe<BindStateBase, BindStateBaseRefCountTraits> {
- public:
-  REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
-
-  using InvokeFuncStorage = void(*)();
-
- private:
-  BindStateBase(InvokeFuncStorage polymorphic_invoke,
-                void (*destructor)(const BindStateBase*));
-  BindStateBase(InvokeFuncStorage polymorphic_invoke,
-                void (*destructor)(const BindStateBase*),
-                bool (*is_cancelled)(const BindStateBase*));
-
-  ~BindStateBase() = default;
-
-  friend struct BindStateBaseRefCountTraits;
-  friend class RefCountedThreadSafe<BindStateBase, BindStateBaseRefCountTraits>;
-
-  friend class CallbackBase;
-  friend class CallbackBaseCopyable;
-
-  // Whitelist subclasses that access the destructor of BindStateBase.
-  template <typename Functor, typename... BoundArgs>
-  friend struct BindState;
-  friend struct ::base::FakeBindState;
-
-  bool IsCancelled() const {
-    return is_cancelled_(this);
-  }
-
-  // In C++, it is safe to cast function pointers to function pointers of
-  // another type. It is not okay to use void*. We create a InvokeFuncStorage
-  // that that can store our function pointer, and then cast it back to
-  // the original type on usage.
-  InvokeFuncStorage polymorphic_invoke_;
-
-  // Pointer to a function that will properly destroy |this|.
-  void (*destructor_)(const BindStateBase*);
-  bool (*is_cancelled_)(const BindStateBase*);
-
-  DISALLOW_COPY_AND_ASSIGN(BindStateBase);
-};
-
-// Holds the Callback methods that don't require specialization to reduce
-// template bloat.
-// CallbackBase<MoveOnly> is a direct base class of MoveOnly callbacks, and
-// CallbackBase<Copyable> uses CallbackBase<MoveOnly> for its implementation.
-class BASE_EXPORT CallbackBase {
- public:
-  inline CallbackBase(CallbackBase&& c) noexcept;
-  CallbackBase& operator=(CallbackBase&& c) noexcept;
-
-  explicit CallbackBase(const CallbackBaseCopyable& c);
-  CallbackBase& operator=(const CallbackBaseCopyable& c);
-
-  explicit CallbackBase(CallbackBaseCopyable&& c) noexcept;
-  CallbackBase& operator=(CallbackBaseCopyable&& c) noexcept;
-
-  // Returns true if Callback is null (doesn't refer to anything).
-  bool is_null() const { return !bind_state_; }
-  explicit operator bool() const { return !is_null(); }
-
-  // Returns true if the callback invocation will be nop due to an cancellation.
-  // It's invalid to call this on uninitialized callback.
-  bool IsCancelled() const;
-
-  // Returns the Callback into an uninitialized state.
-  void Reset();
-
- protected:
-  using InvokeFuncStorage = BindStateBase::InvokeFuncStorage;
-
-  // Returns true if this callback equals |other|. |other| may be null.
-  bool EqualsInternal(const CallbackBase& other) const;
-
-  constexpr inline CallbackBase();
-
-  // Allow initializing of |bind_state_| via the constructor to avoid default
-  // initialization of the scoped_refptr.
-  explicit inline CallbackBase(BindStateBase* bind_state);
-
-  InvokeFuncStorage polymorphic_invoke() const {
-    return bind_state_->polymorphic_invoke_;
-  }
-
-  // Force the destructor to be instantiated inside this translation unit so
-  // that our subclasses will not get inlined versions.  Avoids more template
-  // bloat.
-  ~CallbackBase();
-
-  scoped_refptr<BindStateBase> bind_state_;
-};
-
-constexpr CallbackBase::CallbackBase() = default;
-CallbackBase::CallbackBase(CallbackBase&&) noexcept = default;
-CallbackBase::CallbackBase(BindStateBase* bind_state)
-    : bind_state_(AdoptRef(bind_state)) {}
-
-// CallbackBase<Copyable> is a direct base class of Copyable Callbacks.
-class BASE_EXPORT CallbackBaseCopyable : public CallbackBase {
- public:
-  CallbackBaseCopyable(const CallbackBaseCopyable& c);
-  CallbackBaseCopyable(CallbackBaseCopyable&& c) noexcept = default;
-  CallbackBaseCopyable& operator=(const CallbackBaseCopyable& c);
-  CallbackBaseCopyable& operator=(CallbackBaseCopyable&& c) noexcept;
-
- protected:
-  constexpr CallbackBaseCopyable() = default;
-  explicit CallbackBaseCopyable(BindStateBase* bind_state)
-      : CallbackBase(bind_state) {}
-  ~CallbackBaseCopyable() = default;
-};
-
-}  // namespace internal
-}  // namespace base
-
-#endif  // BASE_CALLBACK_INTERNAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/cfi_buildflags.h b/native/zucchini/vendor/libchrome/base/cfi_buildflags.h
deleted file mode 100644
index be8270e..0000000
--- a/native/zucchini/vendor/libchrome/base/cfi_buildflags.h
+++ /dev/null
@@ -1,7 +0,0 @@
-// Generated by build/write_buildflag_header.py
-// From "base_debugging_flags"
-#ifndef BASE_CFI_BUILDFLAGS_H_
-#define BASE_CFI_BUILDFLAGS_H_
-#include "build/buildflag.h"
-#define BUILDFLAG_INTERNAL_CFI_ICALL_CHECK() (0)
-#endif  // BASE_CFI_BUILDFLAGS_H_
diff --git a/native/zucchini/vendor/libchrome/base/command_line.h b/native/zucchini/vendor/libchrome/base/command_line.h
deleted file mode 100644
index 25fd7d9..0000000
--- a/native/zucchini/vendor/libchrome/base/command_line.h
+++ /dev/null
@@ -1,247 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This class works with command lines: building and parsing.
-// Arguments with prefixes ('--', '-', and on Windows, '/') are switches.
-// Switches will precede all other arguments without switch prefixes.
-// Switches can optionally have values, delimited by '=', e.g., "-switch=value".
-// An argument of "--" will terminate switch parsing during initialization,
-// interpreting subsequent tokens as non-switch arguments, regardless of prefix.
-
-// There is a singleton read-only CommandLine that represents the command line
-// that the current process was started with.  It must be initialized in main().
-
-#ifndef BASE_COMMAND_LINE_H_
-#define BASE_COMMAND_LINE_H_
-
-#include <stddef.h>
-#include <map>
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-#include "build/build_config.h"
-
-namespace base {
-
-class FilePath;
-
-class BASE_EXPORT CommandLine {
- public:
-#if defined(OS_WIN)
-  // The native command line string type.
-  using StringType = string16;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  using StringType = std::string;
-#endif
-
-  using CharType = StringType::value_type;
-  using StringVector = std::vector<StringType>;
-  using SwitchMap = std::map<std::string, StringType, std::less<>>;
-
-  // A constructor for CommandLines that only carry switches and arguments.
-  enum NoProgram { NO_PROGRAM };
-  explicit CommandLine(NoProgram no_program);
-
-  // Construct a new command line with |program| as argv[0].
-  explicit CommandLine(const FilePath& program);
-
-  // Construct a new command line from an argument list.
-  CommandLine(int argc, const CharType* const* argv);
-  explicit CommandLine(const StringVector& argv);
-
-  // Override copy and assign to ensure |switches_by_stringpiece_| is valid.
-  CommandLine(const CommandLine& other);
-  CommandLine& operator=(const CommandLine& other);
-
-  ~CommandLine();
-
-#if defined(OS_WIN)
-  // By default this class will treat command-line arguments beginning with
-  // slashes as switches on Windows, but not other platforms.
-  //
-  // If this behavior is inappropriate for your application, you can call this
-  // function BEFORE initializing the current process' global command line
-  // object and the behavior will be the same as Posix systems (only hyphens
-  // begin switches, everything else will be an arg).
-  static void set_slash_is_not_a_switch();
-
-  // Normally when the CommandLine singleton is initialized it gets the command
-  // line via the GetCommandLineW API and then uses the shell32 API
-  // 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.
-  static void InitUsingArgvForTesting(int argc, const char* const* argv);
-#endif
-
-  // Initialize the current process CommandLine singleton. On Windows, ignores
-  // its arguments (we instead parse GetCommandLineW() directly) because we
-  // 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.
-  static bool Init(int argc, const char* const* argv);
-
-  // Destroys the current process CommandLine singleton. This is necessary if
-  // you want to reset the base library to its initial state (for example, in an
-  // outer library that needs to be able to terminate, and be re-initialized).
-  // If Init is called only once, as in main(), Reset() is not necessary.
-  // Do not call this in tests. Use base::test::ScopedCommandLine instead.
-  static void Reset();
-
-  // Get the singleton CommandLine representing the current process's
-  // command line. Note: returned value is mutable, but not thread safe;
-  // only mutate if you know what you're doing!
-  static CommandLine* ForCurrentProcess();
-
-  // Returns true if the CommandLine has been initialized for the given process.
-  static bool InitializedForCurrentProcess();
-
-#if defined(OS_WIN)
-  static CommandLine FromString(const string16& command_line);
-#endif
-
-  // Initialize from an argv vector.
-  void InitFromArgv(int argc, const CharType* const* argv);
-  void InitFromArgv(const StringVector& argv);
-
-  // Constructs and returns the represented command line string.
-  // CAUTION! This should be avoided on POSIX because quoting behavior is
-  // unclear.
-  StringType GetCommandLineString() const {
-    return GetCommandLineStringInternal(false);
-  }
-
-#if defined(OS_WIN)
-  // Constructs and returns the represented command line string. Assumes the
-  // command line contains placeholders (eg, %1) and quotes any program or
-  // argument with a '%' in it. This should be avoided unless the placeholder is
-  // required by an external interface (eg, the Windows registry), because it is
-  // not generally safe to replace it with an arbitrary string. If possible,
-  // placeholders should be replaced *before* converting the command line to a
-  // string.
-  StringType GetCommandLineStringWithPlaceholders() const {
-    return GetCommandLineStringInternal(true);
-  }
-#endif
-
-  // Constructs and returns the represented arguments string.
-  // CAUTION! This should be avoided on POSIX because quoting behavior is
-  // unclear.
-  StringType GetArgumentsString() const {
-    return GetArgumentsStringInternal(false);
-  }
-
-#if defined(OS_WIN)
-  // Constructs and returns the represented arguments string. Assumes the
-  // command line contains placeholders (eg, %1) and quotes any argument with a
-  // '%' in it. This should be avoided unless the placeholder is required by an
-  // external interface (eg, the Windows registry), because it is not generally
-  // safe to replace it with an arbitrary string. If possible, placeholders
-  // should be replaced *before* converting the arguments to a string.
-  StringType GetArgumentsStringWithPlaceholders() const {
-    return GetArgumentsStringInternal(true);
-  }
-#endif
-
-  // Returns the original command line string as a vector of strings.
-  const StringVector& argv() const { return argv_; }
-
-  // Get and Set the program part of the command line string (the first item).
-  FilePath GetProgram() const;
-  void SetProgram(const FilePath& program);
-
-  // Returns true if this command line contains the given switch.
-  // Switch names must be lowercase.
-  // The second override provides an optimized version to avoid inlining codegen
-  // at every callsite to find the length of the constant and construct a
-  // StringPiece.
-  bool HasSwitch(const StringPiece& switch_string) const;
-  bool HasSwitch(const char switch_constant[]) const;
-
-  // Returns the value associated with the given switch. If the switch has no
-  // value or isn't present, this method returns the empty string.
-  // Switch names must be lowercase.
-  std::string GetSwitchValueASCII(const StringPiece& switch_string) const;
-  FilePath GetSwitchValuePath(const StringPiece& switch_string) const;
-  StringType GetSwitchValueNative(const StringPiece& switch_string) const;
-
-  // Get a copy of all switches, along with their values.
-  const SwitchMap& GetSwitches() const { return switches_; }
-
-  // Append a switch [with optional value] to the command line.
-  // Note: Switches will precede arguments regardless of appending order.
-  void AppendSwitch(const std::string& switch_string);
-  void AppendSwitchPath(const std::string& switch_string,
-                        const FilePath& path);
-  void AppendSwitchNative(const std::string& switch_string,
-                          const StringType& value);
-  void AppendSwitchASCII(const std::string& switch_string,
-                         const std::string& value);
-
-  // Copy a set of switches (and any values) from another command line.
-  // Commonly used when launching a subprocess.
-  void CopySwitchesFrom(const CommandLine& source,
-                        const char* const switches[],
-                        size_t count);
-
-  // Get the remaining arguments to the command.
-  StringVector GetArgs() const;
-
-  // Append an argument to the command line. Note that the argument is quoted
-  // properly such that it is interpreted as one argument to the target command.
-  // AppendArg is primarily for ASCII; non-ASCII input is interpreted as UTF-8.
-  // Note: Switches will precede arguments regardless of appending order.
-  void AppendArg(const std::string& value);
-  void AppendArgPath(const FilePath& value);
-  void AppendArgNative(const StringType& value);
-
-  // Append the switches and arguments from another command line to this one.
-  // If |include_program| is true, include |other|'s program as well.
-  void AppendArguments(const CommandLine& other, bool include_program);
-
-  // Insert a command before the current command.
-  // Common for debuggers, like "gdb --args".
-  void PrependWrapper(const StringType& wrapper);
-
-#if defined(OS_WIN)
-  // Initialize by parsing the given command line string.
-  // The program name is assumed to be the first item in the string.
-  void ParseFromString(const string16& command_line);
-#endif
-
- private:
-  // Disallow default constructor; a program name must be explicitly specified.
-  CommandLine() = delete;
-  // Allow the copy constructor. A common pattern is to copy of the current
-  // process's command line and then add some flags to it. For example:
-  //   CommandLine cl(*CommandLine::ForCurrentProcess());
-  //   cl.AppendSwitch(...);
-
-  // Internal version of GetCommandLineString. If |quote_placeholders| is true,
-  // also quotes parts with '%' in them.
-  StringType GetCommandLineStringInternal(bool quote_placeholders) const;
-
-  // Internal version of GetArgumentsString. If |quote_placeholders| is true,
-  // also quotes parts with '%' in them.
-  StringType GetArgumentsStringInternal(bool quote_placeholders) const;
-
-  // The singleton CommandLine representing the current process's command line.
-  static CommandLine* current_process_commandline_;
-
-  // The argv array: { program, [(--|-|/)switch[=value]]*, [--], [argument]* }
-  StringVector argv_;
-
-  // Parsed-out switch keys and values.
-  SwitchMap switches_;
-
-  // The index after the program and switches, any arguments start here.
-  size_t begin_args_;
-};
-
-}  // namespace base
-
-#endif  // BASE_COMMAND_LINE_H_
diff --git a/native/zucchini/vendor/libchrome/base/compiler_specific.h b/native/zucchini/vendor/libchrome/base/compiler_specific.h
deleted file mode 100644
index a930f5d..0000000
--- a/native/zucchini/vendor/libchrome/base/compiler_specific.h
+++ /dev/null
@@ -1,236 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_COMPILER_SPECIFIC_H_
-#define BASE_COMPILER_SPECIFIC_H_
-
-#include "build/build_config.h"
-
-#if defined(ANDROID)
-// Prefer Android's libbase definitions to our own.
-#include <android-base/macros.h>
-#endif  // defined(ANDROID)
-
-#if defined(COMPILER_MSVC)
-
-// For _Printf_format_string_.
-#include <sal.h>
-
-// Macros for suppressing and disabling warnings on MSVC.
-//
-// Warning numbers are enumerated at:
-// http://msdn.microsoft.com/en-us/library/8x5x43k7(VS.80).aspx
-//
-// The warning pragma:
-// http://msdn.microsoft.com/en-us/library/2c8f766e(VS.80).aspx
-//
-// Using __pragma instead of #pragma inside macros:
-// http://msdn.microsoft.com/en-us/library/d9x1s805.aspx
-
-// MSVC_SUPPRESS_WARNING disables warning |n| for the remainder of the line and
-// for the next line of the source file.
-#define MSVC_SUPPRESS_WARNING(n) __pragma(warning(suppress:n))
-
-// MSVC_PUSH_DISABLE_WARNING pushes |n| onto a stack of warnings to be disabled.
-// The warning remains disabled until popped by MSVC_POP_WARNING.
-#define MSVC_PUSH_DISABLE_WARNING(n) __pragma(warning(push)) \
-                                     __pragma(warning(disable:n))
-
-// MSVC_PUSH_WARNING_LEVEL pushes |n| as the global warning level.  The level
-// remains in effect until popped by MSVC_POP_WARNING().  Use 0 to disable all
-// warnings.
-#define MSVC_PUSH_WARNING_LEVEL(n) __pragma(warning(push, n))
-
-// Pop effects of innermost MSVC_PUSH_* macro.
-#define MSVC_POP_WARNING() __pragma(warning(pop))
-
-#define MSVC_DISABLE_OPTIMIZE() __pragma(optimize("", off))
-#define MSVC_ENABLE_OPTIMIZE() __pragma(optimize("", on))
-
-#else  // Not MSVC
-
-#define _Printf_format_string_
-#define MSVC_SUPPRESS_WARNING(n)
-#define MSVC_PUSH_DISABLE_WARNING(n)
-#define MSVC_PUSH_WARNING_LEVEL(n)
-#define MSVC_POP_WARNING()
-#define MSVC_DISABLE_OPTIMIZE()
-#define MSVC_ENABLE_OPTIMIZE()
-
-#endif  // COMPILER_MSVC
-
-// Annotate a variable indicating it's ok if the variable is not used.
-// (Typically used to silence a compiler warning when the assignment
-// is important for some other reason.)
-// Use like:
-//   int x = ...;
-//   ALLOW_UNUSED_LOCAL(x);
-#define ALLOW_UNUSED_LOCAL(x) (void)x
-
-// Annotate a typedef or function indicating it's ok if it's not used.
-// Use like:
-//   typedef Foo Bar ALLOW_UNUSED_TYPE;
-#if defined(COMPILER_GCC) || defined(__clang__)
-#define ALLOW_UNUSED_TYPE __attribute__((unused))
-#else
-#define ALLOW_UNUSED_TYPE
-#endif
-
-// Annotate a function indicating it should not be inlined.
-// Use like:
-//   NOINLINE void DoStuff() { ... }
-#if defined(COMPILER_GCC)
-#define NOINLINE __attribute__((noinline))
-#elif defined(COMPILER_MSVC)
-#define NOINLINE __declspec(noinline)
-#else
-#define NOINLINE
-#endif
-
-#if COMPILER_GCC && defined(NDEBUG)
-#define ALWAYS_INLINE inline __attribute__((__always_inline__))
-#elif COMPILER_MSVC && defined(NDEBUG)
-#define ALWAYS_INLINE __forceinline
-#else
-#define ALWAYS_INLINE inline
-#endif
-
-// Specify memory alignment for structs, classes, etc.
-// Use like:
-//   class ALIGNAS(16) MyClass { ... }
-//   ALIGNAS(16) int array[4];
-//
-// In most places you can use the C++11 keyword "alignas", which is preferred.
-//
-// But compilers have trouble mixing __attribute__((...)) syntax with
-// alignas(...) syntax.
-//
-// Doesn't work in clang or gcc:
-//   struct alignas(16) __attribute__((packed)) S { char c; };
-// Works in clang but not gcc:
-//   struct __attribute__((packed)) alignas(16) S2 { char c; };
-// Works in clang and gcc:
-//   struct alignas(16) S3 { char c; } __attribute__((packed));
-//
-// There are also some attributes that must be specified *before* a class
-// definition: visibility (used for exporting functions/classes) is one of
-// these attributes. This means that it is not possible to use alignas() with a
-// class that is marked as exported.
-#if defined(COMPILER_MSVC)
-#define ALIGNAS(byte_alignment) __declspec(align(byte_alignment))
-#elif defined(COMPILER_GCC)
-#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))
-#endif
-
-// Annotate a function indicating the caller must examine the return value.
-// Use like:
-//   int foo() WARN_UNUSED_RESULT;
-// To explicitly ignore a result, see |ignore_result()| in base/macros.h.
-#undef WARN_UNUSED_RESULT
-#if defined(COMPILER_GCC) || defined(__clang__)
-#define WARN_UNUSED_RESULT __attribute__((warn_unused_result))
-#else
-#define WARN_UNUSED_RESULT
-#endif
-
-// Tell the compiler a function is using a printf-style format string.
-// |format_param| is the one-based index of the format string parameter;
-// |dots_param| is the one-based index of the "..." parameter.
-// For v*printf functions (which take a va_list), pass 0 for dots_param.
-// (This is undocumented but matches what the system C headers do.)
-#if defined(COMPILER_GCC) || defined(__clang__)
-#define PRINTF_FORMAT(format_param, dots_param) \
-    __attribute__((format(printf, format_param, dots_param)))
-#else
-#define PRINTF_FORMAT(format_param, dots_param)
-#endif
-
-// WPRINTF_FORMAT is the same, but for wide format strings.
-// This doesn't appear to yet be implemented in any compiler.
-// See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=38308 .
-#define WPRINTF_FORMAT(format_param, dots_param)
-// If available, it would look like:
-//   __attribute__((format(wprintf, format_param, dots_param)))
-
-// Sanitizers annotations.
-#if defined(__has_attribute)
-#if __has_attribute(no_sanitize)
-#define NO_SANITIZE(what) __attribute__((no_sanitize(what)))
-#endif
-#endif
-#if !defined(NO_SANITIZE)
-#define NO_SANITIZE(what)
-#endif
-
-// MemorySanitizer annotations.
-#if defined(MEMORY_SANITIZER) && !defined(OS_NACL)
-#include <sanitizer/msan_interface.h>
-
-// Mark a memory region fully initialized.
-// Use this to annotate code that deliberately reads uninitialized data, for
-// example a GC scavenging root set pointers from the stack.
-#define MSAN_UNPOISON(p, size)  __msan_unpoison(p, size)
-
-// Check a memory region for initializedness, as if it was being used here.
-// If any bits are uninitialized, crash with an MSan report.
-// Use this to sanitize data which MSan won't be able to track, e.g. before
-// passing data to another process via shared memory.
-#define MSAN_CHECK_MEM_IS_INITIALIZED(p, size) \
-    __msan_check_mem_is_initialized(p, size)
-#else  // MEMORY_SANITIZER
-#define MSAN_UNPOISON(p, size)
-#define MSAN_CHECK_MEM_IS_INITIALIZED(p, size)
-#endif  // MEMORY_SANITIZER
-
-// DISABLE_CFI_PERF -- Disable Control Flow Integrity for perf reasons.
-#if !defined(DISABLE_CFI_PERF)
-#if defined(__clang__) && defined(OFFICIAL_BUILD)
-#define DISABLE_CFI_PERF __attribute__((no_sanitize("cfi")))
-#else
-#define DISABLE_CFI_PERF
-#endif
-#endif
-
-// Macro useful for writing cross-platform function pointers.
-#if !defined(CDECL)
-#if defined(OS_WIN)
-#define CDECL __cdecl
-#else  // defined(OS_WIN)
-#define CDECL
-#endif  // defined(OS_WIN)
-#endif  // !defined(CDECL)
-
-// Macro for hinting that an expression is likely to be false.
-#if !defined(UNLIKELY)
-#if defined(COMPILER_GCC) || defined(__clang__)
-#define UNLIKELY(x) __builtin_expect(!!(x), 0)
-#else
-#define UNLIKELY(x) (x)
-#endif  // defined(COMPILER_GCC)
-#endif  // !defined(UNLIKELY)
-
-#if !defined(LIKELY)
-#if defined(COMPILER_GCC) || defined(__clang__)
-#define LIKELY(x) __builtin_expect(!!(x), 1)
-#else
-#define LIKELY(x) (x)
-#endif  // defined(COMPILER_GCC)
-#endif  // !defined(LIKELY)
-
-// Compiler feature-detection.
-// clang.llvm.org/docs/LanguageExtensions.html#has-feature-and-has-extension
-#if defined(__has_feature)
-#define HAS_FEATURE(FEATURE) __has_feature(FEATURE)
-#else
-#define HAS_FEATURE(FEATURE) 0
-#endif
-
-// Macro for telling -Wimplicit-fallthrough that a fallthrough is intentional.
-#if defined(__clang__)
-#define FALLTHROUGH [[clang::fallthrough]]
-#else
-#define FALLTHROUGH
-#endif
-
-#endif  // BASE_COMPILER_SPECIFIC_H_
diff --git a/native/zucchini/vendor/libchrome/base/containers/circular_deque.h b/native/zucchini/vendor/libchrome/base/containers/circular_deque.h
deleted file mode 100644
index bf42a95..0000000
--- a/native/zucchini/vendor/libchrome/base/containers/circular_deque.h
+++ /dev/null
@@ -1,1111 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CONTAINERS_CIRCULAR_DEQUE_H_
-#define BASE_CONTAINERS_CIRCULAR_DEQUE_H_
-
-#include <algorithm>
-#include <cstddef>
-#include <iterator>
-#include <type_traits>
-#include <utility>
-
-#include "base/containers/vector_buffer.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/template_util.h"
-
-// base::circular_deque is similar to std::deque. Unlike std::deque, the
-// storage is provided in a flat circular buffer conceptually similar to a
-// vector. The beginning and end will wrap around as necessary so that
-// pushes and pops will be constant time as long as a capacity expansion is
-// not required.
-//
-// The API should be identical to std::deque with the following differences:
-//
-//  - ITERATORS ARE NOT STABLE. Mutating the container will invalidate all
-//    iterators.
-//
-//  - Insertions may resize the vector and so are not constant time (std::deque
-//    guarantees constant time for insertions at the ends).
-//
-//  - Container-wide comparisons are not implemented. If you want to compare
-//    two containers, use an algorithm so the expensive iteration is explicit.
-//
-// If you want a similar container with only a queue API, use base::queue in
-// base/containers/queue.h.
-//
-// Constructors:
-//   circular_deque();
-//   circular_deque(size_t count);
-//   circular_deque(size_t count, const T& value);
-//   circular_deque(InputIterator first, InputIterator last);
-//   circular_deque(const circular_deque&);
-//   circular_deque(circular_deque&&);
-//   circular_deque(std::initializer_list<value_type>);
-//
-// Assignment functions:
-//   circular_deque& operator=(const circular_deque&);
-//   circular_deque& operator=(circular_deque&&);
-//   circular_deque& operator=(std::initializer_list<T>);
-//   void assign(size_t count, const T& value);
-//   void assign(InputIterator first, InputIterator last);
-//   void assign(std::initializer_list<T> value);
-//
-// Random accessors:
-//   T& at(size_t);
-//   const T& at(size_t) const;
-//   T& operator[](size_t);
-//   const T& operator[](size_t) const;
-//
-// End accessors:
-//   T& front();
-//   const T& front() const;
-//   T& back();
-//   const T& back() const;
-//
-// Iterator functions:
-//   iterator               begin();
-//   const_iterator         begin() const;
-//   const_iterator         cbegin() const;
-//   iterator               end();
-//   const_iterator         end() const;
-//   const_iterator         cend() const;
-//   reverse_iterator       rbegin();
-//   const_reverse_iterator rbegin() const;
-//   const_reverse_iterator crbegin() const;
-//   reverse_iterator       rend();
-//   const_reverse_iterator rend() const;
-//   const_reverse_iterator crend() const;
-//
-// Memory management:
-//   void reserve(size_t);  // SEE IMPLEMENTATION FOR SOME GOTCHAS.
-//   size_t capacity() const;
-//   void shrink_to_fit();
-//
-// Size management:
-//   void clear();
-//   bool empty() const;
-//   size_t size() const;
-//   void resize(size_t);
-//   void resize(size_t count, const T& value);
-//
-// Positional insert and erase:
-//   void insert(const_iterator pos, size_type count, const T& value);
-//   void insert(const_iterator pos,
-//               InputIterator first, InputIterator last);
-//   iterator insert(const_iterator pos, const T& value);
-//   iterator insert(const_iterator pos, T&& value);
-//   iterator emplace(const_iterator pos, Args&&... args);
-//   iterator erase(const_iterator pos);
-//   iterator erase(const_iterator first, const_iterator last);
-//
-// End insert and erase:
-//   void push_front(const T&);
-//   void push_front(T&&);
-//   void push_back(const T&);
-//   void push_back(T&&);
-//   T& emplace_front(Args&&...);
-//   T& emplace_back(Args&&...);
-//   void pop_front();
-//   void pop_back();
-//
-// General:
-//   void swap(circular_deque&);
-
-namespace base {
-
-template <class T>
-class circular_deque;
-
-namespace internal {
-
-// Start allocating nonempty buffers with this many entries. This is the
-// external capacity so the internal buffer will be one larger (= 4) which is
-// more even for the allocator. See the descriptions of internal vs. external
-// capacity on the comment above the buffer_ variable below.
-constexpr size_t kCircularBufferInitialCapacity = 3;
-
-template <typename T>
-class circular_deque_const_iterator {
- public:
-  using difference_type = std::ptrdiff_t;
-  using value_type = T;
-  using pointer = const T*;
-  using reference = const T&;
-  using iterator_category = std::random_access_iterator_tag;
-
-  circular_deque_const_iterator() : parent_deque_(nullptr), index_(0) {
-#if DCHECK_IS_ON()
-    created_generation_ = 0;
-#endif  // DCHECK_IS_ON()
-  }
-
-  // Dereferencing.
-  const T& operator*() const {
-    CheckUnstableUsage();
-    parent_deque_->CheckValidIndex(index_);
-    return parent_deque_->buffer_[index_];
-  }
-  const T* operator->() const {
-    CheckUnstableUsage();
-    parent_deque_->CheckValidIndex(index_);
-    return &parent_deque_->buffer_[index_];
-  }
-  const value_type& operator[](difference_type i) const { return *(*this + i); }
-
-  // Increment and decrement.
-  circular_deque_const_iterator& operator++() {
-    Increment();
-    return *this;
-  }
-  circular_deque_const_iterator operator++(int) {
-    circular_deque_const_iterator ret = *this;
-    Increment();
-    return ret;
-  }
-  circular_deque_const_iterator& operator--() {
-    Decrement();
-    return *this;
-  }
-  circular_deque_const_iterator operator--(int) {
-    circular_deque_const_iterator ret = *this;
-    Decrement();
-    return ret;
-  }
-
-  // Random access mutation.
-  friend circular_deque_const_iterator operator+(
-      const circular_deque_const_iterator& iter,
-      difference_type offset) {
-    circular_deque_const_iterator ret = iter;
-    ret.Add(offset);
-    return ret;
-  }
-  circular_deque_const_iterator& operator+=(difference_type offset) {
-    Add(offset);
-    return *this;
-  }
-  friend circular_deque_const_iterator operator-(
-      const circular_deque_const_iterator& iter,
-      difference_type offset) {
-    circular_deque_const_iterator ret = iter;
-    ret.Add(-offset);
-    return ret;
-  }
-  circular_deque_const_iterator& operator-=(difference_type offset) {
-    Add(-offset);
-    return *this;
-  }
-
-  friend std::ptrdiff_t operator-(const circular_deque_const_iterator& lhs,
-                                  const circular_deque_const_iterator& rhs) {
-    lhs.CheckComparable(rhs);
-    return lhs.OffsetFromBegin() - rhs.OffsetFromBegin();
-  }
-
-  // Comparisons.
-  friend bool operator==(const circular_deque_const_iterator& lhs,
-                         const circular_deque_const_iterator& rhs) {
-    lhs.CheckComparable(rhs);
-    return lhs.index_ == rhs.index_;
-  }
-  friend bool operator!=(const circular_deque_const_iterator& lhs,
-                         const circular_deque_const_iterator& rhs) {
-    return !(lhs == rhs);
-  }
-  friend bool operator<(const circular_deque_const_iterator& lhs,
-                        const circular_deque_const_iterator& rhs) {
-    lhs.CheckComparable(rhs);
-    return lhs.OffsetFromBegin() < rhs.OffsetFromBegin();
-  }
-  friend bool operator<=(const circular_deque_const_iterator& lhs,
-                         const circular_deque_const_iterator& rhs) {
-    return !(lhs > rhs);
-  }
-  friend bool operator>(const circular_deque_const_iterator& lhs,
-                        const circular_deque_const_iterator& rhs) {
-    lhs.CheckComparable(rhs);
-    return lhs.OffsetFromBegin() > rhs.OffsetFromBegin();
-  }
-  friend bool operator>=(const circular_deque_const_iterator& lhs,
-                         const circular_deque_const_iterator& rhs) {
-    return !(lhs < rhs);
-  }
-
- protected:
-  friend class circular_deque<T>;
-
-  circular_deque_const_iterator(const circular_deque<T>* parent, size_t index)
-      : parent_deque_(parent), index_(index) {
-#if DCHECK_IS_ON()
-    created_generation_ = parent->generation_;
-#endif  // DCHECK_IS_ON()
-  }
-
-  // Returns the offset from the beginning index of the buffer to the current
-  // item.
-  size_t OffsetFromBegin() const {
-    if (index_ >= parent_deque_->begin_)
-      return index_ - parent_deque_->begin_;  // On the same side as begin.
-    return parent_deque_->buffer_.capacity() - parent_deque_->begin_ + index_;
-  }
-
-  // Most uses will be ++ and -- so use a simplified implementation.
-  void Increment() {
-    CheckUnstableUsage();
-    parent_deque_->CheckValidIndex(index_);
-    index_++;
-    if (index_ == parent_deque_->buffer_.capacity())
-      index_ = 0;
-  }
-  void Decrement() {
-    CheckUnstableUsage();
-    parent_deque_->CheckValidIndexOrEnd(index_);
-    if (index_ == 0)
-      index_ = parent_deque_->buffer_.capacity() - 1;
-    else
-      index_--;
-  }
-  void Add(difference_type delta) {
-    CheckUnstableUsage();
-#if DCHECK_IS_ON()
-    if (delta <= 0)
-      parent_deque_->CheckValidIndexOrEnd(index_);
-    else
-      parent_deque_->CheckValidIndex(index_);
-#endif
-    // It should be valid to add 0 to any iterator, even if the container is
-    // empty and the iterator points to end(). The modulo below will divide
-    // by 0 if the buffer capacity is empty, so it's important to check for
-    // this case explicitly.
-    if (delta == 0)
-      return;
-
-    difference_type new_offset = OffsetFromBegin() + delta;
-    DCHECK(new_offset >= 0 &&
-           new_offset <= static_cast<difference_type>(parent_deque_->size()));
-    index_ = (new_offset + parent_deque_->begin_) %
-             parent_deque_->buffer_.capacity();
-  }
-
-#if DCHECK_IS_ON()
-  void CheckUnstableUsage() const {
-    DCHECK(parent_deque_);
-    // Since circular_deque doesn't guarantee stability, any attempt to
-    // dereference this iterator after a mutation (i.e. the generation doesn't
-    // match the original) in the container is illegal.
-    DCHECK_EQ(created_generation_, parent_deque_->generation_)
-        << "circular_deque iterator dereferenced after mutation.";
-  }
-  void CheckComparable(const circular_deque_const_iterator& other) const {
-    DCHECK_EQ(parent_deque_, other.parent_deque_);
-    // Since circular_deque doesn't guarantee stability, two iterators that
-    // are compared must have been generated without mutating the container.
-    // If this fires, the container was mutated between generating the two
-    // iterators being compared.
-    DCHECK_EQ(created_generation_, other.created_generation_);
-  }
-#else
-  inline void CheckUnstableUsage() const {}
-  inline void CheckComparable(const circular_deque_const_iterator&) const {}
-#endif  // DCHECK_IS_ON()
-
-  const circular_deque<T>* parent_deque_;
-  size_t index_;
-
-#if DCHECK_IS_ON()
-  // The generation of the parent deque when this iterator was created. The
-  // container will update the generation for every modification so we can
-  // test if the container was modified by comparing them.
-  uint64_t created_generation_;
-#endif  // DCHECK_IS_ON()
-};
-
-template <typename T>
-class circular_deque_iterator : public circular_deque_const_iterator<T> {
-  using base = circular_deque_const_iterator<T>;
-
- public:
-  friend class circular_deque<T>;
-
-  using difference_type = std::ptrdiff_t;
-  using value_type = T;
-  using pointer = T*;
-  using reference = T&;
-  using iterator_category = std::random_access_iterator_tag;
-
-  // Expose the base class' constructor.
-  circular_deque_iterator() : circular_deque_const_iterator<T>() {}
-
-  // Dereferencing.
-  T& operator*() const { return const_cast<T&>(base::operator*()); }
-  T* operator->() const { return const_cast<T*>(base::operator->()); }
-  T& operator[](difference_type i) {
-    return const_cast<T&>(base::operator[](i));
-  }
-
-  // Random access mutation.
-  friend circular_deque_iterator operator+(const circular_deque_iterator& iter,
-                                           difference_type offset) {
-    circular_deque_iterator ret = iter;
-    ret.Add(offset);
-    return ret;
-  }
-  circular_deque_iterator& operator+=(difference_type offset) {
-    base::Add(offset);
-    return *this;
-  }
-  friend circular_deque_iterator operator-(const circular_deque_iterator& iter,
-                                           difference_type offset) {
-    circular_deque_iterator ret = iter;
-    ret.Add(-offset);
-    return ret;
-  }
-  circular_deque_iterator& operator-=(difference_type offset) {
-    base::Add(-offset);
-    return *this;
-  }
-
-  // Increment and decrement.
-  circular_deque_iterator& operator++() {
-    base::Increment();
-    return *this;
-  }
-  circular_deque_iterator operator++(int) {
-    circular_deque_iterator ret = *this;
-    base::Increment();
-    return ret;
-  }
-  circular_deque_iterator& operator--() {
-    base::Decrement();
-    return *this;
-  }
-  circular_deque_iterator operator--(int) {
-    circular_deque_iterator ret = *this;
-    base::Decrement();
-    return ret;
-  }
-
- private:
-  circular_deque_iterator(const circular_deque<T>* parent, size_t index)
-      : circular_deque_const_iterator<T>(parent, index) {}
-};
-
-}  // namespace internal
-
-template <typename T>
-class circular_deque {
- private:
-  using VectorBuffer = internal::VectorBuffer<T>;
-
- public:
-  using value_type = T;
-  using size_type = std::size_t;
-  using difference_type = std::ptrdiff_t;
-  using reference = value_type&;
-  using const_reference = const value_type&;
-  using pointer = value_type*;
-  using const_pointer = const value_type*;
-
-  using iterator = internal::circular_deque_iterator<T>;
-  using const_iterator = internal::circular_deque_const_iterator<T>;
-  using reverse_iterator = std::reverse_iterator<iterator>;
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-
-  // ---------------------------------------------------------------------------
-  // Constructor
-
-  constexpr circular_deque() = default;
-
-  // Constructs with |count| copies of |value| or default constructed version.
-  circular_deque(size_type count) { resize(count); }
-  circular_deque(size_type count, const T& value) { resize(count, value); }
-
-  // Range constructor.
-  template <class InputIterator>
-  circular_deque(InputIterator first, InputIterator last) {
-    assign(first, last);
-  }
-
-  // Copy/move.
-  circular_deque(const circular_deque& other) : buffer_(other.size() + 1) {
-    assign(other.begin(), other.end());
-  }
-  circular_deque(circular_deque&& other) noexcept
-      : buffer_(std::move(other.buffer_)),
-        begin_(other.begin_),
-        end_(other.end_) {
-    other.begin_ = 0;
-    other.end_ = 0;
-  }
-
-  circular_deque(std::initializer_list<value_type> init) { assign(init); }
-
-  ~circular_deque() { DestructRange(begin_, end_); }
-
-  // ---------------------------------------------------------------------------
-  // Assignments.
-  //
-  // All of these may invalidate iterators and references.
-
-  circular_deque& operator=(const circular_deque& other) {
-    if (&other == this)
-      return *this;
-
-    reserve(other.size());
-    assign(other.begin(), other.end());
-    return *this;
-  }
-  circular_deque& operator=(circular_deque&& other) noexcept {
-    if (&other == this)
-      return *this;
-
-    // We're about to overwrite the buffer, so don't free it in clear to
-    // avoid doing it twice.
-    ClearRetainCapacity();
-    buffer_ = std::move(other.buffer_);
-    begin_ = other.begin_;
-    end_ = other.end_;
-
-    other.begin_ = 0;
-    other.end_ = 0;
-
-    IncrementGeneration();
-    return *this;
-  }
-  circular_deque& operator=(std::initializer_list<value_type> ilist) {
-    reserve(ilist.size());
-    assign(std::begin(ilist), std::end(ilist));
-    return *this;
-  }
-
-  void assign(size_type count, const value_type& value) {
-    ClearRetainCapacity();
-    reserve(count);
-    for (size_t i = 0; i < count; i++)
-      emplace_back(value);
-    IncrementGeneration();
-  }
-
-  // This variant should be enabled only when InputIterator is an iterator.
-  template <typename InputIterator>
-  typename std::enable_if<::base::internal::is_iterator<InputIterator>::value,
-                          void>::type
-  assign(InputIterator first, InputIterator last) {
-    // Possible future enhancement, dispatch on iterator tag type. For forward
-    // iterators we can use std::difference to preallocate the space required
-    // and only do one copy.
-    ClearRetainCapacity();
-    for (; first != last; ++first)
-      emplace_back(*first);
-    IncrementGeneration();
-  }
-
-  void assign(std::initializer_list<value_type> value) {
-    reserve(std::distance(value.begin(), value.end()));
-    assign(value.begin(), value.end());
-  }
-
-  // ---------------------------------------------------------------------------
-  // Accessors.
-  //
-  // Since this class assumes no exceptions, at() and operator[] are equivalent.
-
-  const value_type& at(size_type i) const {
-    DCHECK(i < size());
-    size_t right_size = buffer_.capacity() - begin_;
-    if (begin_ <= end_ || i < right_size)
-      return buffer_[begin_ + i];
-    return buffer_[i - right_size];
-  }
-  value_type& at(size_type i) {
-    return const_cast<value_type&>(
-        const_cast<const circular_deque*>(this)->at(i));
-  }
-
-  value_type& operator[](size_type i) { return at(i); }
-  const value_type& operator[](size_type i) const {
-    return const_cast<circular_deque*>(this)->at(i);
-  }
-
-  value_type& front() {
-    DCHECK(!empty());
-    return buffer_[begin_];
-  }
-  const value_type& front() const {
-    DCHECK(!empty());
-    return buffer_[begin_];
-  }
-
-  value_type& back() {
-    DCHECK(!empty());
-    return *(--end());
-  }
-  const value_type& back() const {
-    DCHECK(!empty());
-    return *(--end());
-  }
-
-  // ---------------------------------------------------------------------------
-  // Iterators.
-
-  iterator begin() { return iterator(this, begin_); }
-  const_iterator begin() const { return const_iterator(this, begin_); }
-  const_iterator cbegin() const { return const_iterator(this, begin_); }
-
-  iterator end() { return iterator(this, end_); }
-  const_iterator end() const { return const_iterator(this, end_); }
-  const_iterator cend() const { return const_iterator(this, end_); }
-
-  reverse_iterator rbegin() { return reverse_iterator(end()); }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(end());
-  }
-  const_reverse_iterator crbegin() const { return rbegin(); }
-
-  reverse_iterator rend() { return reverse_iterator(begin()); }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(begin());
-  }
-  const_reverse_iterator crend() const { return rend(); }
-
-  // ---------------------------------------------------------------------------
-  // Memory management.
-
-  // IMPORTANT NOTE ON reserve(...): This class implements auto-shrinking of
-  // the buffer when elements are deleted and there is "too much" wasted space.
-  // So if you call reserve() with a large size in anticipation of pushing many
-  // elements, but pop an element before the queue is full, the capacity you
-  // reserved may be lost.
-  //
-  // As a result, it's only worthwhile to call reserve() when you're adding
-  // many things at once with no intermediate operations.
-  void reserve(size_type new_capacity) {
-    if (new_capacity > capacity())
-      SetCapacityTo(new_capacity);
-  }
-
-  size_type capacity() const {
-    // One item is wasted to indicate end().
-    return buffer_.capacity() == 0 ? 0 : buffer_.capacity() - 1;
-  }
-
-  void shrink_to_fit() {
-    if (empty()) {
-      // Optimize empty case to really delete everything if there was
-      // something.
-      if (buffer_.capacity())
-        buffer_ = VectorBuffer();
-    } else {
-      SetCapacityTo(size());
-    }
-  }
-
-  // ---------------------------------------------------------------------------
-  // Size management.
-
-  // This will additionally reset the capacity() to 0.
-  void clear() {
-    // This can't resize(0) because that requires a default constructor to
-    // compile, which not all contained classes may implement.
-    ClearRetainCapacity();
-    buffer_ = VectorBuffer();
-  }
-
-  bool empty() const { return begin_ == end_; }
-
-  size_type size() const {
-    if (begin_ <= end_)
-      return end_ - begin_;
-    return buffer_.capacity() - begin_ + end_;
-  }
-
-  // When reducing size, the elements are deleted from the end. When expanding
-  // size, elements are added to the end with |value| or the default
-  // constructed version. Even when using resize(count) to shrink, a default
-  // constructor is required for the code to compile, even though it will not
-  // be called.
-  //
-  // There are two versions rather than using a default value to avoid
-  // creating a temporary when shrinking (when it's not needed). Plus if
-  // the default constructor is desired when expanding usually just calling it
-  // for each element is faster than making a default-constructed temporary and
-  // copying it.
-  void resize(size_type count) {
-    // SEE BELOW VERSION if you change this. The code is mostly the same.
-    if (count > size()) {
-      // This could be slighly more efficient but expanding a queue with
-      // identical elements is unusual and the extra computations of emplacing
-      // one-by-one will typically be small relative to calling the constructor
-      // for every item.
-      ExpandCapacityIfNecessary(count - size());
-      while (size() < count)
-        emplace_back();
-    } else if (count < size()) {
-      size_t new_end = (begin_ + count) % buffer_.capacity();
-      DestructRange(new_end, end_);
-      end_ = new_end;
-
-      ShrinkCapacityIfNecessary();
-    }
-    IncrementGeneration();
-  }
-  void resize(size_type count, const value_type& value) {
-    // SEE ABOVE VERSION if you change this. The code is mostly the same.
-    if (count > size()) {
-      ExpandCapacityIfNecessary(count - size());
-      while (size() < count)
-        emplace_back(value);
-    } else if (count < size()) {
-      size_t new_end = (begin_ + count) % buffer_.capacity();
-      DestructRange(new_end, end_);
-      end_ = new_end;
-
-      ShrinkCapacityIfNecessary();
-    }
-    IncrementGeneration();
-  }
-
-  // ---------------------------------------------------------------------------
-  // Insert and erase.
-  //
-  // Insertion and deletion in the middle is O(n) and invalidates all existing
-  // iterators.
-  //
-  // The implementation of insert isn't optimized as much as it could be. If
-  // the insertion requires that the buffer be grown, it will first be grown
-  // and everything moved, and then the items will be inserted, potentially
-  // moving some items twice. This simplifies the implemntation substantially
-  // and means less generated templatized code. Since this is an uncommon
-  // operation for deques, and already relatively slow, it doesn't seem worth
-  // the benefit to optimize this.
-
-  void insert(const_iterator pos, size_type count, const T& value) {
-    ValidateIterator(pos);
-
-    // Optimize insert at the beginning.
-    if (pos == begin()) {
-      ExpandCapacityIfNecessary(count);
-      for (size_t i = 0; i < count; i++)
-        push_front(value);
-      return;
-    }
-
-    iterator insert_cur(this, pos.index_);
-    iterator insert_end;
-    MakeRoomFor(count, &insert_cur, &insert_end);
-    while (insert_cur < insert_end) {
-      new (&buffer_[insert_cur.index_]) T(value);
-      ++insert_cur;
-    }
-
-    IncrementGeneration();
-  }
-
-  // This enable_if keeps this call from getting confused with the (pos, count,
-  // value) version when value is an integer.
-  template <class InputIterator>
-  typename std::enable_if<::base::internal::is_iterator<InputIterator>::value,
-                          void>::type
-  insert(const_iterator pos, InputIterator first, InputIterator last) {
-    ValidateIterator(pos);
-
-    size_t inserted_items = std::distance(first, last);
-    if (inserted_items == 0)
-      return;  // Can divide by 0 when doing modulo below, so return early.
-
-    // Make a hole to copy the items into.
-    iterator insert_cur;
-    iterator insert_end;
-    if (pos == begin()) {
-      // Optimize insert at the beginning, nothing needs to be shifted and the
-      // hole is the |inserted_items| block immediately before |begin_|.
-      ExpandCapacityIfNecessary(inserted_items);
-      insert_end = begin();
-      begin_ =
-          (begin_ + buffer_.capacity() - inserted_items) % buffer_.capacity();
-      insert_cur = begin();
-    } else {
-      insert_cur = iterator(this, pos.index_);
-      MakeRoomFor(inserted_items, &insert_cur, &insert_end);
-    }
-
-    // Copy the items.
-    while (insert_cur < insert_end) {
-      new (&buffer_[insert_cur.index_]) T(*first);
-      ++insert_cur;
-      ++first;
-    }
-
-    IncrementGeneration();
-  }
-
-  // These all return an iterator to the inserted item. Existing iterators will
-  // be invalidated.
-  iterator insert(const_iterator pos, const T& value) {
-    return emplace(pos, value);
-  }
-  iterator insert(const_iterator pos, T&& value) {
-    return emplace(pos, std::move(value));
-  }
-  template <class... Args>
-  iterator emplace(const_iterator pos, Args&&... args) {
-    ValidateIterator(pos);
-
-    // Optimize insert at beginning which doesn't require shifting.
-    if (pos == cbegin()) {
-      emplace_front(std::forward<Args>(args)...);
-      return begin();
-    }
-
-    // Do this before we make the new iterators we return.
-    IncrementGeneration();
-
-    iterator insert_begin(this, pos.index_);
-    iterator insert_end;
-    MakeRoomFor(1, &insert_begin, &insert_end);
-    new (&buffer_[insert_begin.index_]) T(std::forward<Args>(args)...);
-
-    return insert_begin;
-  }
-
-  // Calling erase() won't automatically resize the buffer smaller like resize
-  // or the pop functions. Erase is slow and relatively uncommon, and for
-  // normal deque usage a pop will normally be done on a regular basis that
-  // will prevent excessive buffer usage over long periods of time. It's not
-  // worth having the extra code for every template instantiation of erase()
-  // to resize capacity downward to a new buffer.
-  iterator erase(const_iterator pos) { return erase(pos, pos + 1); }
-  iterator erase(const_iterator first, const_iterator last) {
-    ValidateIterator(first);
-    ValidateIterator(last);
-
-    IncrementGeneration();
-
-    // First, call the destructor on the deleted items.
-    if (first.index_ == last.index_) {
-      // Nothing deleted. Need to return early to avoid falling through to
-      // moving items on top of themselves.
-      return iterator(this, first.index_);
-    } else if (first.index_ < last.index_) {
-      // Contiguous range.
-      buffer_.DestructRange(&buffer_[first.index_], &buffer_[last.index_]);
-    } else {
-      // Deleted range wraps around.
-      buffer_.DestructRange(&buffer_[first.index_],
-                            &buffer_[buffer_.capacity()]);
-      buffer_.DestructRange(&buffer_[0], &buffer_[last.index_]);
-    }
-
-    if (first.index_ == begin_) {
-      // This deletion is from the beginning. Nothing needs to be copied, only
-      // begin_ needs to be updated.
-      begin_ = last.index_;
-      return iterator(this, last.index_);
-    }
-
-    // In an erase operation, the shifted items all move logically to the left,
-    // so move them from left-to-right.
-    iterator move_src(this, last.index_);
-    iterator move_src_end = end();
-    iterator move_dest(this, first.index_);
-    for (; move_src < move_src_end; move_src++, move_dest++) {
-      buffer_.MoveRange(&buffer_[move_src.index_],
-                        &buffer_[move_src.index_ + 1],
-                        &buffer_[move_dest.index_]);
-    }
-
-    end_ = move_dest.index_;
-
-    // Since we did not reallocate and only changed things after the erase
-    // element(s), the input iterator's index points to the thing following the
-    // deletion.
-    return iterator(this, first.index_);
-  }
-
-  // ---------------------------------------------------------------------------
-  // Begin/end operations.
-
-  void push_front(const T& value) { emplace_front(value); }
-  void push_front(T&& value) { emplace_front(std::move(value)); }
-
-  void push_back(const T& value) { emplace_back(value); }
-  void push_back(T&& value) { emplace_back(std::move(value)); }
-
-  template <class... Args>
-  reference emplace_front(Args&&... args) {
-    ExpandCapacityIfNecessary(1);
-    if (begin_ == 0)
-      begin_ = buffer_.capacity() - 1;
-    else
-      begin_--;
-    IncrementGeneration();
-    new (&buffer_[begin_]) T(std::forward<Args>(args)...);
-    return front();
-  }
-
-  template <class... Args>
-  reference emplace_back(Args&&... args) {
-    ExpandCapacityIfNecessary(1);
-    new (&buffer_[end_]) T(std::forward<Args>(args)...);
-    if (end_ == buffer_.capacity() - 1)
-      end_ = 0;
-    else
-      end_++;
-    IncrementGeneration();
-    return back();
-  }
-
-  void pop_front() {
-    DCHECK(size());
-    buffer_.DestructRange(&buffer_[begin_], &buffer_[begin_ + 1]);
-    begin_++;
-    if (begin_ == buffer_.capacity())
-      begin_ = 0;
-
-    ShrinkCapacityIfNecessary();
-
-    // Technically popping will not invalidate any iterators since the
-    // underlying buffer will be stable. But in the future we may want to add a
-    // feature that resizes the buffer smaller if there is too much wasted
-    // space. This ensures we can make such a change safely.
-    IncrementGeneration();
-  }
-  void pop_back() {
-    DCHECK(size());
-    if (end_ == 0)
-      end_ = buffer_.capacity() - 1;
-    else
-      end_--;
-    buffer_.DestructRange(&buffer_[end_], &buffer_[end_ + 1]);
-
-    ShrinkCapacityIfNecessary();
-
-    // See pop_front comment about why this is here.
-    IncrementGeneration();
-  }
-
-  // ---------------------------------------------------------------------------
-  // General operations.
-
-  void swap(circular_deque& other) {
-    std::swap(buffer_, other.buffer_);
-    std::swap(begin_, other.begin_);
-    std::swap(end_, other.end_);
-    IncrementGeneration();
-  }
-
-  friend void swap(circular_deque& lhs, circular_deque& rhs) { lhs.swap(rhs); }
-
- private:
-  friend internal::circular_deque_iterator<T>;
-  friend internal::circular_deque_const_iterator<T>;
-
-  // Moves the items in the given circular buffer to the current one. The
-  // source is moved from so will become invalid. The destination buffer must
-  // have already been allocated with enough size.
-  static void MoveBuffer(VectorBuffer& from_buf,
-                         size_t from_begin,
-                         size_t from_end,
-                         VectorBuffer* to_buf,
-                         size_t* to_begin,
-                         size_t* to_end) {
-    size_t from_capacity = from_buf.capacity();
-
-    *to_begin = 0;
-    if (from_begin < from_end) {
-      // Contiguous.
-      from_buf.MoveRange(&from_buf[from_begin], &from_buf[from_end],
-                         to_buf->begin());
-      *to_end = from_end - from_begin;
-    } else if (from_begin > from_end) {
-      // Discontiguous, copy the right side to the beginning of the new buffer.
-      from_buf.MoveRange(&from_buf[from_begin], &from_buf[from_capacity],
-                         to_buf->begin());
-      size_t right_size = from_capacity - from_begin;
-      // Append the left side.
-      from_buf.MoveRange(&from_buf[0], &from_buf[from_end],
-                         &(*to_buf)[right_size]);
-      *to_end = right_size + from_end;
-    } else {
-      // No items.
-      *to_end = 0;
-    }
-  }
-
-  // Expands the buffer size. This assumes the size is larger than the
-  // number of elements in the vector (it won't call delete on anything).
-  void SetCapacityTo(size_t new_capacity) {
-    // Use the capacity + 1 as the internal buffer size to differentiate
-    // empty and full (see definition of buffer_ below).
-    VectorBuffer new_buffer(new_capacity + 1);
-    MoveBuffer(buffer_, begin_, end_, &new_buffer, &begin_, &end_);
-    buffer_ = std::move(new_buffer);
-  }
-  void ExpandCapacityIfNecessary(size_t additional_elts) {
-    size_t min_new_capacity = size() + additional_elts;
-    if (capacity() >= min_new_capacity)
-      return;  // Already enough room.
-
-    min_new_capacity =
-        std::max(min_new_capacity, internal::kCircularBufferInitialCapacity);
-
-    // std::vector always grows by at least 50%. WTF::Deque grows by at least
-    // 25%. We expect queue workloads to generally stay at a similar size and
-    // grow less than a vector might, so use 25%.
-    size_t new_capacity =
-        std::max(min_new_capacity, capacity() + capacity() / 4);
-    SetCapacityTo(new_capacity);
-  }
-
-  void ShrinkCapacityIfNecessary() {
-    // Don't auto-shrink below this size.
-    if (capacity() <= internal::kCircularBufferInitialCapacity)
-      return;
-
-    // Shrink when 100% of the size() is wasted.
-    size_t sz = size();
-    size_t empty_spaces = capacity() - sz;
-    if (empty_spaces < sz)
-      return;
-
-    // Leave 1/4 the size as free capacity, not going below the initial
-    // capacity.
-    size_t new_capacity =
-        std::max(internal::kCircularBufferInitialCapacity, sz + sz / 4);
-    if (new_capacity < capacity()) {
-      // Count extra item to convert to internal capacity.
-      SetCapacityTo(new_capacity);
-    }
-  }
-
-  // Backend for clear() but does not resize the internal buffer.
-  void ClearRetainCapacity() {
-    // This can't resize(0) because that requires a default constructor to
-    // compile, which not all contained classes may implement.
-    DestructRange(begin_, end_);
-    begin_ = 0;
-    end_ = 0;
-    IncrementGeneration();
-  }
-
-  // Calls destructors for the given begin->end indices. The indices may wrap
-  // around. The buffer is not resized, and the begin_ and end_ members are
-  // not changed.
-  void DestructRange(size_t begin, size_t end) {
-    if (end == begin) {
-      return;
-    } else if (end > begin) {
-      buffer_.DestructRange(&buffer_[begin], &buffer_[end]);
-    } else {
-      buffer_.DestructRange(&buffer_[begin], &buffer_[buffer_.capacity()]);
-      buffer_.DestructRange(&buffer_[0], &buffer_[end]);
-    }
-  }
-
-  // Makes room for |count| items starting at |*insert_begin|. Since iterators
-  // are not stable across buffer resizes, |*insert_begin| will be updated to
-  // point to the beginning of the newly opened position in the new array (it's
-  // in/out), and the end of the newly opened position (it's out-only).
-  void MakeRoomFor(size_t count, iterator* insert_begin, iterator* insert_end) {
-    if (count == 0) {
-      *insert_end = *insert_begin;
-      return;
-    }
-
-    // The offset from the beginning will be stable across reallocations.
-    size_t begin_offset = insert_begin->OffsetFromBegin();
-    ExpandCapacityIfNecessary(count);
-
-    insert_begin->index_ = (begin_ + begin_offset) % buffer_.capacity();
-    *insert_end =
-        iterator(this, (insert_begin->index_ + count) % buffer_.capacity());
-
-    // Update the new end and prepare the iterators for copying.
-    iterator src = end();
-    end_ = (end_ + count) % buffer_.capacity();
-    iterator dest = end();
-
-    // Move the elements. This will always involve shifting logically to the
-    // right, so move in a right-to-left order.
-    while (true) {
-      if (src == *insert_begin)
-        break;
-      --src;
-      --dest;
-      buffer_.MoveRange(&buffer_[src.index_], &buffer_[src.index_ + 1],
-                        &buffer_[dest.index_]);
-    }
-  }
-
-#if DCHECK_IS_ON()
-  // Asserts the given index is dereferencable. The index is an index into the
-  // buffer, not an index used by operator[] or at() which will be offsets from
-  // begin.
-  void CheckValidIndex(size_t i) const {
-    if (begin_ <= end_)
-      DCHECK(i >= begin_ && i < end_);
-    else
-      DCHECK((i >= begin_ && i < buffer_.capacity()) || i < end_);
-  }
-
-  // Asserts the given index is either dereferencable or points to end().
-  void CheckValidIndexOrEnd(size_t i) const {
-    if (i != end_)
-      CheckValidIndex(i);
-  }
-
-  void ValidateIterator(const const_iterator& i) const {
-    DCHECK(i.parent_deque_ == this);
-    i.CheckUnstableUsage();
-  }
-
-  // See generation_ below.
-  void IncrementGeneration() { generation_++; }
-#else
-  // No-op versions of these functions for release builds.
-  void CheckValidIndex(size_t) const {}
-  void CheckValidIndexOrEnd(size_t) const {}
-  void ValidateIterator(const const_iterator& i) const {}
-  void IncrementGeneration() {}
-#endif
-
-  // Danger, the buffer_.capacity() is the "internal capacity" which is
-  // capacity() + 1 since there is an extra item to indicate the end. Otherwise
-  // being completely empty and completely full are indistinguishable (begin ==
-  // end). We could add a separate flag to avoid it, but that adds significant
-  // extra complexity since every computation will have to check for it. Always
-  // keeping one extra unused element in the buffer makes iterator computations
-  // much simpler.
-  //
-  // Container internal code will want to use buffer_.capacity() for offset
-  // computations rather than capacity().
-  VectorBuffer buffer_;
-  size_type begin_ = 0;
-  size_type end_ = 0;
-
-#if DCHECK_IS_ON()
-  // Incremented every time a modification is made that could affect iterator
-  // invalidations.
-  uint64_t generation_ = 0;
-#endif
-};
-
-// Implementations of base::Erase[If] (see base/stl_util.h).
-template <class T, class Value>
-void Erase(circular_deque<T>& container, const Value& value) {
-  container.erase(std::remove(container.begin(), container.end(), value),
-                  container.end());
-}
-
-template <class T, class Predicate>
-void EraseIf(circular_deque<T>& container, Predicate pred) {
-  container.erase(std::remove_if(container.begin(), container.end(), pred),
-                  container.end());
-}
-
-}  // namespace base
-
-#endif  // BASE_CONTAINERS_CIRCULAR_DEQUE_H_
diff --git a/native/zucchini/vendor/libchrome/base/containers/queue.h b/native/zucchini/vendor/libchrome/base/containers/queue.h
deleted file mode 100644
index b5bc5c3..0000000
--- a/native/zucchini/vendor/libchrome/base/containers/queue.h
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CONTAINERS_QUEUE_H_
-#define BASE_CONTAINERS_QUEUE_H_
-
-#include <queue>
-
-#include "base/containers/circular_deque.h"
-
-namespace base {
-
-// Provides a definition of base::queue that's like std::queue but uses a
-// base::circular_deque instead of std::deque. Since std::queue is just a
-// wrapper for an underlying type, we can just provide a typedef for it that
-// defaults to the base circular_deque.
-template <class T, class Container = circular_deque<T>>
-using queue = std::queue<T, Container>;
-
-}  // namespace base
-
-#endif  // BASE_CONTAINERS_QUEUE_H_
diff --git a/native/zucchini/vendor/libchrome/base/containers/span.h b/native/zucchini/vendor/libchrome/base/containers/span.h
deleted file mode 100644
index f1e0000..0000000
--- a/native/zucchini/vendor/libchrome/base/containers/span.h
+++ /dev/null
@@ -1,453 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CONTAINERS_SPAN_H_
-#define BASE_CONTAINERS_SPAN_H_
-
-#include <stddef.h>
-
-#include <algorithm>
-#include <array>
-#include <iterator>
-#include <type_traits>
-#include <utility>
-
-#include "base/logging.h"
-#include "base/stl_util.h"
-
-namespace base {
-
-// [views.constants]
-constexpr size_t dynamic_extent = static_cast<size_t>(-1);
-
-template <typename T, size_t Extent = dynamic_extent>
-class span;
-
-namespace internal {
-
-template <typename T>
-struct IsSpanImpl : std::false_type {};
-
-template <typename T, size_t Extent>
-struct IsSpanImpl<span<T, Extent>> : std::true_type {};
-
-template <typename T>
-using IsSpan = IsSpanImpl<std::decay_t<T>>;
-
-template <typename T>
-struct IsStdArrayImpl : std::false_type {};
-
-template <typename T, size_t N>
-struct IsStdArrayImpl<std::array<T, N>> : std::true_type {};
-
-template <typename T>
-using IsStdArray = IsStdArrayImpl<std::decay_t<T>>;
-
-template <typename T>
-using IsCArray = std::is_array<std::remove_reference_t<T>>;
-
-template <typename From, typename To>
-using IsLegalDataConversion = std::is_convertible<From (*)[], To (*)[]>;
-
-template <typename Container, typename T>
-using ContainerHasConvertibleData = IsLegalDataConversion<
-    std::remove_pointer_t<decltype(base::data(std::declval<Container>()))>,
-    T>;
-
-template <typename Container>
-using ContainerHasIntegralSize =
-    std::is_integral<decltype(base::size(std::declval<Container>()))>;
-
-template <typename From, size_t FromExtent, typename To, size_t ToExtent>
-using EnableIfLegalSpanConversion =
-    std::enable_if_t<(ToExtent == dynamic_extent || ToExtent == FromExtent) &&
-                     IsLegalDataConversion<From, To>::value>;
-
-// SFINAE check if Array can be converted to a span<T>.
-template <typename Array, size_t N, typename T, size_t Extent>
-using EnableIfSpanCompatibleArray =
-    std::enable_if_t<(Extent == dynamic_extent || Extent == N) &&
-                     ContainerHasConvertibleData<Array, T>::value>;
-
-// SFINAE check if Container can be converted to a span<T>.
-template <typename Container, typename T>
-using EnableIfSpanCompatibleContainer =
-    std::enable_if_t<!internal::IsSpan<Container>::value &&
-                     !internal::IsStdArray<Container>::value &&
-                     !internal::IsCArray<Container>::value &&
-                     ContainerHasConvertibleData<Container, T>::value &&
-                     ContainerHasIntegralSize<Container>::value>;
-
-}  // namespace internal
-
-// A span is a value type that represents an array of elements of type T. Since
-// it only consists of a pointer to memory with an associated size, it is very
-// light-weight. It is cheap to construct, copy, move and use spans, so that
-// users are encouraged to use it as a pass-by-value parameter. A span does not
-// own the underlying memory, so care must be taken to ensure that a span does
-// not outlive the backing store.
-//
-// span is somewhat analogous to StringPiece, but with arbitrary element types,
-// allowing mutation if T is non-const.
-//
-// span is implicitly convertible from C++ arrays, as well as most [1]
-// container-like types that provide a data() and size() method (such as
-// std::vector<T>). A mutable span<T> can also be implicitly converted to an
-// immutable span<const T>.
-//
-// Consider using a span for functions that take a data pointer and size
-// parameter: it allows the function to still act on an array-like type, while
-// allowing the caller code to be a bit more concise.
-//
-// For read-only data access pass a span<const T>: the caller can supply either
-// a span<const T> or a span<T>, while the callee will have a read-only view.
-// For read-write access a mutable span<T> is required.
-//
-// Without span:
-//   Read-Only:
-//     // std::string HexEncode(const uint8_t* data, size_t size);
-//     std::vector<uint8_t> data_buffer = GenerateData();
-//     std::string r = HexEncode(data_buffer.data(), data_buffer.size());
-//
-//  Mutable:
-//     // ssize_t SafeSNPrintf(char* buf, size_t N, const char* fmt, Args...);
-//     char str_buffer[100];
-//     SafeSNPrintf(str_buffer, sizeof(str_buffer), "Pi ~= %lf", 3.14);
-//
-// With span:
-//   Read-Only:
-//     // std::string HexEncode(base::span<const uint8_t> data);
-//     std::vector<uint8_t> data_buffer = GenerateData();
-//     std::string r = HexEncode(data_buffer);
-//
-//  Mutable:
-//     // ssize_t SafeSNPrintf(base::span<char>, const char* fmt, Args...);
-//     char str_buffer[100];
-//     SafeSNPrintf(str_buffer, "Pi ~= %lf", 3.14);
-//
-// Spans with "const" and pointers
-// -------------------------------
-//
-// Const and pointers can get confusing. Here are vectors of pointers and their
-// corresponding spans:
-//
-//   const std::vector<int*>        =>  base::span<int* const>
-//   std::vector<const int*>        =>  base::span<const int*>
-//   const std::vector<const int*>  =>  base::span<const int* const>
-//
-// Differences from the working group proposal
-// -------------------------------------------
-//
-// https://wg21.link/P0122 is the latest working group proposal, Chromium
-// currently implements R7. Differences between the proposal and the
-// implementation are documented in subsections below.
-//
-// Differences from [span.objectrep]:
-// - as_bytes() and as_writable_bytes() return spans of uint8_t instead of
-//   std::byte
-//
-// Differences in constants and types:
-// - index_type is aliased to size_t
-//
-// Differences from [span.sub]:
-// - using size_t instead of ptrdiff_t for indexing
-//
-// Differences from [span.obs]:
-// - using size_t instead of ptrdiff_t to represent size()
-//
-// Differences from [span.elem]:
-// - using size_t instead of ptrdiff_t for indexing
-//
-// Furthermore, all constructors and methods are marked noexcept due to the lack
-// of exceptions in Chromium.
-//
-// Due to the lack of class template argument deduction guides in C++14
-// appropriate make_span() utility functions are provided.
-
-// [span], class template span
-template <typename T, size_t Extent>
-class span {
- public:
-  using element_type = T;
-  using value_type = std::remove_cv_t<T>;
-  using index_type = size_t;
-  using difference_type = ptrdiff_t;
-  using pointer = T*;
-  using reference = T&;
-  using iterator = T*;
-  using const_iterator = const T*;
-  using reverse_iterator = std::reverse_iterator<iterator>;
-  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
-  static constexpr index_type extent = Extent;
-
-  // [span.cons], span constructors, copy, assignment, and destructor
-  constexpr span() noexcept : data_(nullptr), size_(0) {
-    static_assert(Extent == dynamic_extent || Extent == 0, "Invalid Extent");
-  }
-
-  constexpr span(T* data, size_t size) noexcept : data_(data), size_(size) {
-    CHECK(Extent == dynamic_extent || Extent == size);
-  }
-
-  // Artificially templatized to break ambiguity for span(ptr, 0).
-  template <typename = void>
-  constexpr span(T* begin, T* end) noexcept : span(begin, end - begin) {
-    // Note: CHECK_LE is not constexpr, hence regular CHECK must be used.
-    CHECK(begin <= end);
-  }
-
-  template <
-      size_t N,
-      typename = internal::EnableIfSpanCompatibleArray<T (&)[N], N, T, Extent>>
-  constexpr span(T (&array)[N]) noexcept : span(base::data(array), N) {}
-
-  template <
-      size_t N,
-      typename = internal::
-          EnableIfSpanCompatibleArray<std::array<value_type, N>&, N, T, Extent>>
-  constexpr span(std::array<value_type, N>& array) noexcept
-      : span(base::data(array), N) {}
-
-  template <size_t N,
-            typename = internal::EnableIfSpanCompatibleArray<
-                const std::array<value_type, N>&,
-                N,
-                T,
-                Extent>>
-  constexpr span(const std::array<value_type, N>& array) noexcept
-      : span(base::data(array), N) {}
-
-  // Conversion from a container that has compatible base::data() and integral
-  // base::size().
-  template <typename Container,
-            typename = internal::EnableIfSpanCompatibleContainer<Container&, T>>
-  constexpr span(Container& container) noexcept
-      : span(base::data(container), base::size(container)) {}
-
-  template <
-      typename Container,
-      typename = internal::EnableIfSpanCompatibleContainer<const Container&, T>>
-  span(const Container& container) noexcept
-      : span(base::data(container), base::size(container)) {}
-
-  constexpr span(const span& other) noexcept = default;
-
-  // Conversions from spans of compatible types and extents: this allows a
-  // span<T> to be seamlessly used as a span<const T>, but not the other way
-  // around. If extent is not dynamic, OtherExtent has to be equal to Extent.
-  template <
-      typename U,
-      size_t OtherExtent,
-      typename =
-          internal::EnableIfLegalSpanConversion<U, OtherExtent, T, Extent>>
-  constexpr span(const span<U, OtherExtent>& other)
-      : span(other.data(), other.size()) {}
-
-  constexpr span& operator=(const span& other) noexcept = default;
-  ~span() noexcept = default;
-
-  // [span.sub], span subviews
-  template <size_t Count>
-  constexpr span<T, Count> first() const noexcept {
-    static_assert(Extent == dynamic_extent || Count <= Extent,
-                  "Count must not exceed Extent");
-    CHECK(Extent != dynamic_extent || Count <= size());
-    return {data(), Count};
-  }
-
-  template <size_t Count>
-  constexpr span<T, Count> last() const noexcept {
-    static_assert(Extent == dynamic_extent || Count <= Extent,
-                  "Count must not exceed Extent");
-    CHECK(Extent != dynamic_extent || Count <= size());
-    return {data() + (size() - Count), Count};
-  }
-
-  template <size_t Offset, size_t Count = dynamic_extent>
-  constexpr span<T,
-                 (Count != dynamic_extent
-                     ? Count
-                     : (Extent != dynamic_extent ? Extent - Offset
-                                                 : dynamic_extent))>
-  subspan() const noexcept {
-    static_assert(Extent == dynamic_extent || Offset <= Extent,
-                  "Offset must not exceed Extent");
-    static_assert(Extent == dynamic_extent || Count == dynamic_extent ||
-                      Count <= Extent - Offset,
-                  "Count must not exceed Extent - Offset");
-    CHECK(Extent != dynamic_extent || Offset <= size());
-    CHECK(Extent != dynamic_extent || Count == dynamic_extent ||
-          Count <= size() - Offset);
-    return {data() + Offset, Count != dynamic_extent ? Count : size() - Offset};
-  }
-
-  constexpr span<T, dynamic_extent> first(size_t count) const noexcept {
-    // Note: CHECK_LE is not constexpr, hence regular CHECK must be used.
-    CHECK(count <= size());
-    return {data(), count};
-  }
-
-  constexpr span<T, dynamic_extent> last(size_t count) const noexcept {
-    // Note: CHECK_LE is not constexpr, hence regular CHECK must be used.
-    CHECK(count <= size());
-    return {data() + (size() - count), count};
-  }
-
-  constexpr span<T, dynamic_extent> subspan(size_t offset,
-                                            size_t count = dynamic_extent) const
-      noexcept {
-    // Note: CHECK_LE is not constexpr, hence regular CHECK must be used.
-    CHECK(offset <= size());
-    CHECK(count == dynamic_extent || count <= size() - offset);
-    return {data() + offset, count != dynamic_extent ? count : size() - offset};
-  }
-
-  // [span.obs], span observers
-  constexpr size_t size() const noexcept { return size_; }
-  constexpr size_t size_bytes() const noexcept { return size() * sizeof(T); }
-  constexpr bool empty() const noexcept { return size() == 0; }
-
-  // [span.elem], span element access
-  constexpr T& operator[](size_t idx) const noexcept {
-    // Note: CHECK_LT is not constexpr, hence regular CHECK must be used.
-    CHECK(idx < size());
-    return *(data() + idx);
-  }
-
-  constexpr T& operator()(size_t idx) const noexcept {
-    // Note: CHECK_LT is not constexpr, hence regular CHECK must be used.
-    CHECK(idx < size());
-    return *(data() + idx);
-  }
-
-  constexpr T* data() const noexcept { return data_; }
-
-  // [span.iter], span iterator support
-  constexpr iterator begin() const noexcept { return data(); }
-  constexpr iterator end() const noexcept { return data() + size(); }
-
-  constexpr const_iterator cbegin() const noexcept { return begin(); }
-  constexpr const_iterator cend() const noexcept { return end(); }
-
-  constexpr reverse_iterator rbegin() const noexcept {
-    return reverse_iterator(end());
-  }
-  constexpr reverse_iterator rend() const noexcept {
-    return reverse_iterator(begin());
-  }
-
-  constexpr const_reverse_iterator crbegin() const noexcept {
-    return const_reverse_iterator(cend());
-  }
-  constexpr const_reverse_iterator crend() const noexcept {
-    return const_reverse_iterator(cbegin());
-  }
-
- private:
-  T* data_;
-  size_t size_;
-};
-
-// span<T, Extent>::extent can not be declared inline prior to C++17, hence this
-// definition is required.
-template <class T, size_t Extent>
-constexpr size_t span<T, Extent>::extent;
-
-// [span.comparison], span comparison operators
-// Relational operators. Equality is a element-wise comparison.
-template <typename T, size_t X, typename U, size_t Y>
-constexpr bool operator==(span<T, X> lhs, span<U, Y> rhs) noexcept {
-  return std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin(), rhs.cend());
-}
-
-template <typename T, size_t X, typename U, size_t Y>
-constexpr bool operator!=(span<T, X> lhs, span<U, Y> rhs) noexcept {
-  return !(lhs == rhs);
-}
-
-template <typename T, size_t X, typename U, size_t Y>
-constexpr bool operator<(span<T, X> lhs, span<U, Y> rhs) noexcept {
-  return std::lexicographical_compare(lhs.cbegin(), lhs.cend(), rhs.cbegin(),
-                                      rhs.cend());
-}
-
-template <typename T, size_t X, typename U, size_t Y>
-constexpr bool operator<=(span<T, X> lhs, span<U, Y> rhs) noexcept {
-  return !(rhs < lhs);
-}
-
-template <typename T, size_t X, typename U, size_t Y>
-constexpr bool operator>(span<T, X> lhs, span<U, Y> rhs) noexcept {
-  return rhs < lhs;
-}
-
-template <typename T, size_t X, typename U, size_t Y>
-constexpr bool operator>=(span<T, X> lhs, span<U, Y> rhs) noexcept {
-  return !(lhs < rhs);
-}
-
-// [span.objectrep], views of object representation
-template <typename T, size_t X>
-span<const uint8_t, (X == dynamic_extent ? dynamic_extent : sizeof(T) * X)>
-as_bytes(span<T, X> s) noexcept {
-  return {reinterpret_cast<const uint8_t*>(s.data()), s.size_bytes()};
-}
-
-template <typename T,
-          size_t X,
-          typename = std::enable_if_t<!std::is_const<T>::value>>
-span<uint8_t, (X == dynamic_extent ? dynamic_extent : sizeof(T) * X)>
-as_writable_bytes(span<T, X> s) noexcept {
-  return {reinterpret_cast<uint8_t*>(s.data()), s.size_bytes()};
-}
-
-// Type-deducing helpers for constructing a span.
-template <typename T>
-constexpr span<T> make_span(T* data, size_t size) noexcept {
-  return {data, size};
-}
-
-template <typename T>
-constexpr span<T> make_span(T* begin, T* end) noexcept {
-  return {begin, end};
-}
-
-template <typename T, size_t N>
-constexpr span<T, N> make_span(T (&array)[N]) noexcept {
-  return array;
-}
-
-template <typename T, size_t N>
-constexpr span<T, N> make_span(std::array<T, N>& array) noexcept {
-  return array;
-}
-
-template <typename T, size_t N>
-constexpr span<const T, N> make_span(const std::array<T, N>& array) noexcept {
-  return array;
-}
-
-template <typename Container,
-          typename T = typename Container::value_type,
-          typename = internal::EnableIfSpanCompatibleContainer<Container&, T>>
-constexpr span<T> make_span(Container& container) noexcept {
-  return container;
-}
-
-template <
-    typename Container,
-    typename T = const typename Container::value_type,
-    typename = internal::EnableIfSpanCompatibleContainer<const Container&, T>>
-constexpr span<T> make_span(const Container& container) noexcept {
-  return container;
-}
-
-template <typename T, size_t X>
-constexpr span<T, X> make_span(const span<T, X>& span) noexcept {
-  return span;
-}
-
-}  // namespace base
-
-#endif  // BASE_CONTAINERS_SPAN_H_
diff --git a/native/zucchini/vendor/libchrome/base/containers/stack.h b/native/zucchini/vendor/libchrome/base/containers/stack.h
deleted file mode 100644
index 5cf06f8..0000000
--- a/native/zucchini/vendor/libchrome/base/containers/stack.h
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CONTAINERS_STACK_H_
-#define BASE_CONTAINERS_STACK_H_
-
-#include <stack>
-
-#include "base/containers/circular_deque.h"
-
-namespace base {
-
-// Provides a definition of base::stack that's like std::stack but uses a
-// base::circular_deque instead of std::deque. Since std::stack is just a
-// wrapper for an underlying type, we can just provide a typedef for it that
-// defaults to the base circular_deque.
-template <class T, class Container = circular_deque<T>>
-using stack = std::stack<T, Container>;
-
-}  // namespace base
-
-#endif  // BASE_CONTAINERS_STACK_H_
diff --git a/native/zucchini/vendor/libchrome/base/containers/vector_buffer.h b/native/zucchini/vendor/libchrome/base/containers/vector_buffer.h
deleted file mode 100644
index a72c1ed..0000000
--- a/native/zucchini/vendor/libchrome/base/containers/vector_buffer.h
+++ /dev/null
@@ -1,163 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_CONTAINERS_VECTOR_BUFFERS_H_
-#define BASE_CONTAINERS_VECTOR_BUFFERS_H_
-
-#include <stdlib.h>
-#include <string.h>
-
-#include <type_traits>
-#include <utility>
-
-#include "base/logging.h"
-#include "base/macros.h"
-
-namespace base {
-namespace internal {
-
-// Internal implementation detail of base/containers.
-//
-// Implements a vector-like buffer that holds a certain capacity of T. Unlike
-// std::vector, VectorBuffer never constructs or destructs its arguments, and
-// can't change sizes. But it does implement templates to assist in efficient
-// moving and destruction of those items manually.
-//
-// In particular, the destructor function does not iterate over the items if
-// there is no destructor. Moves should be implemented as a memcpy/memmove for
-// trivially copyable objects (POD) otherwise, it should be a std::move if
-// possible, and as a last resort it falls back to a copy. This behavior is
-// similar to std::vector.
-//
-// No special consideration is done for noexcept move constructors since
-// we compile without exceptions.
-//
-// The current API does not support moving overlapping ranges.
-template <typename T>
-class VectorBuffer {
- public:
-  constexpr VectorBuffer() = default;
-
-#if defined(__clang__) && !defined(__native_client__)
-  // This constructor converts an uninitialized void* to a T* which triggers
-  // clang Control Flow Integrity. Since this is as-designed, disable.
-  __attribute__((no_sanitize("cfi-unrelated-cast", "vptr")))
-#endif
-  VectorBuffer(size_t count)
-      : buffer_(reinterpret_cast<T*>(malloc(sizeof(T) * count))),
-        capacity_(count) {
-  }
-  VectorBuffer(VectorBuffer&& other) noexcept
-      : buffer_(other.buffer_), capacity_(other.capacity_) {
-    other.buffer_ = nullptr;
-    other.capacity_ = 0;
-  }
-
-  ~VectorBuffer() { free(buffer_); }
-
-  VectorBuffer& operator=(VectorBuffer&& other) {
-    free(buffer_);
-    buffer_ = other.buffer_;
-    capacity_ = other.capacity_;
-
-    other.buffer_ = nullptr;
-    other.capacity_ = 0;
-    return *this;
-  }
-
-  size_t capacity() const { return capacity_; }
-
-  T& operator[](size_t i) { return buffer_[i]; }
-  const T& operator[](size_t i) const { return buffer_[i]; }
-  T* begin() { return buffer_; }
-  T* end() { return &buffer_[capacity_]; }
-
-  // DestructRange ------------------------------------------------------------
-
-  // Trivially destructible objects need not have their destructors called.
-  template <typename T2 = T,
-            typename std::enable_if<std::is_trivially_destructible<T2>::value,
-                                    int>::type = 0>
-  void DestructRange(T* begin, T* end) {}
-
-  // Non-trivially destructible objects must have their destructors called
-  // individually.
-  template <typename T2 = T,
-            typename std::enable_if<!std::is_trivially_destructible<T2>::value,
-                                    int>::type = 0>
-  void DestructRange(T* begin, T* end) {
-    while (begin != end) {
-      begin->~T();
-      begin++;
-    }
-  }
-
-  // MoveRange ----------------------------------------------------------------
-  //
-  // The destructor will be called (as necessary) for all moved types. The
-  // ranges must not overlap.
-  //
-  // The parameters and begin and end (one past the last) of the input buffer,
-  // and the address of the first element to copy to. There must be sufficient
-  // room in the destination for all items in the range [begin, end).
-
-  // Trivially copyable types can use memcpy. trivially copyable implies
-  // that there is a trivial destructor as we don't have to call it.
-  template <typename T2 = T,
-            typename std::enable_if<base::is_trivially_copyable<T2>::value,
-                                    int>::type = 0>
-  static void MoveRange(T* from_begin, T* from_end, T* to) {
-    DCHECK(!RangesOverlap(from_begin, from_end, to));
-    memcpy(to, from_begin, (from_end - from_begin) * sizeof(T));
-  }
-
-  // Not trivially copyable, but movable: call the move constructor and
-  // destruct the original.
-  template <typename T2 = T,
-            typename std::enable_if<std::is_move_constructible<T2>::value &&
-                                        !base::is_trivially_copyable<T2>::value,
-                                    int>::type = 0>
-  static void MoveRange(T* from_begin, T* from_end, T* to) {
-    DCHECK(!RangesOverlap(from_begin, from_end, to));
-    while (from_begin != from_end) {
-      new (to) T(std::move(*from_begin));
-      from_begin->~T();
-      from_begin++;
-      to++;
-    }
-  }
-
-  // Not movable, not trivially copyable: call the copy constructor and
-  // destruct the original.
-  template <typename T2 = T,
-            typename std::enable_if<!std::is_move_constructible<T2>::value &&
-                                        !base::is_trivially_copyable<T2>::value,
-                                    int>::type = 0>
-  static void MoveRange(T* from_begin, T* from_end, T* to) {
-    DCHECK(!RangesOverlap(from_begin, from_end, to));
-    while (from_begin != from_end) {
-      new (to) T(*from_begin);
-      from_begin->~T();
-      from_begin++;
-      to++;
-    }
-  }
-
- private:
-  static bool RangesOverlap(const T* from_begin,
-                            const T* from_end,
-                            const T* to) {
-    return !(to >= from_end || to + (from_end - from_begin) <= from_begin);
-  }
-
-  T* buffer_ = nullptr;
-  size_t capacity_ = 0;
-
-  DISALLOW_COPY_AND_ASSIGN(VectorBuffer);
-};
-
-}  // namespace internal
-}  // namespace base
-
-#endif  // BASE_CONTAINERS_VECTOR_BUFFERS_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/activity_tracker.cc b/native/zucchini/vendor/libchrome/base/debug/activity_tracker.cc
deleted file mode 100644
index 24cfa5a..0000000
--- a/native/zucchini/vendor/libchrome/base/debug/activity_tracker.cc
+++ /dev/null
@@ -1,1828 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/debug/activity_tracker.h"
-
-#include <algorithm>
-#include <limits>
-#include <utility>
-
-#include "base/atomic_sequence_num.h"
-#include "base/debug/stack_trace.h"
-#include "base/files/file.h"
-#include "base/files/file_path.h"
-#include "base/files/memory_mapped_file.h"
-#include "base/logging.h"
-#include "base/memory/ptr_util.h"
-#include "base/metrics/field_trial.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/pending_task.h"
-#include "base/pickle.h"
-#include "base/process/process.h"
-#include "base/process/process_handle.h"
-#include "base/stl_util.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/threading/platform_thread.h"
-#include "build/build_config.h"
-
-namespace base {
-namespace debug {
-
-namespace {
-
-// The minimum depth a stack should support.
-const int kMinStackDepth = 2;
-
-// The amount of memory set aside for holding arbitrary user data (key/value
-// pairs) globally or associated with ActivityData entries.
-const size_t kUserDataSize = 1 << 10;     // 1 KiB
-const size_t kProcessDataSize = 4 << 10;  // 4 KiB
-const size_t kMaxUserDataNameLength =
-    static_cast<size_t>(std::numeric_limits<uint8_t>::max());
-
-// A constant used to indicate that module information is changing.
-const uint32_t kModuleInformationChanging = 0x80000000;
-
-// The key used to record process information.
-const char kProcessPhaseDataKey[] = "process-phase";
-
-// An atomically incrementing number, used to check for recreations of objects
-// in the same memory space.
-AtomicSequenceNumber g_next_id;
-
-// Gets the next non-zero identifier. It is only unique within a process.
-uint32_t GetNextDataId() {
-  uint32_t id;
-  while ((id = g_next_id.GetNext()) == 0)
-    ;
-  return id;
-}
-
-// Gets the current process-id, either from the GlobalActivityTracker if it
-// exists (where the PID can be defined for testing) or from the system if
-// there isn't such.
-int64_t GetProcessId() {
-  GlobalActivityTracker* global = GlobalActivityTracker::Get();
-  if (global)
-    return global->process_id();
-  return GetCurrentProcId();
-}
-
-// Finds and reuses a specific allocation or creates a new one.
-PersistentMemoryAllocator::Reference AllocateFrom(
-    PersistentMemoryAllocator* allocator,
-    uint32_t from_type,
-    size_t size,
-    uint32_t to_type) {
-  PersistentMemoryAllocator::Iterator iter(allocator);
-  PersistentMemoryAllocator::Reference ref;
-  while ((ref = iter.GetNextOfType(from_type)) != 0) {
-    DCHECK_LE(size, allocator->GetAllocSize(ref));
-    // This can fail if a another thread has just taken it. It is assumed that
-    // the memory is cleared during the "free" operation.
-    if (allocator->ChangeType(ref, to_type, from_type, /*clear=*/false))
-      return ref;
-  }
-
-  return allocator->Allocate(size, to_type);
-}
-
-// Determines the previous aligned index.
-size_t RoundDownToAlignment(size_t index, size_t alignment) {
-  return index & (0 - alignment);
-}
-
-// Determines the next aligned index.
-size_t RoundUpToAlignment(size_t index, size_t alignment) {
-  return (index + (alignment - 1)) & (0 - alignment);
-}
-
-// Converts "tick" timing into wall time.
-Time WallTimeFromTickTime(int64_t ticks_start, int64_t ticks, Time time_start) {
-  return time_start + TimeDelta::FromInternalValue(ticks - ticks_start);
-}
-
-}  // namespace
-
-union ThreadRef {
-  int64_t as_id;
-#if defined(OS_WIN)
-  // On Windows, the handle itself is often a pseudo-handle with a common
-  // value meaning "this thread" and so the thread-id is used. The former
-  // can be converted to a thread-id with a system call.
-  PlatformThreadId as_tid;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  // On Posix and Fuchsia, the handle is always a unique identifier so no
-  // conversion needs to be done. However, its value is officially opaque so
-  // there is no one correct way to convert it to a numerical identifier.
-  PlatformThreadHandle::Handle as_handle;
-#endif
-};
-
-OwningProcess::OwningProcess() = default;
-OwningProcess::~OwningProcess() = default;
-
-void OwningProcess::Release_Initialize(int64_t pid) {
-  uint32_t old_id = data_id.load(std::memory_order_acquire);
-  DCHECK_EQ(0U, old_id);
-  process_id = pid != 0 ? pid : GetProcessId();
-  create_stamp = Time::Now().ToInternalValue();
-  data_id.store(GetNextDataId(), std::memory_order_release);
-}
-
-void OwningProcess::SetOwningProcessIdForTesting(int64_t pid, int64_t stamp) {
-  DCHECK_NE(0U, data_id);
-  process_id = pid;
-  create_stamp = stamp;
-}
-
-// static
-bool OwningProcess::GetOwningProcessId(const void* memory,
-                                       int64_t* out_id,
-                                       int64_t* out_stamp) {
-  const OwningProcess* info = reinterpret_cast<const OwningProcess*>(memory);
-  uint32_t id = info->data_id.load(std::memory_order_acquire);
-  if (id == 0)
-    return false;
-
-  *out_id = info->process_id;
-  *out_stamp = info->create_stamp;
-  return id == info->data_id.load(std::memory_order_seq_cst);
-}
-
-// It doesn't matter what is contained in this (though it will be all zeros)
-// as only the address of it is important.
-const ActivityData kNullActivityData = {};
-
-ActivityData ActivityData::ForThread(const PlatformThreadHandle& handle) {
-  ThreadRef thread_ref;
-  thread_ref.as_id = 0;  // Zero the union in case other is smaller.
-#if defined(OS_WIN)
-  thread_ref.as_tid = ::GetThreadId(handle.platform_handle());
-#elif defined(OS_POSIX)
-  thread_ref.as_handle = handle.platform_handle();
-#endif
-  return ForThread(thread_ref.as_id);
-}
-
-ActivityTrackerMemoryAllocator::ActivityTrackerMemoryAllocator(
-    PersistentMemoryAllocator* allocator,
-    uint32_t object_type,
-    uint32_t object_free_type,
-    size_t object_size,
-    size_t cache_size,
-    bool make_iterable)
-    : allocator_(allocator),
-      object_type_(object_type),
-      object_free_type_(object_free_type),
-      object_size_(object_size),
-      cache_size_(cache_size),
-      make_iterable_(make_iterable),
-      iterator_(allocator),
-      cache_values_(new Reference[cache_size]),
-      cache_used_(0) {
-  DCHECK(allocator);
-}
-
-ActivityTrackerMemoryAllocator::~ActivityTrackerMemoryAllocator() = default;
-
-ActivityTrackerMemoryAllocator::Reference
-ActivityTrackerMemoryAllocator::GetObjectReference() {
-  // First see if there is a cached value that can be returned. This is much
-  // faster than searching the memory system for free blocks.
-  while (cache_used_ > 0) {
-    Reference cached = cache_values_[--cache_used_];
-    // Change the type of the cached object to the proper type and return it.
-    // If the type-change fails that means another thread has taken this from
-    // under us (via the search below) so ignore it and keep trying. Don't
-    // clear the memory because that was done when the type was made "free".
-    if (allocator_->ChangeType(cached, object_type_, object_free_type_, false))
-      return cached;
-  }
-
-  // Fetch the next "free" object from persistent memory. Rather than restart
-  // the iterator at the head each time and likely waste time going again
-  // through objects that aren't relevant, the iterator continues from where
-  // it last left off and is only reset when the end is reached. If the
-  // returned reference matches |last|, then it has wrapped without finding
-  // anything.
-  const Reference last = iterator_.GetLast();
-  while (true) {
-    uint32_t type;
-    Reference found = iterator_.GetNext(&type);
-    if (found && type == object_free_type_) {
-      // Found a free object. Change it to the proper type and return it. If
-      // the type-change fails that means another thread has taken this from
-      // under us so ignore it and keep trying.
-      if (allocator_->ChangeType(found, object_type_, object_free_type_, false))
-        return found;
-    }
-    if (found == last) {
-      // Wrapped. No desired object was found.
-      break;
-    }
-    if (!found) {
-      // Reached end; start over at the beginning.
-      iterator_.Reset();
-    }
-  }
-
-  // No free block was found so instead allocate a new one.
-  Reference allocated = allocator_->Allocate(object_size_, object_type_);
-  if (allocated && make_iterable_)
-    allocator_->MakeIterable(allocated);
-  return allocated;
-}
-
-void ActivityTrackerMemoryAllocator::ReleaseObjectReference(Reference ref) {
-  // Mark object as free.
-  bool success = allocator_->ChangeType(ref, object_free_type_, object_type_,
-                                        /*clear=*/true);
-  DCHECK(success);
-
-  // Add this reference to our "free" cache if there is space. If not, the type
-  // has still been changed to indicate that it is free so this (or another)
-  // thread can find it, albeit more slowly, using the iteration method above.
-  if (cache_used_ < cache_size_)
-    cache_values_[cache_used_++] = ref;
-}
-
-// static
-void Activity::FillFrom(Activity* activity,
-                        const void* program_counter,
-                        const void* origin,
-                        Type type,
-                        const ActivityData& data) {
-  activity->time_internal = base::TimeTicks::Now().ToInternalValue();
-  activity->calling_address = reinterpret_cast<uintptr_t>(program_counter);
-  activity->origin_address = reinterpret_cast<uintptr_t>(origin);
-  activity->activity_type = type;
-  activity->data = data;
-
-#if (!defined(OS_NACL) && DCHECK_IS_ON()) || defined(ADDRESS_SANITIZER)
-  // Create a stacktrace from the current location and get the addresses for
-  // improved debuggability.
-  StackTrace stack_trace;
-  size_t stack_depth;
-  const void* const* stack_addrs = stack_trace.Addresses(&stack_depth);
-  // Copy the stack addresses, ignoring the first one (here).
-  size_t i;
-  for (i = 1; i < stack_depth && i < kActivityCallStackSize; ++i) {
-    activity->call_stack[i - 1] = reinterpret_cast<uintptr_t>(stack_addrs[i]);
-  }
-  activity->call_stack[i - 1] = 0;
-#else
-  activity->call_stack[0] = 0;
-#endif
-}
-
-ActivityUserData::TypedValue::TypedValue() = default;
-ActivityUserData::TypedValue::TypedValue(const TypedValue& other) = default;
-ActivityUserData::TypedValue::~TypedValue() = default;
-
-StringPiece ActivityUserData::TypedValue::Get() const {
-  DCHECK_EQ(RAW_VALUE, type_);
-  return long_value_;
-}
-
-StringPiece ActivityUserData::TypedValue::GetString() const {
-  DCHECK_EQ(STRING_VALUE, type_);
-  return long_value_;
-}
-
-bool ActivityUserData::TypedValue::GetBool() const {
-  DCHECK_EQ(BOOL_VALUE, type_);
-  return short_value_ != 0;
-}
-
-char ActivityUserData::TypedValue::GetChar() const {
-  DCHECK_EQ(CHAR_VALUE, type_);
-  return static_cast<char>(short_value_);
-}
-
-int64_t ActivityUserData::TypedValue::GetInt() const {
-  DCHECK_EQ(SIGNED_VALUE, type_);
-  return static_cast<int64_t>(short_value_);
-}
-
-uint64_t ActivityUserData::TypedValue::GetUint() const {
-  DCHECK_EQ(UNSIGNED_VALUE, type_);
-  return static_cast<uint64_t>(short_value_);
-}
-
-StringPiece ActivityUserData::TypedValue::GetReference() const {
-  DCHECK_EQ(RAW_VALUE_REFERENCE, type_);
-  return ref_value_;
-}
-
-StringPiece ActivityUserData::TypedValue::GetStringReference() const {
-  DCHECK_EQ(STRING_VALUE_REFERENCE, type_);
-  return ref_value_;
-}
-
-// These are required because std::atomic is (currently) not a POD type and
-// thus clang requires explicit out-of-line constructors and destructors even
-// when they do nothing.
-ActivityUserData::ValueInfo::ValueInfo() = default;
-ActivityUserData::ValueInfo::ValueInfo(ValueInfo&&) = default;
-ActivityUserData::ValueInfo::~ValueInfo() = default;
-ActivityUserData::MemoryHeader::MemoryHeader() = default;
-ActivityUserData::MemoryHeader::~MemoryHeader() = default;
-ActivityUserData::FieldHeader::FieldHeader() = default;
-ActivityUserData::FieldHeader::~FieldHeader() = default;
-
-ActivityUserData::ActivityUserData() : ActivityUserData(nullptr, 0, -1) {}
-
-ActivityUserData::ActivityUserData(void* memory, size_t size, int64_t pid)
-    : memory_(reinterpret_cast<char*>(memory)),
-      available_(RoundDownToAlignment(size, kMemoryAlignment)),
-      header_(reinterpret_cast<MemoryHeader*>(memory)),
-      orig_data_id(0),
-      orig_process_id(0),
-      orig_create_stamp(0) {
-  // It's possible that no user data is being stored.
-  if (!memory_)
-    return;
-
-  static_assert(0 == sizeof(MemoryHeader) % kMemoryAlignment, "invalid header");
-  DCHECK_LT(sizeof(MemoryHeader), available_);
-  if (header_->owner.data_id.load(std::memory_order_acquire) == 0)
-    header_->owner.Release_Initialize(pid);
-  memory_ += sizeof(MemoryHeader);
-  available_ -= sizeof(MemoryHeader);
-
-  // Make a copy of identifying information for later comparison.
-  *const_cast<uint32_t*>(&orig_data_id) =
-      header_->owner.data_id.load(std::memory_order_acquire);
-  *const_cast<int64_t*>(&orig_process_id) = header_->owner.process_id;
-  *const_cast<int64_t*>(&orig_create_stamp) = header_->owner.create_stamp;
-
-  // If there is already data present, load that. This allows the same class
-  // to be used for analysis through snapshots.
-  ImportExistingData();
-}
-
-ActivityUserData::~ActivityUserData() = default;
-
-bool ActivityUserData::CreateSnapshot(Snapshot* output_snapshot) const {
-  DCHECK(output_snapshot);
-  DCHECK(output_snapshot->empty());
-
-  // Find any new data that may have been added by an active instance of this
-  // class that is adding records.
-  ImportExistingData();
-
-  // Add all the values to the snapshot.
-  for (const auto& entry : values_) {
-    TypedValue value;
-    const size_t size = entry.second.size_ptr->load(std::memory_order_acquire);
-    value.type_ = entry.second.type;
-    DCHECK_GE(entry.second.extent, size);
-
-    switch (entry.second.type) {
-      case RAW_VALUE:
-      case STRING_VALUE:
-        value.long_value_ =
-            std::string(reinterpret_cast<char*>(entry.second.memory), size);
-        break;
-      case RAW_VALUE_REFERENCE:
-      case STRING_VALUE_REFERENCE: {
-        ReferenceRecord* ref =
-            reinterpret_cast<ReferenceRecord*>(entry.second.memory);
-        value.ref_value_ = StringPiece(
-            reinterpret_cast<char*>(static_cast<uintptr_t>(ref->address)),
-            static_cast<size_t>(ref->size));
-      } break;
-      case BOOL_VALUE:
-      case CHAR_VALUE:
-        value.short_value_ = *reinterpret_cast<char*>(entry.second.memory);
-        break;
-      case SIGNED_VALUE:
-      case UNSIGNED_VALUE:
-        value.short_value_ = *reinterpret_cast<uint64_t*>(entry.second.memory);
-        break;
-      case END_OF_VALUES:  // Included for completeness purposes.
-        NOTREACHED();
-    }
-    auto inserted = output_snapshot->insert(
-        std::make_pair(entry.second.name.as_string(), std::move(value)));
-    DCHECK(inserted.second);  // True if inserted, false if existed.
-  }
-
-  // Another import attempt will validate that the underlying memory has not
-  // been reused for another purpose. Entries added since the first import
-  // will be ignored here but will be returned if another snapshot is created.
-  ImportExistingData();
-  if (!memory_) {
-    output_snapshot->clear();
-    return false;
-  }
-
-  // Successful snapshot.
-  return true;
-}
-
-const void* ActivityUserData::GetBaseAddress() const {
-  // The |memory_| pointer advances as elements are written but the |header_|
-  // value is always at the start of the block so just return that.
-  return header_;
-}
-
-void ActivityUserData::SetOwningProcessIdForTesting(int64_t pid,
-                                                    int64_t stamp) {
-  if (!header_)
-    return;
-  header_->owner.SetOwningProcessIdForTesting(pid, stamp);
-}
-
-// static
-bool ActivityUserData::GetOwningProcessId(const void* memory,
-                                          int64_t* out_id,
-                                          int64_t* out_stamp) {
-  const MemoryHeader* header = reinterpret_cast<const MemoryHeader*>(memory);
-  return OwningProcess::GetOwningProcessId(&header->owner, out_id, out_stamp);
-}
-
-void ActivityUserData::Set(StringPiece name,
-                           ValueType type,
-                           const void* memory,
-                           size_t size) {
-  DCHECK_GE(std::numeric_limits<uint8_t>::max(), name.length());
-  size = std::min(std::numeric_limits<uint16_t>::max() - (kMemoryAlignment - 1),
-                  size);
-
-  // It's possible that no user data is being stored.
-  if (!memory_)
-    return;
-
-  // The storage of a name is limited so use that limit during lookup.
-  if (name.length() > kMaxUserDataNameLength)
-    name.set(name.data(), kMaxUserDataNameLength);
-
-  ValueInfo* info;
-  auto existing = values_.find(name);
-  if (existing != values_.end()) {
-    info = &existing->second;
-  } else {
-    // The name size is limited to what can be held in a single byte but
-    // because there are not alignment constraints on strings, it's set tight
-    // against the header. Its extent (the reserved space, even if it's not
-    // all used) is calculated so that, when pressed against the header, the
-    // following field will be aligned properly.
-    size_t name_size = name.length();
-    size_t name_extent =
-        RoundUpToAlignment(sizeof(FieldHeader) + name_size, kMemoryAlignment) -
-        sizeof(FieldHeader);
-    size_t value_extent = RoundUpToAlignment(size, kMemoryAlignment);
-
-    // The "base size" is the size of the header and (padded) string key. Stop
-    // now if there's not room enough for even this.
-    size_t base_size = sizeof(FieldHeader) + name_extent;
-    if (base_size > available_)
-      return;
-
-    // The "full size" is the size for storing the entire value.
-    size_t full_size = std::min(base_size + value_extent, available_);
-
-    // If the value is actually a single byte, see if it can be stuffed at the
-    // end of the name extent rather than wasting kMemoryAlignment bytes.
-    if (size == 1 && name_extent > name_size) {
-      full_size = base_size;
-      --name_extent;
-      --base_size;
-    }
-
-    // Truncate the stored size to the amount of available memory. Stop now if
-    // there's not any room for even part of the value.
-    if (size != 0) {
-      size = std::min(full_size - base_size, size);
-      if (size == 0)
-        return;
-    }
-
-    // Allocate a chunk of memory.
-    FieldHeader* header = reinterpret_cast<FieldHeader*>(memory_);
-    memory_ += full_size;
-    available_ -= full_size;
-
-    // Datafill the header and name records. Memory must be zeroed. The |type|
-    // is written last, atomically, to release all the other values.
-    DCHECK_EQ(END_OF_VALUES, header->type.load(std::memory_order_relaxed));
-    DCHECK_EQ(0, header->value_size.load(std::memory_order_relaxed));
-    header->name_size = static_cast<uint8_t>(name_size);
-    header->record_size = full_size;
-    char* name_memory = reinterpret_cast<char*>(header) + sizeof(FieldHeader);
-    void* value_memory =
-        reinterpret_cast<char*>(header) + sizeof(FieldHeader) + name_extent;
-    memcpy(name_memory, name.data(), name_size);
-    header->type.store(type, std::memory_order_release);
-
-    // Create an entry in |values_| so that this field can be found and changed
-    // later on without having to allocate new entries.
-    StringPiece persistent_name(name_memory, name_size);
-    auto inserted =
-        values_.insert(std::make_pair(persistent_name, ValueInfo()));
-    DCHECK(inserted.second);  // True if inserted, false if existed.
-    info = &inserted.first->second;
-    info->name = persistent_name;
-    info->memory = value_memory;
-    info->size_ptr = &header->value_size;
-    info->extent = full_size - sizeof(FieldHeader) - name_extent;
-    info->type = type;
-  }
-
-  // Copy the value data to storage. The |size| is written last, atomically, to
-  // release the copied data. Until then, a parallel reader will just ignore
-  // records with a zero size.
-  DCHECK_EQ(type, info->type);
-  size = std::min(size, info->extent);
-  info->size_ptr->store(0, std::memory_order_seq_cst);
-  memcpy(info->memory, memory, size);
-  info->size_ptr->store(size, std::memory_order_release);
-}
-
-void ActivityUserData::SetReference(StringPiece name,
-                                    ValueType type,
-                                    const void* memory,
-                                    size_t size) {
-  ReferenceRecord rec;
-  rec.address = reinterpret_cast<uintptr_t>(memory);
-  rec.size = size;
-  Set(name, type, &rec, sizeof(rec));
-}
-
-void ActivityUserData::ImportExistingData() const {
-  // It's possible that no user data is being stored.
-  if (!memory_)
-    return;
-
-  while (available_ > sizeof(FieldHeader)) {
-    FieldHeader* header = reinterpret_cast<FieldHeader*>(memory_);
-    ValueType type =
-        static_cast<ValueType>(header->type.load(std::memory_order_acquire));
-    if (type == END_OF_VALUES)
-      return;
-    if (header->record_size > available_)
-      return;
-
-    size_t value_offset = RoundUpToAlignment(
-        sizeof(FieldHeader) + header->name_size, kMemoryAlignment);
-    if (header->record_size == value_offset &&
-        header->value_size.load(std::memory_order_relaxed) == 1) {
-      value_offset -= 1;
-    }
-    if (value_offset + header->value_size > header->record_size)
-      return;
-
-    ValueInfo info;
-    info.name = StringPiece(memory_ + sizeof(FieldHeader), header->name_size);
-    info.type = type;
-    info.memory = memory_ + value_offset;
-    info.size_ptr = &header->value_size;
-    info.extent = header->record_size - value_offset;
-
-    StringPiece key(info.name);
-    values_.insert(std::make_pair(key, std::move(info)));
-
-    memory_ += header->record_size;
-    available_ -= header->record_size;
-  }
-
-  // Check if memory has been completely reused.
-  if (header_->owner.data_id.load(std::memory_order_acquire) != orig_data_id ||
-      header_->owner.process_id != orig_process_id ||
-      header_->owner.create_stamp != orig_create_stamp) {
-    memory_ = nullptr;
-    values_.clear();
-  }
-}
-
-// This information is kept for every thread that is tracked. It is filled
-// the very first time the thread is seen. All fields must be of exact sizes
-// so there is no issue moving between 32 and 64-bit builds.
-struct ThreadActivityTracker::Header {
-  // Defined in .h for analyzer access. Increment this if structure changes!
-  static constexpr uint32_t kPersistentTypeId =
-      GlobalActivityTracker::kTypeIdActivityTracker;
-
-  // Expected size for 32/64-bit check.
-  static constexpr size_t kExpectedInstanceSize =
-      OwningProcess::kExpectedInstanceSize + Activity::kExpectedInstanceSize +
-      72;
-
-  // This information uniquely identifies a process.
-  OwningProcess owner;
-
-  // The thread-id (thread_ref.as_id) to which this data belongs. This number
-  // is not guaranteed to mean anything but combined with the process-id from
-  // OwningProcess is unique among all active trackers.
-  ThreadRef thread_ref;
-
-  // The start-time and start-ticks when the data was created. Each activity
-  // record has a |time_internal| value that can be converted to a "wall time"
-  // with these two values.
-  int64_t start_time;
-  int64_t start_ticks;
-
-  // The number of Activity slots (spaces that can hold an Activity) that
-  // immediately follow this structure in memory.
-  uint32_t stack_slots;
-
-  // Some padding to keep everything 64-bit aligned.
-  uint32_t padding;
-
-  // The current depth of the stack. This may be greater than the number of
-  // slots. If the depth exceeds the number of slots, the newest entries
-  // won't be recorded.
-  std::atomic<uint32_t> current_depth;
-
-  // A memory location used to indicate if changes have been made to the data
-  // that would invalidate an in-progress read of its contents. The active
-  // tracker will increment the value whenever something gets popped from the
-  // stack. A monitoring tracker can check the value before and after access
-  // to know, if it's still the same, that the contents didn't change while
-  // being copied.
-  std::atomic<uint32_t> data_version;
-
-  // The last "exception" activity. This can't be stored on the stack because
-  // that could get popped as things unwind.
-  Activity last_exception;
-
-  // The name of the thread (up to a maximum length). Dynamic-length names
-  // are not practical since the memory has to come from the same persistent
-  // allocator that holds this structure and to which this object has no
-  // reference.
-  char thread_name[32];
-};
-
-ThreadActivityTracker::Snapshot::Snapshot() = default;
-ThreadActivityTracker::Snapshot::~Snapshot() = default;
-
-ThreadActivityTracker::ScopedActivity::ScopedActivity(
-    ThreadActivityTracker* tracker,
-    const void* program_counter,
-    const void* origin,
-    Activity::Type type,
-    const ActivityData& data)
-    : tracker_(tracker) {
-  if (tracker_)
-    activity_id_ = tracker_->PushActivity(program_counter, origin, type, data);
-}
-
-ThreadActivityTracker::ScopedActivity::~ScopedActivity() {
-  if (tracker_)
-    tracker_->PopActivity(activity_id_);
-}
-
-void ThreadActivityTracker::ScopedActivity::ChangeTypeAndData(
-    Activity::Type type,
-    const ActivityData& data) {
-  if (tracker_)
-    tracker_->ChangeActivity(activity_id_, type, data);
-}
-
-ThreadActivityTracker::ThreadActivityTracker(void* base, size_t size)
-    : header_(static_cast<Header*>(base)),
-      stack_(reinterpret_cast<Activity*>(reinterpret_cast<char*>(base) +
-                                         sizeof(Header))),
-#if DCHECK_IS_ON()
-      thread_id_(PlatformThreadRef()),
-#endif
-      stack_slots_(
-          static_cast<uint32_t>((size - sizeof(Header)) / sizeof(Activity))) {
-
-  // Verify the parameters but fail gracefully if they're not valid so that
-  // production code based on external inputs will not crash.  IsValid() will
-  // return false in this case.
-  if (!base ||
-      // Ensure there is enough space for the header and at least a few records.
-      size < sizeof(Header) + kMinStackDepth * sizeof(Activity) ||
-      // Ensure that the |stack_slots_| calculation didn't overflow.
-      (size - sizeof(Header)) / sizeof(Activity) >
-          std::numeric_limits<uint32_t>::max()) {
-    NOTREACHED();
-    return;
-  }
-
-  // Ensure that the thread reference doesn't exceed the size of the ID number.
-  // This won't compile at the global scope because Header is a private struct.
-  static_assert(
-      sizeof(header_->thread_ref) == sizeof(header_->thread_ref.as_id),
-      "PlatformThreadHandle::Handle is too big to hold in 64-bit ID");
-
-  // Ensure that the alignment of Activity.data is properly aligned to a
-  // 64-bit boundary so there are no interoperability-issues across cpu
-  // architectures.
-  static_assert(offsetof(Activity, data) % sizeof(uint64_t) == 0,
-                "ActivityData.data is not 64-bit aligned");
-
-  // Provided memory should either be completely initialized or all zeros.
-  if (header_->owner.data_id.load(std::memory_order_relaxed) == 0) {
-    // This is a new file. Double-check other fields and then initialize.
-    DCHECK_EQ(0, header_->owner.process_id);
-    DCHECK_EQ(0, header_->owner.create_stamp);
-    DCHECK_EQ(0, header_->thread_ref.as_id);
-    DCHECK_EQ(0, header_->start_time);
-    DCHECK_EQ(0, header_->start_ticks);
-    DCHECK_EQ(0U, header_->stack_slots);
-    DCHECK_EQ(0U, header_->current_depth.load(std::memory_order_relaxed));
-    DCHECK_EQ(0U, header_->data_version.load(std::memory_order_relaxed));
-    DCHECK_EQ(0, stack_[0].time_internal);
-    DCHECK_EQ(0U, stack_[0].origin_address);
-    DCHECK_EQ(0U, stack_[0].call_stack[0]);
-    DCHECK_EQ(0U, stack_[0].data.task.sequence_id);
-
-#if defined(OS_WIN)
-    header_->thread_ref.as_tid = PlatformThread::CurrentId();
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-    header_->thread_ref.as_handle =
-        PlatformThread::CurrentHandle().platform_handle();
-#endif
-
-    header_->start_time = base::Time::Now().ToInternalValue();
-    header_->start_ticks = base::TimeTicks::Now().ToInternalValue();
-    header_->stack_slots = stack_slots_;
-    strlcpy(header_->thread_name, PlatformThread::GetName(),
-            sizeof(header_->thread_name));
-
-    // This is done last so as to guarantee that everything above is "released"
-    // by the time this value gets written.
-    header_->owner.Release_Initialize();
-
-    valid_ = true;
-    DCHECK(IsValid());
-  } else {
-    // This is a file with existing data. Perform basic consistency checks.
-    valid_ = true;
-    valid_ = IsValid();
-  }
-}
-
-ThreadActivityTracker::~ThreadActivityTracker() = default;
-
-ThreadActivityTracker::ActivityId ThreadActivityTracker::PushActivity(
-    const void* program_counter,
-    const void* origin,
-    Activity::Type type,
-    const ActivityData& data) {
-  // A thread-checker creates a lock to check the thread-id which means
-  // re-entry into this code if lock acquisitions are being tracked.
-  DCHECK(type == Activity::ACT_LOCK_ACQUIRE || CalledOnValidThread());
-
-  // Get the current depth of the stack. No access to other memory guarded
-  // by this variable is done here so a "relaxed" load is acceptable.
-  uint32_t depth = header_->current_depth.load(std::memory_order_relaxed);
-
-  // Handle the case where the stack depth has exceeded the storage capacity.
-  // Extra entries will be lost leaving only the base of the stack.
-  if (depth >= stack_slots_) {
-    // Since no other threads modify the data, no compare/exchange is needed.
-    // Since no other memory is being modified, a "relaxed" store is acceptable.
-    header_->current_depth.store(depth + 1, std::memory_order_relaxed);
-    return depth;
-  }
-
-  // Get a pointer to the next activity and load it. No atomicity is required
-  // here because the memory is known only to this thread. It will be made
-  // known to other threads once the depth is incremented.
-  Activity::FillFrom(&stack_[depth], program_counter, origin, type, data);
-
-  // Save the incremented depth. Because this guards |activity| memory filled
-  // above that may be read by another thread once the recorded depth changes,
-  // a "release" store is required.
-  header_->current_depth.store(depth + 1, std::memory_order_release);
-
-  // The current depth is used as the activity ID because it simply identifies
-  // an entry. Once an entry is pop'd, it's okay to reuse the ID.
-  return depth;
-}
-
-void ThreadActivityTracker::ChangeActivity(ActivityId id,
-                                           Activity::Type type,
-                                           const ActivityData& data) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(type != Activity::ACT_NULL || &data != &kNullActivityData);
-  DCHECK_LT(id, header_->current_depth.load(std::memory_order_acquire));
-
-  // Update the information if it is being recorded (i.e. within slot limit).
-  if (id < stack_slots_) {
-    Activity* activity = &stack_[id];
-
-    if (type != Activity::ACT_NULL) {
-      DCHECK_EQ(activity->activity_type & Activity::ACT_CATEGORY_MASK,
-                type & Activity::ACT_CATEGORY_MASK);
-      activity->activity_type = type;
-    }
-
-    if (&data != &kNullActivityData)
-      activity->data = data;
-  }
-}
-
-void ThreadActivityTracker::PopActivity(ActivityId id) {
-  // Do an atomic decrement of the depth. No changes to stack entries guarded
-  // by this variable are done here so a "relaxed" operation is acceptable.
-  // |depth| will receive the value BEFORE it was modified which means the
-  // return value must also be decremented. The slot will be "free" after
-  // this call but since only a single thread can access this object, the
-  // data will remain valid until this method returns or calls outside.
-  uint32_t depth =
-      header_->current_depth.fetch_sub(1, std::memory_order_relaxed) - 1;
-
-  // Validate that everything is running correctly.
-  DCHECK_EQ(id, depth);
-
-  // A thread-checker creates a lock to check the thread-id which means
-  // re-entry into this code if lock acquisitions are being tracked.
-  DCHECK(stack_[depth].activity_type == Activity::ACT_LOCK_ACQUIRE ||
-         CalledOnValidThread());
-
-  // The stack has shrunk meaning that some other thread trying to copy the
-  // contents for reporting purposes could get bad data. Increment the data
-  // version so that it con tell that things have changed. This needs to
-  // happen after the atomic |depth| operation above so a "release" store
-  // is required.
-  header_->data_version.fetch_add(1, std::memory_order_release);
-}
-
-std::unique_ptr<ActivityUserData> ThreadActivityTracker::GetUserData(
-    ActivityId id,
-    ActivityTrackerMemoryAllocator* allocator) {
-  // Don't allow user data for lock acquisition as recursion may occur.
-  if (stack_[id].activity_type == Activity::ACT_LOCK_ACQUIRE) {
-    NOTREACHED();
-    return std::make_unique<ActivityUserData>();
-  }
-
-  // User-data is only stored for activities actually held in the stack.
-  if (id >= stack_slots_)
-    return std::make_unique<ActivityUserData>();
-
-  // Create and return a real UserData object.
-  return CreateUserDataForActivity(&stack_[id], allocator);
-}
-
-bool ThreadActivityTracker::HasUserData(ActivityId id) {
-  // User-data is only stored for activities actually held in the stack.
-  return (id < stack_slots_ && stack_[id].user_data_ref);
-}
-
-void ThreadActivityTracker::ReleaseUserData(
-    ActivityId id,
-    ActivityTrackerMemoryAllocator* allocator) {
-  // User-data is only stored for activities actually held in the stack.
-  if (id < stack_slots_ && stack_[id].user_data_ref) {
-    allocator->ReleaseObjectReference(stack_[id].user_data_ref);
-    stack_[id].user_data_ref = 0;
-  }
-}
-
-void ThreadActivityTracker::RecordExceptionActivity(const void* program_counter,
-                                                    const void* origin,
-                                                    Activity::Type type,
-                                                    const ActivityData& data) {
-  // A thread-checker creates a lock to check the thread-id which means
-  // re-entry into this code if lock acquisitions are being tracked.
-  DCHECK(CalledOnValidThread());
-
-  // Fill the reusable exception activity.
-  Activity::FillFrom(&header_->last_exception, program_counter, origin, type,
-                     data);
-
-  // The data has changed meaning that some other thread trying to copy the
-  // contents for reporting purposes could get bad data.
-  header_->data_version.fetch_add(1, std::memory_order_relaxed);
-}
-
-bool ThreadActivityTracker::IsValid() const {
-  if (header_->owner.data_id.load(std::memory_order_acquire) == 0 ||
-      header_->owner.process_id == 0 || header_->thread_ref.as_id == 0 ||
-      header_->start_time == 0 || header_->start_ticks == 0 ||
-      header_->stack_slots != stack_slots_ ||
-      header_->thread_name[sizeof(header_->thread_name) - 1] != '\0') {
-    return false;
-  }
-
-  return valid_;
-}
-
-bool ThreadActivityTracker::CreateSnapshot(Snapshot* output_snapshot) const {
-  DCHECK(output_snapshot);
-
-  // There is no "called on valid thread" check for this method as it can be
-  // called from other threads or even other processes. It is also the reason
-  // why atomic operations must be used in certain places above.
-
-  // It's possible for the data to change while reading it in such a way that it
-  // invalidates the read. Make several attempts but don't try forever.
-  const int kMaxAttempts = 10;
-  uint32_t depth;
-
-  // Stop here if the data isn't valid.
-  if (!IsValid())
-    return false;
-
-  // Allocate the maximum size for the stack so it doesn't have to be done
-  // during the time-sensitive snapshot operation. It is shrunk once the
-  // actual size is known.
-  output_snapshot->activity_stack.reserve(stack_slots_);
-
-  for (int attempt = 0; attempt < kMaxAttempts; ++attempt) {
-    // Remember the data IDs to ensure nothing is replaced during the snapshot
-    // operation. Use "acquire" so that all the non-atomic fields of the
-    // structure are valid (at least at the current moment in time).
-    const uint32_t starting_id =
-        header_->owner.data_id.load(std::memory_order_acquire);
-    const int64_t starting_create_stamp = header_->owner.create_stamp;
-    const int64_t starting_process_id = header_->owner.process_id;
-    const int64_t starting_thread_id = header_->thread_ref.as_id;
-
-    // Note the current |data_version| so it's possible to detect at the end
-    // that nothing has changed since copying the data began. A "cst" operation
-    // is required to ensure it occurs before everything else. Using "cst"
-    // memory ordering is relatively expensive but this is only done during
-    // analysis so doesn't directly affect the worker threads.
-    const uint32_t pre_version =
-        header_->data_version.load(std::memory_order_seq_cst);
-
-    // Fetching the current depth also "acquires" the contents of the stack.
-    depth = header_->current_depth.load(std::memory_order_acquire);
-    uint32_t count = std::min(depth, stack_slots_);
-    output_snapshot->activity_stack.resize(count);
-    if (count > 0) {
-      // Copy the existing contents. Memcpy is used for speed.
-      memcpy(&output_snapshot->activity_stack[0], stack_,
-             count * sizeof(Activity));
-    }
-
-    // Capture the last exception.
-    memcpy(&output_snapshot->last_exception, &header_->last_exception,
-           sizeof(Activity));
-
-    // TODO(bcwhite): Snapshot other things here.
-
-    // Retry if something changed during the copy. A "cst" operation ensures
-    // it must happen after all the above operations.
-    if (header_->data_version.load(std::memory_order_seq_cst) != pre_version)
-      continue;
-
-    // Stack copied. Record it's full depth.
-    output_snapshot->activity_stack_depth = depth;
-
-    // Get the general thread information.
-    output_snapshot->thread_name =
-        std::string(header_->thread_name, sizeof(header_->thread_name) - 1);
-    output_snapshot->create_stamp = header_->owner.create_stamp;
-    output_snapshot->thread_id = header_->thread_ref.as_id;
-    output_snapshot->process_id = header_->owner.process_id;
-
-    // All characters of the thread-name buffer were copied so as to not break
-    // if the trailing NUL were missing. Now limit the length if the actual
-    // name is shorter.
-    output_snapshot->thread_name.resize(
-        strlen(output_snapshot->thread_name.c_str()));
-
-    // If the data ID has changed then the tracker has exited and the memory
-    // reused by a new one. Try again.
-    if (header_->owner.data_id.load(std::memory_order_seq_cst) != starting_id ||
-        output_snapshot->create_stamp != starting_create_stamp ||
-        output_snapshot->process_id != starting_process_id ||
-        output_snapshot->thread_id != starting_thread_id) {
-      continue;
-    }
-
-    // Only successful if the data is still valid once everything is done since
-    // it's possible for the thread to end somewhere in the middle and all its
-    // values become garbage.
-    if (!IsValid())
-      return false;
-
-    // Change all the timestamps in the activities from "ticks" to "wall" time.
-    const Time start_time = Time::FromInternalValue(header_->start_time);
-    const int64_t start_ticks = header_->start_ticks;
-    for (Activity& activity : output_snapshot->activity_stack) {
-      activity.time_internal =
-          WallTimeFromTickTime(start_ticks, activity.time_internal, start_time)
-              .ToInternalValue();
-    }
-    output_snapshot->last_exception.time_internal =
-        WallTimeFromTickTime(start_ticks,
-                             output_snapshot->last_exception.time_internal,
-                             start_time)
-            .ToInternalValue();
-
-    // Success!
-    return true;
-  }
-
-  // Too many attempts.
-  return false;
-}
-
-const void* ThreadActivityTracker::GetBaseAddress() {
-  return header_;
-}
-
-uint32_t ThreadActivityTracker::GetDataVersionForTesting() {
-  return header_->data_version.load(std::memory_order_relaxed);
-}
-
-void ThreadActivityTracker::SetOwningProcessIdForTesting(int64_t pid,
-                                                         int64_t stamp) {
-  header_->owner.SetOwningProcessIdForTesting(pid, stamp);
-}
-
-// static
-bool ThreadActivityTracker::GetOwningProcessId(const void* memory,
-                                               int64_t* out_id,
-                                               int64_t* out_stamp) {
-  const Header* header = reinterpret_cast<const Header*>(memory);
-  return OwningProcess::GetOwningProcessId(&header->owner, out_id, out_stamp);
-}
-
-// static
-size_t ThreadActivityTracker::SizeForStackDepth(int stack_depth) {
-  return static_cast<size_t>(stack_depth) * sizeof(Activity) + sizeof(Header);
-}
-
-bool ThreadActivityTracker::CalledOnValidThread() {
-#if DCHECK_IS_ON()
-  return thread_id_ == PlatformThreadRef();
-#else
-  return true;
-#endif
-}
-
-std::unique_ptr<ActivityUserData>
-ThreadActivityTracker::CreateUserDataForActivity(
-    Activity* activity,
-    ActivityTrackerMemoryAllocator* allocator) {
-  DCHECK_EQ(0U, activity->user_data_ref);
-
-  PersistentMemoryAllocator::Reference ref = allocator->GetObjectReference();
-  void* memory = allocator->GetAsArray<char>(ref, kUserDataSize);
-  if (memory) {
-    std::unique_ptr<ActivityUserData> user_data =
-        std::make_unique<ActivityUserData>(memory, kUserDataSize);
-    activity->user_data_ref = ref;
-    activity->user_data_id = user_data->id();
-    return user_data;
-  }
-
-  // Return a dummy object that will still accept (but ignore) Set() calls.
-  return std::make_unique<ActivityUserData>();
-}
-
-// The instantiation of the GlobalActivityTracker object.
-// The object held here will obviously not be destructed at process exit
-// but that's best since PersistentMemoryAllocator objects (that underlie
-// GlobalActivityTracker objects) are explicitly forbidden from doing anything
-// essential at exit anyway due to the fact that they depend on data managed
-// elsewhere and which could be destructed first. An AtomicWord is used instead
-// of std::atomic because the latter can create global ctors and dtors.
-subtle::AtomicWord GlobalActivityTracker::g_tracker_ = 0;
-
-GlobalActivityTracker::ModuleInfo::ModuleInfo() = default;
-GlobalActivityTracker::ModuleInfo::ModuleInfo(ModuleInfo&& rhs) = default;
-GlobalActivityTracker::ModuleInfo::ModuleInfo(const ModuleInfo& rhs) = default;
-GlobalActivityTracker::ModuleInfo::~ModuleInfo() = default;
-
-GlobalActivityTracker::ModuleInfo& GlobalActivityTracker::ModuleInfo::operator=(
-    ModuleInfo&& rhs) = default;
-GlobalActivityTracker::ModuleInfo& GlobalActivityTracker::ModuleInfo::operator=(
-    const ModuleInfo& rhs) = default;
-
-GlobalActivityTracker::ModuleInfoRecord::ModuleInfoRecord() = default;
-GlobalActivityTracker::ModuleInfoRecord::~ModuleInfoRecord() = default;
-
-bool GlobalActivityTracker::ModuleInfoRecord::DecodeTo(
-    GlobalActivityTracker::ModuleInfo* info,
-    size_t record_size) const {
-  // Get the current "changes" indicator, acquiring all the other values.
-  uint32_t current_changes = changes.load(std::memory_order_acquire);
-
-  // Copy out the dynamic information.
-  info->is_loaded = loaded != 0;
-  info->address = static_cast<uintptr_t>(address);
-  info->load_time = load_time;
-
-  // Check to make sure no information changed while being read. A "seq-cst"
-  // operation is expensive but is only done during analysis and it's the only
-  // way to ensure this occurs after all the accesses above. If changes did
-  // occur then return a "not loaded" result so that |size| and |address|
-  // aren't expected to be accurate.
-  if ((current_changes & kModuleInformationChanging) != 0 ||
-      changes.load(std::memory_order_seq_cst) != current_changes) {
-    info->is_loaded = false;
-  }
-
-  // Copy out the static information. These never change so don't have to be
-  // protected by the atomic |current_changes| operations.
-  info->size = static_cast<size_t>(size);
-  info->timestamp = timestamp;
-  info->age = age;
-  memcpy(info->identifier, identifier, sizeof(info->identifier));
-
-  if (offsetof(ModuleInfoRecord, pickle) + pickle_size > record_size)
-    return false;
-  Pickle pickler(pickle, pickle_size);
-  PickleIterator iter(pickler);
-  return iter.ReadString(&info->file) && iter.ReadString(&info->debug_file);
-}
-
-GlobalActivityTracker::ModuleInfoRecord*
-GlobalActivityTracker::ModuleInfoRecord::CreateFrom(
-    const GlobalActivityTracker::ModuleInfo& info,
-    PersistentMemoryAllocator* allocator) {
-  Pickle pickler;
-  pickler.WriteString(info.file);
-  pickler.WriteString(info.debug_file);
-  size_t required_size = offsetof(ModuleInfoRecord, pickle) + pickler.size();
-  ModuleInfoRecord* record = allocator->New<ModuleInfoRecord>(required_size);
-  if (!record)
-    return nullptr;
-
-  // These fields never changes and are done before the record is made
-  // iterable so no thread protection is necessary.
-  record->size = info.size;
-  record->timestamp = info.timestamp;
-  record->age = info.age;
-  memcpy(record->identifier, info.identifier, sizeof(identifier));
-  memcpy(record->pickle, pickler.data(), pickler.size());
-  record->pickle_size = pickler.size();
-  record->changes.store(0, std::memory_order_relaxed);
-
-  // Initialize the owner info.
-  record->owner.Release_Initialize();
-
-  // Now set those fields that can change.
-  bool success = record->UpdateFrom(info);
-  DCHECK(success);
-  return record;
-}
-
-bool GlobalActivityTracker::ModuleInfoRecord::UpdateFrom(
-    const GlobalActivityTracker::ModuleInfo& info) {
-  // Updates can occur after the record is made visible so make changes atomic.
-  // A "strong" exchange ensures no false failures.
-  uint32_t old_changes = changes.load(std::memory_order_relaxed);
-  uint32_t new_changes = old_changes | kModuleInformationChanging;
-  if ((old_changes & kModuleInformationChanging) != 0 ||
-      !changes.compare_exchange_strong(old_changes, new_changes,
-                                       std::memory_order_acquire,
-                                       std::memory_order_acquire)) {
-    NOTREACHED() << "Multiple sources are updating module information.";
-    return false;
-  }
-
-  loaded = info.is_loaded ? 1 : 0;
-  address = info.address;
-  load_time = Time::Now().ToInternalValue();
-
-  bool success = changes.compare_exchange_strong(new_changes, old_changes + 1,
-                                                 std::memory_order_release,
-                                                 std::memory_order_relaxed);
-  DCHECK(success);
-  return true;
-}
-
-GlobalActivityTracker::ScopedThreadActivity::ScopedThreadActivity(
-    const void* program_counter,
-    const void* origin,
-    Activity::Type type,
-    const ActivityData& data,
-    bool lock_allowed)
-    : ThreadActivityTracker::ScopedActivity(GetOrCreateTracker(lock_allowed),
-                                            program_counter,
-                                            origin,
-                                            type,
-                                            data) {}
-
-GlobalActivityTracker::ScopedThreadActivity::~ScopedThreadActivity() {
-  if (tracker_ && tracker_->HasUserData(activity_id_)) {
-    GlobalActivityTracker* global = GlobalActivityTracker::Get();
-    AutoLock lock(global->user_data_allocator_lock_);
-    tracker_->ReleaseUserData(activity_id_, &global->user_data_allocator_);
-  }
-}
-
-ActivityUserData& GlobalActivityTracker::ScopedThreadActivity::user_data() {
-  if (!user_data_) {
-    if (tracker_) {
-      GlobalActivityTracker* global = GlobalActivityTracker::Get();
-      AutoLock lock(global->user_data_allocator_lock_);
-      user_data_ =
-          tracker_->GetUserData(activity_id_, &global->user_data_allocator_);
-    } else {
-      user_data_ = std::make_unique<ActivityUserData>();
-    }
-  }
-  return *user_data_;
-}
-
-GlobalActivityTracker::ThreadSafeUserData::ThreadSafeUserData(void* memory,
-                                                              size_t size,
-                                                              int64_t pid)
-    : ActivityUserData(memory, size, pid) {}
-
-GlobalActivityTracker::ThreadSafeUserData::~ThreadSafeUserData() = default;
-
-void GlobalActivityTracker::ThreadSafeUserData::Set(StringPiece name,
-                                                    ValueType type,
-                                                    const void* memory,
-                                                    size_t size) {
-  AutoLock lock(data_lock_);
-  ActivityUserData::Set(name, type, memory, size);
-}
-
-GlobalActivityTracker::ManagedActivityTracker::ManagedActivityTracker(
-    PersistentMemoryAllocator::Reference mem_reference,
-    void* base,
-    size_t size)
-    : ThreadActivityTracker(base, size),
-      mem_reference_(mem_reference),
-      mem_base_(base) {}
-
-GlobalActivityTracker::ManagedActivityTracker::~ManagedActivityTracker() {
-  // The global |g_tracker_| must point to the owner of this class since all
-  // objects of this type must be destructed before |g_tracker_| can be changed
-  // (something that only occurs in tests).
-  DCHECK(g_tracker_);
-  GlobalActivityTracker::Get()->ReturnTrackerMemory(this);
-}
-
-void GlobalActivityTracker::CreateWithAllocator(
-    std::unique_ptr<PersistentMemoryAllocator> allocator,
-    int stack_depth,
-    int64_t process_id) {
-  // There's no need to do anything with the result. It is self-managing.
-  GlobalActivityTracker* global_tracker =
-      new GlobalActivityTracker(std::move(allocator), stack_depth, process_id);
-  // Create a tracker for this thread since it is known.
-  global_tracker->CreateTrackerForCurrentThread();
-}
-
-#if !defined(OS_NACL)
-// static
-bool GlobalActivityTracker::CreateWithFile(const FilePath& file_path,
-                                           size_t size,
-                                           uint64_t id,
-                                           StringPiece name,
-                                           int stack_depth) {
-  DCHECK(!file_path.empty());
-  DCHECK_GE(static_cast<uint64_t>(std::numeric_limits<int64_t>::max()), size);
-
-  // Create and map the file into memory and make it globally available.
-  std::unique_ptr<MemoryMappedFile> mapped_file(new MemoryMappedFile());
-  bool success = mapped_file->Initialize(
-      File(file_path, File::FLAG_CREATE_ALWAYS | File::FLAG_READ |
-                          File::FLAG_WRITE | File::FLAG_SHARE_DELETE),
-      {0, size}, MemoryMappedFile::READ_WRITE_EXTEND);
-  if (!success)
-    return false;
-  if (!FilePersistentMemoryAllocator::IsFileAcceptable(*mapped_file, false))
-    return false;
-  CreateWithAllocator(std::make_unique<FilePersistentMemoryAllocator>(
-                          std::move(mapped_file), size, id, name, false),
-                      stack_depth, 0);
-  return true;
-}
-#endif  // !defined(OS_NACL)
-
-// static
-bool GlobalActivityTracker::CreateWithLocalMemory(size_t size,
-                                                  uint64_t id,
-                                                  StringPiece name,
-                                                  int stack_depth,
-                                                  int64_t process_id) {
-  CreateWithAllocator(
-      std::make_unique<LocalPersistentMemoryAllocator>(size, id, name),
-      stack_depth, process_id);
-  return true;
-}
-
-// static
-bool GlobalActivityTracker::CreateWithSharedMemory(
-    std::unique_ptr<SharedMemory> shm,
-    uint64_t id,
-    StringPiece name,
-    int stack_depth) {
-  if (shm->mapped_size() == 0 ||
-      !SharedPersistentMemoryAllocator::IsSharedMemoryAcceptable(*shm)) {
-    return false;
-  }
-  CreateWithAllocator(std::make_unique<SharedPersistentMemoryAllocator>(
-                          std::move(shm), id, name, false),
-                      stack_depth, 0);
-  return true;
-}
-
-// static
-bool GlobalActivityTracker::CreateWithSharedMemoryHandle(
-    const SharedMemoryHandle& handle,
-    size_t size,
-    uint64_t id,
-    StringPiece name,
-    int stack_depth) {
-  std::unique_ptr<SharedMemory> shm(
-      new SharedMemory(handle, /*readonly=*/false));
-  if (!shm->Map(size))
-    return false;
-  return CreateWithSharedMemory(std::move(shm), id, name, stack_depth);
-}
-
-// static
-void GlobalActivityTracker::SetForTesting(
-    std::unique_ptr<GlobalActivityTracker> tracker) {
-  CHECK(!subtle::NoBarrier_Load(&g_tracker_));
-  subtle::Release_Store(&g_tracker_,
-                        reinterpret_cast<uintptr_t>(tracker.release()));
-}
-
-// static
-std::unique_ptr<GlobalActivityTracker>
-GlobalActivityTracker::ReleaseForTesting() {
-  GlobalActivityTracker* tracker = Get();
-  if (!tracker)
-    return nullptr;
-
-  // Thread trackers assume that the global tracker is present for some
-  // operations so ensure that there aren't any.
-  tracker->ReleaseTrackerForCurrentThreadForTesting();
-  DCHECK_EQ(0, tracker->thread_tracker_count_.load(std::memory_order_relaxed));
-
-  subtle::Release_Store(&g_tracker_, 0);
-  return WrapUnique(tracker);
-}
-
-ThreadActivityTracker* GlobalActivityTracker::CreateTrackerForCurrentThread() {
-  DCHECK(!this_thread_tracker_.Get());
-
-  PersistentMemoryAllocator::Reference mem_reference;
-
-  {
-    base::AutoLock autolock(thread_tracker_allocator_lock_);
-    mem_reference = thread_tracker_allocator_.GetObjectReference();
-  }
-
-  if (!mem_reference) {
-    // Failure. This shouldn't happen. But be graceful if it does, probably
-    // because the underlying allocator wasn't given enough memory to satisfy
-    // to all possible requests.
-    NOTREACHED();
-    // Report the thread-count at which the allocator was full so that the
-    // failure can be seen and underlying memory resized appropriately.
-    UMA_HISTOGRAM_COUNTS_1000(
-        "ActivityTracker.ThreadTrackers.MemLimitTrackerCount",
-        thread_tracker_count_.load(std::memory_order_relaxed));
-    // Return null, just as if tracking wasn't enabled.
-    return nullptr;
-  }
-
-  // Convert the memory block found above into an actual memory address.
-  // Doing the conversion as a Header object enacts the 32/64-bit size
-  // consistency checks which would not otherwise be done. Unfortunately,
-  // some older compilers and MSVC don't have standard-conforming definitions
-  // of std::atomic which cause it not to be plain-old-data. Don't check on
-  // those platforms assuming that the checks on other platforms will be
-  // sufficient.
-  // TODO(bcwhite): Review this after major compiler releases.
-  DCHECK(mem_reference);
-  void* mem_base;
-  mem_base =
-      allocator_->GetAsObject<ThreadActivityTracker::Header>(mem_reference);
-
-  DCHECK(mem_base);
-  DCHECK_LE(stack_memory_size_, allocator_->GetAllocSize(mem_reference));
-
-  // Create a tracker with the acquired memory and set it as the tracker
-  // for this particular thread in thread-local-storage.
-  ManagedActivityTracker* tracker =
-      new ManagedActivityTracker(mem_reference, mem_base, stack_memory_size_);
-  DCHECK(tracker->IsValid());
-  this_thread_tracker_.Set(tracker);
-  int old_count = thread_tracker_count_.fetch_add(1, std::memory_order_relaxed);
-
-  UMA_HISTOGRAM_EXACT_LINEAR("ActivityTracker.ThreadTrackers.Count",
-                             old_count + 1, static_cast<int>(kMaxThreadCount));
-  return tracker;
-}
-
-void GlobalActivityTracker::ReleaseTrackerForCurrentThreadForTesting() {
-  ThreadActivityTracker* tracker =
-      reinterpret_cast<ThreadActivityTracker*>(this_thread_tracker_.Get());
-  if (tracker) {
-    this_thread_tracker_.Set(nullptr);
-    delete tracker;
-  }
-}
-
-void GlobalActivityTracker::SetBackgroundTaskRunner(
-    const scoped_refptr<TaskRunner>& runner) {
-  AutoLock lock(global_tracker_lock_);
-  background_task_runner_ = runner;
-}
-
-void GlobalActivityTracker::SetProcessExitCallback(
-    ProcessExitCallback callback) {
-  AutoLock lock(global_tracker_lock_);
-  process_exit_callback_ = callback;
-}
-
-void GlobalActivityTracker::RecordProcessLaunch(
-    ProcessId process_id,
-    const FilePath::StringType& cmd) {
-  const int64_t pid = process_id;
-  DCHECK_NE(GetProcessId(), pid);
-  DCHECK_NE(0, pid);
-
-  base::AutoLock lock(global_tracker_lock_);
-  if (base::ContainsKey(known_processes_, pid)) {
-    // TODO(bcwhite): Measure this in UMA.
-    NOTREACHED() << "Process #" << process_id
-                 << " was previously recorded as \"launched\""
-                 << " with no corresponding exit.\n"
-                 << known_processes_[pid];
-    known_processes_.erase(pid);
-  }
-
-#if defined(OS_WIN)
-  known_processes_.insert(std::make_pair(pid, UTF16ToUTF8(cmd)));
-#else
-  known_processes_.insert(std::make_pair(pid, cmd));
-#endif
-}
-
-void GlobalActivityTracker::RecordProcessLaunch(
-    ProcessId process_id,
-    const FilePath::StringType& exe,
-    const FilePath::StringType& args) {
-  if (exe.find(FILE_PATH_LITERAL(" "))) {
-    RecordProcessLaunch(process_id,
-                        FilePath::StringType(FILE_PATH_LITERAL("\"")) + exe +
-                            FILE_PATH_LITERAL("\" ") + args);
-  } else {
-    RecordProcessLaunch(process_id, exe + FILE_PATH_LITERAL(' ') + args);
-  }
-}
-
-void GlobalActivityTracker::RecordProcessExit(ProcessId process_id,
-                                              int exit_code) {
-  const int64_t pid = process_id;
-  DCHECK_NE(GetProcessId(), pid);
-  DCHECK_NE(0, pid);
-
-  scoped_refptr<TaskRunner> task_runner;
-  std::string command_line;
-  {
-    base::AutoLock lock(global_tracker_lock_);
-    task_runner = background_task_runner_;
-    auto found = known_processes_.find(pid);
-    if (found != known_processes_.end()) {
-      command_line = std::move(found->second);
-      known_processes_.erase(found);
-    } else {
-      DLOG(ERROR) << "Recording exit of unknown process #" << process_id;
-    }
-  }
-
-  // Use the current time to differentiate the process that just exited
-  // from any that might be created in the future with the same ID.
-  int64_t now_stamp = Time::Now().ToInternalValue();
-
-  // The persistent allocator is thread-safe so run the iteration and
-  // adjustments on a worker thread if one was provided.
-  if (task_runner && !task_runner->RunsTasksInCurrentSequence()) {
-    task_runner->PostTask(
-        FROM_HERE,
-        BindOnce(&GlobalActivityTracker::CleanupAfterProcess, Unretained(this),
-                 pid, now_stamp, exit_code, std::move(command_line)));
-    return;
-  }
-
-  CleanupAfterProcess(pid, now_stamp, exit_code, std::move(command_line));
-}
-
-void GlobalActivityTracker::SetProcessPhase(ProcessPhase phase) {
-  process_data().SetInt(kProcessPhaseDataKey, phase);
-}
-
-void GlobalActivityTracker::CleanupAfterProcess(int64_t process_id,
-                                                int64_t exit_stamp,
-                                                int exit_code,
-                                                std::string&& command_line) {
-  // The process may not have exited cleanly so its necessary to go through
-  // all the data structures it may have allocated in the persistent memory
-  // segment and mark them as "released". This will allow them to be reused
-  // later on.
-
-  PersistentMemoryAllocator::Iterator iter(allocator_.get());
-  PersistentMemoryAllocator::Reference ref;
-
-  ProcessExitCallback process_exit_callback;
-  {
-    AutoLock lock(global_tracker_lock_);
-    process_exit_callback = process_exit_callback_;
-  }
-  if (process_exit_callback) {
-    // Find the processes user-data record so the process phase can be passed
-    // to the callback.
-    ActivityUserData::Snapshot process_data_snapshot;
-    while ((ref = iter.GetNextOfType(kTypeIdProcessDataRecord)) != 0) {
-      const void* memory = allocator_->GetAsArray<char>(
-          ref, kTypeIdProcessDataRecord, PersistentMemoryAllocator::kSizeAny);
-      if (!memory)
-        continue;
-      int64_t found_id;
-      int64_t create_stamp;
-      if (ActivityUserData::GetOwningProcessId(memory, &found_id,
-                                               &create_stamp)) {
-        if (found_id == process_id && create_stamp < exit_stamp) {
-          const ActivityUserData process_data(const_cast<void*>(memory),
-                                              allocator_->GetAllocSize(ref));
-          process_data.CreateSnapshot(&process_data_snapshot);
-          break;  // No need to look for any others.
-        }
-      }
-    }
-    iter.Reset();  // So it starts anew when used below.
-
-    // Record the process's phase at exit so callback doesn't need to go
-    // searching based on a private key value.
-    ProcessPhase exit_phase = PROCESS_PHASE_UNKNOWN;
-    auto phase = process_data_snapshot.find(kProcessPhaseDataKey);
-    if (phase != process_data_snapshot.end())
-      exit_phase = static_cast<ProcessPhase>(phase->second.GetInt());
-
-    // Perform the callback.
-    process_exit_callback.Run(process_id, exit_stamp, exit_code, exit_phase,
-                              std::move(command_line),
-                              std::move(process_data_snapshot));
-  }
-
-  // Find all allocations associated with the exited process and free them.
-  uint32_t type;
-  while ((ref = iter.GetNext(&type)) != 0) {
-    switch (type) {
-      case kTypeIdActivityTracker:
-      case kTypeIdUserDataRecord:
-      case kTypeIdProcessDataRecord:
-      case ModuleInfoRecord::kPersistentTypeId: {
-        const void* memory = allocator_->GetAsArray<char>(
-            ref, type, PersistentMemoryAllocator::kSizeAny);
-        if (!memory)
-          continue;
-        int64_t found_id;
-        int64_t create_stamp;
-
-        // By convention, the OwningProcess structure is always the first
-        // field of the structure so there's no need to handle all the
-        // cases separately.
-        if (OwningProcess::GetOwningProcessId(memory, &found_id,
-                                              &create_stamp)) {
-          // Only change the type to be "free" if the process ID matches and
-          // the creation time is before the exit time (so PID re-use doesn't
-          // cause the erasure of something that is in-use). Memory is cleared
-          // here, rather than when it's needed, so as to limit the impact at
-          // that critical time.
-          if (found_id == process_id && create_stamp < exit_stamp)
-            allocator_->ChangeType(ref, ~type, type, /*clear=*/true);
-        }
-      } break;
-    }
-  }
-}
-
-void GlobalActivityTracker::RecordLogMessage(StringPiece message) {
-  // Allocate at least one extra byte so the string is NUL terminated. All
-  // memory returned by the allocator is guaranteed to be zeroed.
-  PersistentMemoryAllocator::Reference ref =
-      allocator_->Allocate(message.size() + 1, kTypeIdGlobalLogMessage);
-  char* memory = allocator_->GetAsArray<char>(ref, kTypeIdGlobalLogMessage,
-                                              message.size() + 1);
-  if (memory) {
-    memcpy(memory, message.data(), message.size());
-    allocator_->MakeIterable(ref);
-  }
-}
-
-void GlobalActivityTracker::RecordModuleInfo(const ModuleInfo& info) {
-  AutoLock lock(modules_lock_);
-  auto found = modules_.find(info.file);
-  if (found != modules_.end()) {
-    ModuleInfoRecord* record = found->second;
-    DCHECK(record);
-
-    // Update the basic state of module information that has been already
-    // recorded. It is assumed that the string information (identifier,
-    // version, etc.) remain unchanged which means that there's no need
-    // to create a new record to accommodate a possibly longer length.
-    record->UpdateFrom(info);
-    return;
-  }
-
-  ModuleInfoRecord* record =
-      ModuleInfoRecord::CreateFrom(info, allocator_.get());
-  if (!record)
-    return;
-  allocator_->MakeIterable(record);
-  modules_.emplace(info.file, record);
-}
-
-void GlobalActivityTracker::RecordFieldTrial(const std::string& trial_name,
-                                             StringPiece group_name) {
-  const std::string key = std::string("FieldTrial.") + trial_name;
-  process_data_.SetString(key, group_name);
-}
-
-void GlobalActivityTracker::RecordException(const void* pc,
-                                            const void* origin,
-                                            uint32_t code) {
-  RecordExceptionImpl(pc, origin, code);
-}
-
-void GlobalActivityTracker::MarkDeleted() {
-  allocator_->SetMemoryState(PersistentMemoryAllocator::MEMORY_DELETED);
-}
-
-GlobalActivityTracker::GlobalActivityTracker(
-    std::unique_ptr<PersistentMemoryAllocator> allocator,
-    int stack_depth,
-    int64_t process_id)
-    : allocator_(std::move(allocator)),
-      stack_memory_size_(ThreadActivityTracker::SizeForStackDepth(stack_depth)),
-      process_id_(process_id == 0 ? GetCurrentProcId() : process_id),
-      this_thread_tracker_(&OnTLSDestroy),
-      thread_tracker_count_(0),
-      thread_tracker_allocator_(allocator_.get(),
-                                kTypeIdActivityTracker,
-                                kTypeIdActivityTrackerFree,
-                                stack_memory_size_,
-                                kCachedThreadMemories,
-                                /*make_iterable=*/true),
-      user_data_allocator_(allocator_.get(),
-                           kTypeIdUserDataRecord,
-                           kTypeIdUserDataRecordFree,
-                           kUserDataSize,
-                           kCachedUserDataMemories,
-                           /*make_iterable=*/true),
-      process_data_(allocator_->GetAsArray<char>(
-                        AllocateFrom(allocator_.get(),
-                                     kTypeIdProcessDataRecordFree,
-                                     kProcessDataSize,
-                                     kTypeIdProcessDataRecord),
-                        kTypeIdProcessDataRecord,
-                        kProcessDataSize),
-                    kProcessDataSize,
-                    process_id_) {
-  DCHECK_NE(0, process_id_);
-
-  // Ensure that there is no other global object and then make this one such.
-  DCHECK(!g_tracker_);
-  subtle::Release_Store(&g_tracker_, reinterpret_cast<uintptr_t>(this));
-
-  // The data records must be iterable in order to be found by an analyzer.
-  allocator_->MakeIterable(allocator_->GetAsReference(
-      process_data_.GetBaseAddress(), kTypeIdProcessDataRecord));
-
-  // Note that this process has launched.
-  SetProcessPhase(PROCESS_LAUNCHED);
-
-  // Fetch and record all activated field trials.
-  FieldTrial::ActiveGroups active_groups;
-  FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
-  for (auto& group : active_groups)
-    RecordFieldTrial(group.trial_name, group.group_name);
-}
-
-GlobalActivityTracker::~GlobalActivityTracker() {
-  DCHECK(Get() == nullptr || Get() == this);
-  DCHECK_EQ(0, thread_tracker_count_.load(std::memory_order_relaxed));
-  subtle::Release_Store(&g_tracker_, 0);
-}
-
-void GlobalActivityTracker::ReturnTrackerMemory(
-    ManagedActivityTracker* tracker) {
-  PersistentMemoryAllocator::Reference mem_reference = tracker->mem_reference_;
-  void* mem_base = tracker->mem_base_;
-  DCHECK(mem_reference);
-  DCHECK(mem_base);
-
-  // Remove the destructed tracker from the set of known ones.
-  DCHECK_LE(1, thread_tracker_count_.load(std::memory_order_relaxed));
-  thread_tracker_count_.fetch_sub(1, std::memory_order_relaxed);
-
-  // Release this memory for re-use at a later time.
-  base::AutoLock autolock(thread_tracker_allocator_lock_);
-  thread_tracker_allocator_.ReleaseObjectReference(mem_reference);
-}
-
-void GlobalActivityTracker::RecordExceptionImpl(const void* pc,
-                                                const void* origin,
-                                                uint32_t code) {
-  // Get an existing tracker for this thread. It's not possible to create
-  // one at this point because such would involve memory allocations and
-  // other potentially complex operations that can cause failures if done
-  // within an exception handler. In most cases various operations will
-  // have already created the tracker so this shouldn't generally be a
-  // problem.
-  ThreadActivityTracker* tracker = GetTrackerForCurrentThread();
-  if (!tracker)
-    return;
-
-  tracker->RecordExceptionActivity(pc, origin, Activity::ACT_EXCEPTION,
-                                   ActivityData::ForException(code));
-}
-
-// static
-void GlobalActivityTracker::OnTLSDestroy(void* value) {
-  delete reinterpret_cast<ManagedActivityTracker*>(value);
-}
-
-ScopedActivity::ScopedActivity(const void* program_counter,
-                               uint8_t action,
-                               uint32_t id,
-                               int32_t info)
-    : GlobalActivityTracker::ScopedThreadActivity(
-          program_counter,
-          nullptr,
-          static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
-          ActivityData::ForGeneric(id, info),
-          /*lock_allowed=*/true),
-      id_(id) {
-  // The action must not affect the category bits of the activity type.
-  DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
-}
-
-void ScopedActivity::ChangeAction(uint8_t action) {
-  DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
-  ChangeTypeAndData(static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
-                    kNullActivityData);
-}
-
-void ScopedActivity::ChangeInfo(int32_t info) {
-  ChangeTypeAndData(Activity::ACT_NULL, ActivityData::ForGeneric(id_, info));
-}
-
-void ScopedActivity::ChangeActionAndInfo(uint8_t action, int32_t info) {
-  DCHECK_EQ(0, action & Activity::ACT_CATEGORY_MASK);
-  ChangeTypeAndData(static_cast<Activity::Type>(Activity::ACT_GENERIC | action),
-                    ActivityData::ForGeneric(id_, info));
-}
-
-ScopedTaskRunActivity::ScopedTaskRunActivity(
-    const void* program_counter,
-    const base::PendingTask& task)
-    : GlobalActivityTracker::ScopedThreadActivity(
-          program_counter,
-          task.posted_from.program_counter(),
-          Activity::ACT_TASK_RUN,
-          ActivityData::ForTask(task.sequence_num),
-          /*lock_allowed=*/true) {}
-
-ScopedLockAcquireActivity::ScopedLockAcquireActivity(
-    const void* program_counter,
-    const base::internal::LockImpl* lock)
-    : GlobalActivityTracker::ScopedThreadActivity(
-          program_counter,
-          nullptr,
-          Activity::ACT_LOCK_ACQUIRE,
-          ActivityData::ForLock(lock),
-          /*lock_allowed=*/false) {}
-
-ScopedEventWaitActivity::ScopedEventWaitActivity(
-    const void* program_counter,
-    const base::WaitableEvent* event)
-    : GlobalActivityTracker::ScopedThreadActivity(
-          program_counter,
-          nullptr,
-          Activity::ACT_EVENT_WAIT,
-          ActivityData::ForEvent(event),
-          /*lock_allowed=*/true) {}
-
-ScopedThreadJoinActivity::ScopedThreadJoinActivity(
-    const void* program_counter,
-    const base::PlatformThreadHandle* thread)
-    : GlobalActivityTracker::ScopedThreadActivity(
-          program_counter,
-          nullptr,
-          Activity::ACT_THREAD_JOIN,
-          ActivityData::ForThread(*thread),
-          /*lock_allowed=*/true) {}
-
-#if !defined(OS_NACL) && !defined(OS_IOS)
-ScopedProcessWaitActivity::ScopedProcessWaitActivity(
-    const void* program_counter,
-    const base::Process* process)
-    : GlobalActivityTracker::ScopedThreadActivity(
-          program_counter,
-          nullptr,
-          Activity::ACT_PROCESS_WAIT,
-          ActivityData::ForProcess(process->Pid()),
-          /*lock_allowed=*/true) {}
-#endif
-
-}  // namespace debug
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/debug/activity_tracker.h b/native/zucchini/vendor/libchrome/base/debug/activity_tracker.h
deleted file mode 100644
index 5647d86..0000000
--- a/native/zucchini/vendor/libchrome/base/debug/activity_tracker.h
+++ /dev/null
@@ -1,1367 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Activity tracking provides a low-overhead method of collecting information
-// about the state of the application for analysis both while it is running
-// and after it has terminated unexpectedly. Its primary purpose is to help
-// locate reasons the browser becomes unresponsive by providing insight into
-// what all the various threads and processes are (or were) doing.
-
-#ifndef BASE_DEBUG_ACTIVITY_TRACKER_H_
-#define BASE_DEBUG_ACTIVITY_TRACKER_H_
-
-// std::atomic is undesired due to performance issues when used as global
-// variables. There are no such instances here. This module uses the
-// PersistentMemoryAllocator which also uses std::atomic and is written
-// by the same author.
-#include <atomic>
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/compiler_specific.h"
-#include "base/gtest_prod_util.h"
-#include "base/location.h"
-#include "base/memory/shared_memory.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/process/process_handle.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/task_runner.h"
-#include "base/threading/platform_thread.h"
-#include "base/threading/thread_local_storage.h"
-
-namespace base {
-
-struct PendingTask;
-
-class FilePath;
-class Lock;
-class PlatformThreadHandle;
-class Process;
-class WaitableEvent;
-
-namespace debug {
-
-class ThreadActivityTracker;
-
-
-enum : int {
-  // The maximum number of call-stack addresses stored per activity. This
-  // cannot be changed without also changing the version number of the
-  // structure. See kTypeIdActivityTracker in GlobalActivityTracker.
-  kActivityCallStackSize = 10,
-};
-
-// A class for keeping all information needed to verify that a structure is
-// associated with a given process.
-struct OwningProcess {
-  OwningProcess();
-  ~OwningProcess();
-
-  // Initializes structure with the current process id and the current time.
-  // These can uniquely identify a process. A unique non-zero data_id will be
-  // set making it possible to tell using atomic reads if the data has changed.
-  void Release_Initialize(int64_t pid = 0);
-
-  // Explicitly sets the process ID.
-  void SetOwningProcessIdForTesting(int64_t pid, int64_t stamp);
-
-  // Gets the associated process ID, in native form, and the creation timestamp
-  // from memory without loading the entire structure for analysis. This will
-  // return false if no valid process ID is available.
-  static bool GetOwningProcessId(const void* memory,
-                                 int64_t* out_id,
-                                 int64_t* out_stamp);
-
-  // SHA1(base::debug::OwningProcess): Increment this if structure changes!
-  static constexpr uint32_t kPersistentTypeId = 0xB1179672 + 1;
-
-  // Expected size for 32/64-bit check by PersistentMemoryAllocator.
-  static constexpr size_t kExpectedInstanceSize = 24;
-
-  std::atomic<uint32_t> data_id;
-  uint32_t padding;
-  int64_t process_id;
-  int64_t create_stamp;
-};
-
-// The data associated with an activity is dependent upon the activity type.
-// This union defines all of the various fields. All fields must be explicitly
-// sized types to ensure no interoperability problems between 32-bit and
-// 64-bit systems.
-union ActivityData {
-  // Expected size for 32/64-bit check.
-  // TODO(bcwhite): VC2015 doesn't allow statics in unions. Fix when it does.
-  // static constexpr size_t kExpectedInstanceSize = 8;
-
-  // Generic activities don't have any defined structure.
-  struct {
-    uint32_t id;   // An arbitrary identifier used for association.
-    int32_t info;  // An arbitrary value used for information purposes.
-  } generic;
-  struct {
-    uint64_t sequence_id;  // The sequence identifier of the posted task.
-  } task;
-  struct {
-    uint64_t lock_address;  // The memory address of the lock object.
-  } lock;
-  struct {
-    uint64_t event_address;  // The memory address of the event object.
-  } event;
-  struct {
-    int64_t thread_id;  // A unique identifier for a thread within a process.
-  } thread;
-  struct {
-    int64_t process_id;  // A unique identifier for a process.
-  } process;
-  struct {
-    uint32_t code;  // An "exception code" number.
-  } exception;
-
-  // These methods create an ActivityData object from the appropriate
-  // parameters. Objects of this type should always be created this way to
-  // ensure that no fields remain unpopulated should the set of recorded
-  // fields change. They're defined inline where practical because they
-  // reduce to loading a small local structure with a few values, roughly
-  // the same as loading all those values into parameters.
-
-  static ActivityData ForGeneric(uint32_t id, int32_t info) {
-    ActivityData data;
-    data.generic.id = id;
-    data.generic.info = info;
-    return data;
-  }
-
-  static ActivityData ForTask(uint64_t sequence) {
-    ActivityData data;
-    data.task.sequence_id = sequence;
-    return data;
-  }
-
-  static ActivityData ForLock(const void* lock) {
-    ActivityData data;
-    data.lock.lock_address = reinterpret_cast<uintptr_t>(lock);
-    return data;
-  }
-
-  static ActivityData ForEvent(const void* event) {
-    ActivityData data;
-    data.event.event_address = reinterpret_cast<uintptr_t>(event);
-    return data;
-  }
-
-  static ActivityData ForThread(const PlatformThreadHandle& handle);
-  static ActivityData ForThread(const int64_t id) {
-    ActivityData data;
-    data.thread.thread_id = id;
-    return data;
-  }
-
-  static ActivityData ForProcess(const int64_t id) {
-    ActivityData data;
-    data.process.process_id = id;
-    return data;
-  }
-
-  static ActivityData ForException(const uint32_t code) {
-    ActivityData data;
-    data.exception.code = code;
-    return data;
-  }
-};
-
-// A "null" activity-data that can be passed to indicate "do not change".
-extern const ActivityData kNullActivityData;
-
-
-// A helper class that is used for managing memory allocations within a
-// persistent memory allocator. Instances of this class are NOT thread-safe.
-// Use from a single thread or protect access with a lock.
-class BASE_EXPORT ActivityTrackerMemoryAllocator {
- public:
-  using Reference = PersistentMemoryAllocator::Reference;
-
-  // Creates a instance for allocating objects of a fixed |object_type|, a
-  // corresponding |object_free| type, and the |object_size|. An internal
-  // cache of the last |cache_size| released references will be kept for
-  // quick future fetches. If |make_iterable| then allocated objects will
-  // be marked "iterable" in the allocator.
-  ActivityTrackerMemoryAllocator(PersistentMemoryAllocator* allocator,
-                                 uint32_t object_type,
-                                 uint32_t object_free_type,
-                                 size_t object_size,
-                                 size_t cache_size,
-                                 bool make_iterable);
-  ~ActivityTrackerMemoryAllocator();
-
-  // Gets a reference to an object of the configured type. This can return
-  // a null reference if it was not possible to allocate the memory.
-  Reference GetObjectReference();
-
-  // Returns an object to the "free" pool.
-  void ReleaseObjectReference(Reference ref);
-
-  // Helper function to access an object allocated using this instance.
-  template <typename T>
-  T* GetAsObject(Reference ref) {
-    return allocator_->GetAsObject<T>(ref);
-  }
-
-  // Similar to GetAsObject() but converts references to arrays of objects.
-  template <typename T>
-  T* GetAsArray(Reference ref, size_t count) {
-    return allocator_->GetAsArray<T>(ref, object_type_, count);
-  }
-
-  // The current "used size" of the internal cache, visible for testing.
-  size_t cache_used() const { return cache_used_; }
-
- private:
-  PersistentMemoryAllocator* const allocator_;
-  const uint32_t object_type_;
-  const uint32_t object_free_type_;
-  const size_t object_size_;
-  const size_t cache_size_;
-  const bool make_iterable_;
-
-  // An iterator for going through persistent memory looking for free'd objects.
-  PersistentMemoryAllocator::Iterator iterator_;
-
-  // The cache of released object memories.
-  std::unique_ptr<Reference[]> cache_values_;
-  size_t cache_used_;
-
-  DISALLOW_COPY_AND_ASSIGN(ActivityTrackerMemoryAllocator);
-};
-
-
-// This structure is the full contents recorded for every activity pushed
-// onto the stack. The |activity_type| indicates what is actually stored in
-// the |data| field. All fields must be explicitly sized types to ensure no
-// interoperability problems between 32-bit and 64-bit systems.
-struct Activity {
-  // SHA1(base::debug::Activity): Increment this if structure changes!
-  static constexpr uint32_t kPersistentTypeId = 0x99425159 + 1;
-  // Expected size for 32/64-bit check. Update this if structure changes!
-  static constexpr size_t kExpectedInstanceSize =
-      48 + 8 * kActivityCallStackSize;
-
-  // The type of an activity on the stack. Activities are broken into
-  // categories with the category ID taking the top 4 bits and the lower
-  // bits representing an action within that category. This combination
-  // makes it easy to "switch" based on the type during analysis.
-  enum Type : uint8_t {
-    // This "null" constant is used to indicate "do not change" in calls.
-    ACT_NULL = 0,
-
-    // Task activities involve callbacks posted to a thread or thread-pool
-    // using the PostTask() method or any of its friends.
-    ACT_TASK = 1 << 4,
-    ACT_TASK_RUN = ACT_TASK,
-
-    // Lock activities involve the acquisition of "mutex" locks.
-    ACT_LOCK = 2 << 4,
-    ACT_LOCK_ACQUIRE = ACT_LOCK,
-    ACT_LOCK_RELEASE,
-
-    // Event activities involve operations on a WaitableEvent.
-    ACT_EVENT = 3 << 4,
-    ACT_EVENT_WAIT = ACT_EVENT,
-    ACT_EVENT_SIGNAL,
-
-    // Thread activities involve the life management of threads.
-    ACT_THREAD = 4 << 4,
-    ACT_THREAD_START = ACT_THREAD,
-    ACT_THREAD_JOIN,
-
-    // Process activities involve the life management of processes.
-    ACT_PROCESS = 5 << 4,
-    ACT_PROCESS_START = ACT_PROCESS,
-    ACT_PROCESS_WAIT,
-
-    // Exception activities indicate the occurence of something unexpected.
-    ACT_EXCEPTION = 14 << 4,
-
-    // Generic activities are user defined and can be anything.
-    ACT_GENERIC = 15 << 4,
-
-    // These constants can be used to separate the category and action from
-    // a combined activity type.
-    ACT_CATEGORY_MASK = 0xF << 4,
-    ACT_ACTION_MASK = 0xF
-  };
-
-  // Internal representation of time. During collection, this is in "ticks"
-  // but when returned in a snapshot, it is "wall time".
-  int64_t time_internal;
-
-  // The address that pushed the activity onto the stack as a raw number.
-  uint64_t calling_address;
-
-  // The address that is the origin of the activity if it not obvious from
-  // the call stack. This is useful for things like tasks that are posted
-  // from a completely different thread though most activities will leave
-  // it null.
-  uint64_t origin_address;
-
-  // Array of program-counters that make up the top of the call stack.
-  // Despite the fixed size, this list is always null-terminated. Entries
-  // after the terminator have no meaning and may or may not also be null.
-  // The list will be completely empty if call-stack collection is not
-  // enabled.
-  uint64_t call_stack[kActivityCallStackSize];
-
-  // Reference to arbitrary user data within the persistent memory segment
-  // and a unique identifier for it.
-  uint32_t user_data_ref;
-  uint32_t user_data_id;
-
-  // The (enumerated) type of the activity. This defines what fields of the
-  // |data| record are valid.
-  uint8_t activity_type;
-
-  // Padding to ensure that the next member begins on a 64-bit boundary
-  // even on 32-bit builds which ensures inter-operability between CPU
-  // architectures. New fields can be taken from this space.
-  uint8_t padding[7];
-
-  // Information specific to the |activity_type|.
-  ActivityData data;
-
-  static void FillFrom(Activity* activity,
-                       const void* program_counter,
-                       const void* origin,
-                       Type type,
-                       const ActivityData& data);
-};
-
-// This class manages arbitrary user data that can be associated with activities
-// done by a thread by supporting key/value pairs of any type. This can provide
-// additional information during debugging. It is also used to store arbitrary
-// global data. All updates must be done from the same thread though other
-// threads can read it concurrently if they create new objects using the same
-// memory.
-class BASE_EXPORT ActivityUserData {
- public:
-  // List of known value type. REFERENCE types must immediately follow the non-
-  // external types.
-  enum ValueType : uint8_t {
-    END_OF_VALUES = 0,
-    RAW_VALUE,
-    RAW_VALUE_REFERENCE,
-    STRING_VALUE,
-    STRING_VALUE_REFERENCE,
-    CHAR_VALUE,
-    BOOL_VALUE,
-    SIGNED_VALUE,
-    UNSIGNED_VALUE,
-  };
-
-  class BASE_EXPORT TypedValue {
-   public:
-    TypedValue();
-    TypedValue(const TypedValue& other);
-    ~TypedValue();
-
-    ValueType type() const { return type_; }
-
-    // These methods return the extracted value in the correct format.
-    StringPiece Get() const;
-    StringPiece GetString() const;
-    bool GetBool() const;
-    char GetChar() const;
-    int64_t GetInt() const;
-    uint64_t GetUint() const;
-
-    // These methods return references to process memory as originally provided
-    // to corresponding Set calls. USE WITH CAUTION! There is no guarantee that
-    // the referenced memory is assessible or useful.  It's possible that:
-    //  - the memory was free'd and reallocated for a different purpose
-    //  - the memory has been released back to the OS
-    //  - the memory belongs to a different process's address space
-    // Dereferencing the returned StringPiece when the memory is not accessible
-    // will cause the program to SEGV!
-    StringPiece GetReference() const;
-    StringPiece GetStringReference() const;
-
-   private:
-    friend class ActivityUserData;
-
-    ValueType type_ = END_OF_VALUES;
-    uint64_t short_value_;    // Used to hold copy of numbers, etc.
-    std::string long_value_;  // Used to hold copy of raw/string data.
-    StringPiece ref_value_;   // Used to hold reference to external data.
-  };
-
-  using Snapshot = std::map<std::string, TypedValue>;
-
-  // Initialize the object either as a "sink" that just accepts and discards
-  // data or an active one that writes to a given (zeroed) memory block.
-  ActivityUserData();
-  ActivityUserData(void* memory, size_t size, int64_t pid = 0);
-  virtual ~ActivityUserData();
-
-  // Gets the unique ID number for this user data. If this changes then the
-  // contents have been overwritten by another thread. The return value is
-  // always non-zero unless it's actually just a data "sink".
-  uint32_t id() const {
-    return header_ ? header_->owner.data_id.load(std::memory_order_relaxed) : 0;
-  }
-
-  // Writes a |value| (as part of a key/value pair) that will be included with
-  // the activity in any reports. The same |name| can be written multiple times
-  // with each successive call overwriting the previously stored |value|. For
-  // raw and string values, the maximum size of successive writes is limited by
-  // the first call. The length of "name" is limited to 255 characters.
-  //
-  // This information is stored on a "best effort" basis. It may be dropped if
-  // the memory buffer is full or the associated activity is beyond the maximum
-  // recording depth.
-  void Set(StringPiece name, const void* memory, size_t size) {
-    Set(name, RAW_VALUE, memory, size);
-  }
-  void SetString(StringPiece name, StringPiece value) {
-    Set(name, STRING_VALUE, value.data(), value.length());
-  }
-  void SetString(StringPiece name, StringPiece16 value) {
-    SetString(name, UTF16ToUTF8(value));
-  }
-  void SetBool(StringPiece name, bool value) {
-    char cvalue = value ? 1 : 0;
-    Set(name, BOOL_VALUE, &cvalue, sizeof(cvalue));
-  }
-  void SetChar(StringPiece name, char value) {
-    Set(name, CHAR_VALUE, &value, sizeof(value));
-  }
-  void SetInt(StringPiece name, int64_t value) {
-    Set(name, SIGNED_VALUE, &value, sizeof(value));
-  }
-  void SetUint(StringPiece name, uint64_t value) {
-    Set(name, UNSIGNED_VALUE, &value, sizeof(value));
-  }
-
-  // These function as above but don't actually copy the data into the
-  // persistent memory. They store unaltered pointers along with a size. These
-  // can be used in conjuction with a memory dump to find certain large pieces
-  // of information.
-  void SetReference(StringPiece name, const void* memory, size_t size) {
-    SetReference(name, RAW_VALUE_REFERENCE, memory, size);
-  }
-  void SetStringReference(StringPiece name, StringPiece value) {
-    SetReference(name, STRING_VALUE_REFERENCE, value.data(), value.length());
-  }
-
-  // Creates a snapshot of the key/value pairs contained within. The returned
-  // data will be fixed, independent of whatever changes afterward. There is
-  // some protection against concurrent modification. This will return false
-  // if the data is invalid or if a complete overwrite of the contents is
-  // detected.
-  bool CreateSnapshot(Snapshot* output_snapshot) const;
-
-  // Gets the base memory address used for storing data.
-  const void* GetBaseAddress() const;
-
-  // Explicitly sets the process ID.
-  void SetOwningProcessIdForTesting(int64_t pid, int64_t stamp);
-
-  // Gets the associated process ID, in native form, and the creation timestamp
-  // from tracker memory without loading the entire structure for analysis. This
-  // will return false if no valid process ID is available.
-  static bool GetOwningProcessId(const void* memory,
-                                 int64_t* out_id,
-                                 int64_t* out_stamp);
-
- protected:
-  virtual void Set(StringPiece name,
-                   ValueType type,
-                   const void* memory,
-                   size_t size);
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(ActivityTrackerTest, UserDataTest);
-
-  enum : size_t { kMemoryAlignment = sizeof(uint64_t) };
-
-  // A structure that defines the structure header in memory.
-  struct MemoryHeader {
-    MemoryHeader();
-    ~MemoryHeader();
-
-    OwningProcess owner;  // Information about the creating process.
-  };
-
-  // Header to a key/value record held in persistent memory.
-  struct FieldHeader {
-    FieldHeader();
-    ~FieldHeader();
-
-    std::atomic<uint8_t> type;         // Encoded ValueType
-    uint8_t name_size;                 // Length of "name" key.
-    std::atomic<uint16_t> value_size;  // Actual size of of the stored value.
-    uint16_t record_size;              // Total storage of name, value, header.
-  };
-
-  // A structure used to reference data held outside of persistent memory.
-  struct ReferenceRecord {
-    uint64_t address;
-    uint64_t size;
-  };
-
-  // This record is used to hold known value is a map so that they can be
-  // found and overwritten later.
-  struct ValueInfo {
-    ValueInfo();
-    ValueInfo(ValueInfo&&);
-    ~ValueInfo();
-
-    StringPiece name;                 // The "key" of the record.
-    ValueType type;                   // The type of the value.
-    void* memory;                     // Where the "value" is held.
-    std::atomic<uint16_t>* size_ptr;  // Address of the actual size of value.
-    size_t extent;                    // The total storage of the value,
-  };                                  // typically rounded up for alignment.
-
-  void SetReference(StringPiece name,
-                    ValueType type,
-                    const void* memory,
-                    size_t size);
-
-  // Loads any data already in the memory segment. This allows for accessing
-  // records created previously. If this detects that the underlying data has
-  // gone away (cleared by another thread/process), it will invalidate all the
-  // data in this object and turn it into simple "sink" with no values to
-  // return.
-  void ImportExistingData() const;
-
-  // A map of all the values within the memory block, keyed by name for quick
-  // updates of the values. This is "mutable" because it changes on "const"
-  // objects even when the actual data values can't change.
-  mutable std::map<StringPiece, ValueInfo> values_;
-
-  // Information about the memory block in which new data can be stored. These
-  // are "mutable" because they change even on "const" objects that are just
-  // skipping already set values.
-  mutable char* memory_;
-  mutable size_t available_;
-
-  // A pointer to the memory header for this instance.
-  MemoryHeader* const header_;
-
-  // These hold values used when initially creating the object. They are
-  // compared against current header values to check for outside changes.
-  const uint32_t orig_data_id;
-  const int64_t orig_process_id;
-  const int64_t orig_create_stamp;
-
-  DISALLOW_COPY_AND_ASSIGN(ActivityUserData);
-};
-
-// This class manages tracking a stack of activities for a single thread in
-// a persistent manner, implementing a bounded-size stack in a fixed-size
-// memory allocation. In order to support an operational mode where another
-// thread is analyzing this data in real-time, atomic operations are used
-// where necessary to guarantee a consistent view from the outside.
-//
-// This class is not generally used directly but instead managed by the
-// GlobalActivityTracker instance and updated using Scoped*Activity local
-// objects.
-class BASE_EXPORT ThreadActivityTracker {
- public:
-  using ActivityId = uint32_t;
-
-  // This structure contains all the common information about the thread so
-  // it doesn't have to be repeated in every entry on the stack. It is defined
-  // and used completely within the .cc file.
-  struct Header;
-
-  // This structure holds a copy of all the internal data at the moment the
-  // "snapshot" operation is done. It is disconnected from the live tracker
-  // so that continued operation of the thread will not cause changes here.
-  struct BASE_EXPORT Snapshot {
-    // Explicit constructor/destructor are needed because of complex types
-    // with non-trivial default constructors and destructors.
-    Snapshot();
-    ~Snapshot();
-
-    // The name of the thread as set when it was created. The name may be
-    // truncated due to internal length limitations.
-    std::string thread_name;
-
-    // The timestamp at which this process was created.
-    int64_t create_stamp;
-
-    // The process and thread IDs. These values have no meaning other than
-    // they uniquely identify a running process and a running thread within
-    // that process.  Thread-IDs can be re-used across different processes
-    // and both can be re-used after the process/thread exits.
-    int64_t process_id = 0;
-    int64_t thread_id = 0;
-
-    // The current stack of activities that are underway for this thread. It
-    // is limited in its maximum size with later entries being left off.
-    std::vector<Activity> activity_stack;
-
-    // The current total depth of the activity stack, including those later
-    // entries not recorded in the |activity_stack| vector.
-    uint32_t activity_stack_depth = 0;
-
-    // The last recorded "exception" activity.
-    Activity last_exception;
-  };
-
-  // This is the base class for having the compiler manage an activity on the
-  // tracker's stack. It does nothing but call methods on the passed |tracker|
-  // if it is not null, making it safe (and cheap) to create these objects
-  // even if activity tracking is not enabled.
-  class BASE_EXPORT ScopedActivity {
-   public:
-    ScopedActivity(ThreadActivityTracker* tracker,
-                   const void* program_counter,
-                   const void* origin,
-                   Activity::Type type,
-                   const ActivityData& data);
-    ~ScopedActivity();
-
-    // Changes some basic metadata about the activity.
-    void ChangeTypeAndData(Activity::Type type, const ActivityData& data);
-
-   protected:
-    // The thread tracker to which this object reports. It can be null if
-    // activity tracking is not (yet) enabled.
-    ThreadActivityTracker* const tracker_;
-
-    // An identifier that indicates a specific activity on the stack.
-    ActivityId activity_id_;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(ScopedActivity);
-  };
-
-  // A ThreadActivityTracker runs on top of memory that is managed externally.
-  // It must be large enough for the internal header and a few Activity
-  // blocks. See SizeForStackDepth().
-  ThreadActivityTracker(void* base, size_t size);
-  virtual ~ThreadActivityTracker();
-
-  // Indicates that an activity has started from a given |origin| address in
-  // the code, though it can be null if the creator's address is not known.
-  // The |type| and |data| describe the activity. |program_counter| should be
-  // the result of GetProgramCounter() where push is called. Returned is an
-  // ID that can be used to adjust the pushed activity.
-  ActivityId PushActivity(const void* program_counter,
-                          const void* origin,
-                          Activity::Type type,
-                          const ActivityData& data);
-
-  // An inlined version of the above that gets the program counter where it
-  // is called.
-  ALWAYS_INLINE
-  ActivityId PushActivity(const void* origin,
-                          Activity::Type type,
-                          const ActivityData& data) {
-    return PushActivity(GetProgramCounter(), origin, type, data);
-  }
-
-  // Changes the activity |type| and |data| of the top-most entry on the stack.
-  // This is useful if the information has changed and it is desireable to
-  // track that change without creating a new stack entry. If the type is
-  // ACT_NULL or the data is kNullActivityData then that value will remain
-  // unchanged. The type, if changed, must remain in the same category.
-  // Changing both is not atomic so a snapshot operation could occur between
-  // the update of |type| and |data| or between update of |data| fields.
-  void ChangeActivity(ActivityId id,
-                      Activity::Type type,
-                      const ActivityData& data);
-
-  // Indicates that an activity has completed.
-  void PopActivity(ActivityId id);
-
-  // Sets the user-data information for an activity.
-  std::unique_ptr<ActivityUserData> GetUserData(
-      ActivityId id,
-      ActivityTrackerMemoryAllocator* allocator);
-
-  // Returns if there is true use-data associated with a given ActivityId since
-  // it's possible than any returned object is just a sink.
-  bool HasUserData(ActivityId id);
-
-  // Release the user-data information for an activity.
-  void ReleaseUserData(ActivityId id,
-                       ActivityTrackerMemoryAllocator* allocator);
-
-  // Save an exception. |origin| is the location of the exception.
-  void RecordExceptionActivity(const void* program_counter,
-                               const void* origin,
-                               Activity::Type type,
-                               const ActivityData& data);
-
-  // Returns whether the current data is valid or not. It is not valid if
-  // corruption has been detected in the header or other data structures.
-  bool IsValid() const;
-
-  // Gets a copy of the tracker contents for analysis. Returns false if a
-  // snapshot was not possible, perhaps because the data is not valid; the
-  // contents of |output_snapshot| are undefined in that case. The current
-  // implementation does not support concurrent snapshot operations.
-  bool CreateSnapshot(Snapshot* output_snapshot) const;
-
-  // Gets the base memory address used for storing data.
-  const void* GetBaseAddress();
-
-  // Access the "data version" value so tests can determine if an activity
-  // was pushed and popped in a single call.
-  uint32_t GetDataVersionForTesting();
-
-  // Explicitly sets the process ID.
-  void SetOwningProcessIdForTesting(int64_t pid, int64_t stamp);
-
-  // Gets the associated process ID, in native form, and the creation timestamp
-  // from tracker memory without loading the entire structure for analysis. This
-  // will return false if no valid process ID is available.
-  static bool GetOwningProcessId(const void* memory,
-                                 int64_t* out_id,
-                                 int64_t* out_stamp);
-
-  // Calculates the memory size required for a given stack depth, including
-  // the internal header structure for the stack.
-  static size_t SizeForStackDepth(int stack_depth);
-
- private:
-  friend class ActivityTrackerTest;
-
-  bool CalledOnValidThread();
-
-  std::unique_ptr<ActivityUserData> CreateUserDataForActivity(
-      Activity* activity,
-      ActivityTrackerMemoryAllocator* allocator);
-
-  Header* const header_;        // Pointer to the Header structure.
-  Activity* const stack_;       // The stack of activities.
-
-#if DCHECK_IS_ON()
-  // The ActivityTracker is thread bound, and will be invoked across all the
-  // sequences that run on the thread. A ThreadChecker does not work here, as it
-  // asserts on running in the same sequence each time.
-  const PlatformThreadRef thread_id_;  // The thread this instance is bound to.
-#endif
-  const uint32_t stack_slots_;  // The total number of stack slots.
-
-  bool valid_ = false;          // Tracks whether the data is valid or not.
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadActivityTracker);
-};
-
-
-// The global tracker manages all the individual thread trackers. Memory for
-// the thread trackers is taken from a PersistentMemoryAllocator which allows
-// for the data to be analyzed by a parallel process or even post-mortem.
-class BASE_EXPORT GlobalActivityTracker {
- public:
-  // Type identifiers used when storing in persistent memory so they can be
-  // identified during extraction; the first 4 bytes of the SHA1 of the name
-  // is used as a unique integer. A "version number" is added to the base
-  // so that, if the structure of that object changes, stored older versions
-  // will be safely ignored. These are public so that an external process
-  // can recognize records of this type within an allocator.
-  enum : uint32_t {
-    kTypeIdActivityTracker = 0x5D7381AF + 4,   // SHA1(ActivityTracker) v4
-    kTypeIdUserDataRecord = 0x615EDDD7 + 3,    // SHA1(UserDataRecord) v3
-    kTypeIdGlobalLogMessage = 0x4CF434F9 + 1,  // SHA1(GlobalLogMessage) v1
-    kTypeIdProcessDataRecord = kTypeIdUserDataRecord + 0x100,
-
-    kTypeIdActivityTrackerFree = ~kTypeIdActivityTracker,
-    kTypeIdUserDataRecordFree = ~kTypeIdUserDataRecord,
-    kTypeIdProcessDataRecordFree = ~kTypeIdProcessDataRecord,
-  };
-
-  // An enumeration of common process life stages. All entries are given an
-  // explicit number so they are known and remain constant; this allows for
-  // cross-version analysis either locally or on a server.
-  enum ProcessPhase : int {
-    // The phases are generic and may have meaning to the tracker.
-    PROCESS_PHASE_UNKNOWN = 0,
-    PROCESS_LAUNCHED = 1,
-    PROCESS_LAUNCH_FAILED = 2,
-    PROCESS_EXITED_CLEANLY = 10,
-    PROCESS_EXITED_WITH_CODE = 11,
-
-    // Add here whatever is useful for analysis.
-    PROCESS_SHUTDOWN_STARTED = 100,
-    PROCESS_MAIN_LOOP_STARTED = 101,
-  };
-
-  // A callback made when a process exits to allow immediate analysis of its
-  // data. Note that the system may reuse the |process_id| so when fetching
-  // records it's important to ensure that what is returned was created before
-  // the |exit_stamp|. Movement of |process_data| information is allowed.
-  using ProcessExitCallback =
-      Callback<void(int64_t process_id,
-                    int64_t exit_stamp,
-                    int exit_code,
-                    ProcessPhase exit_phase,
-                    std::string&& command_line,
-                    ActivityUserData::Snapshot&& process_data)>;
-
-  // This structure contains information about a loaded module, as shown to
-  // users of the tracker.
-  struct BASE_EXPORT ModuleInfo {
-    ModuleInfo();
-    ModuleInfo(ModuleInfo&& rhs);
-    ModuleInfo(const ModuleInfo& rhs);
-    ~ModuleInfo();
-
-    ModuleInfo& operator=(ModuleInfo&& rhs);
-    ModuleInfo& operator=(const ModuleInfo& rhs);
-
-    // Information about where and when the module was loaded/unloaded.
-    bool is_loaded = false;  // Was the last operation a load or unload?
-    uintptr_t address = 0;   // Address of the last load operation.
-    int64_t load_time = 0;   // Time of last change; set automatically.
-
-    // Information about the module itself. These never change no matter how
-    // many times a module may be loaded and unloaded.
-    size_t size = 0;         // The size of the loaded module.
-    uint32_t timestamp = 0;  // Opaque "timestamp" for the module.
-    uint32_t age = 0;        // Opaque "age" for the module.
-    uint8_t identifier[16];  // Opaque identifier (GUID, etc.) for the module.
-    std::string file;        // The full path to the file. (UTF-8)
-    std::string debug_file;  // The full path to the debug file.
-  };
-
-  // This is a thin wrapper around the thread-tracker's ScopedActivity that
-  // allows thread-safe access to data values. It is safe to use even if
-  // activity tracking is not enabled.
-  class BASE_EXPORT ScopedThreadActivity
-      : public ThreadActivityTracker::ScopedActivity {
-   public:
-    ScopedThreadActivity(const void* program_counter,
-                         const void* origin,
-                         Activity::Type type,
-                         const ActivityData& data,
-                         bool lock_allowed);
-    ~ScopedThreadActivity();
-
-    // Returns an object for manipulating user data.
-    ActivityUserData& user_data();
-
-   private:
-    // Gets (or creates) a tracker for the current thread. If locking is not
-    // allowed (because a lock is being tracked which would cause recursion)
-    // then the attempt to create one if none found will be skipped. Once
-    // the tracker for this thread has been created for other reasons, locks
-    // will be tracked. The thread-tracker uses locks.
-    static ThreadActivityTracker* GetOrCreateTracker(bool lock_allowed) {
-      GlobalActivityTracker* global_tracker = Get();
-      if (!global_tracker)
-        return nullptr;
-
-      // It is not safe to use TLS once TLS has been destroyed. This can happen
-      // if code that runs late during thread destruction tries to use a
-      // base::Lock. See https://crbug.com/864589.
-      if (base::ThreadLocalStorage::HasBeenDestroyed())
-        return nullptr;
-
-      if (lock_allowed)
-        return global_tracker->GetOrCreateTrackerForCurrentThread();
-      else
-        return global_tracker->GetTrackerForCurrentThread();
-    }
-
-    // An object that manages additional user data, created only upon request.
-    std::unique_ptr<ActivityUserData> user_data_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedThreadActivity);
-  };
-
-  ~GlobalActivityTracker();
-
-  // Creates a global tracker using a given persistent-memory |allocator| and
-  // providing the given |stack_depth| to each thread tracker it manages. The
-  // created object is activated so tracking will begin immediately upon return.
-  // The |process_id| can be zero to get it from the OS but is taken for testing
-  // purposes.
-  static void CreateWithAllocator(
-      std::unique_ptr<PersistentMemoryAllocator> allocator,
-      int stack_depth,
-      int64_t process_id);
-
-#if !defined(OS_NACL)
-  // Like above but internally creates an allocator around a disk file with
-  // the specified |size| at the given |file_path|. Any existing file will be
-  // overwritten. The |id| and |name| are arbitrary and stored in the allocator
-  // for reference by whatever process reads it. Returns true if successful.
-  static bool CreateWithFile(const FilePath& file_path,
-                             size_t size,
-                             uint64_t id,
-                             StringPiece name,
-                             int stack_depth);
-#endif  // !defined(OS_NACL)
-
-  // Like above but internally creates an allocator using local heap memory of
-  // the specified size. This is used primarily for unit tests. The |process_id|
-  // can be zero to get it from the OS but is taken for testing purposes.
-  static bool CreateWithLocalMemory(size_t size,
-                                    uint64_t id,
-                                    StringPiece name,
-                                    int stack_depth,
-                                    int64_t process_id);
-
-  // Like above but internally creates an allocator using a shared-memory
-  // segment. The segment must already be mapped into the local memory space.
-  static bool CreateWithSharedMemory(std::unique_ptr<SharedMemory> shm,
-                                     uint64_t id,
-                                     StringPiece name,
-                                     int stack_depth);
-
-  // Like above but takes a handle to an existing shared memory segment and
-  // maps it before creating the tracker.
-  static bool CreateWithSharedMemoryHandle(const SharedMemoryHandle& handle,
-                                           size_t size,
-                                           uint64_t id,
-                                           StringPiece name,
-                                           int stack_depth);
-
-  // Gets the global activity-tracker or null if none exists.
-  static GlobalActivityTracker* Get() {
-    return reinterpret_cast<GlobalActivityTracker*>(
-        subtle::Acquire_Load(&g_tracker_));
-  }
-
-  // Sets the global activity-tracker for testing purposes.
-  static void SetForTesting(std::unique_ptr<GlobalActivityTracker> tracker);
-
-  // This access to the persistent allocator is only for testing; it extracts
-  // the global tracker completely. All tracked threads must exit before
-  // calling this. Tracking for the current thread will be automatically
-  // stopped.
-  static std::unique_ptr<GlobalActivityTracker> ReleaseForTesting();
-
-  // Convenience method for determining if a global tracker is active.
-  static bool IsEnabled() { return Get() != nullptr; }
-
-  // Gets the persistent-memory-allocator in which data is stored. Callers
-  // can store additional records here to pass more information to the
-  // analysis process.
-  PersistentMemoryAllocator* allocator() { return allocator_.get(); }
-
-  // Gets the thread's activity-tracker if it exists. This is inline for
-  // performance reasons and it uses thread-local-storage (TLS) so that there
-  // is no significant lookup time required to find the one for the calling
-  // thread. Ownership remains with the global tracker.
-  ThreadActivityTracker* GetTrackerForCurrentThread() {
-    return reinterpret_cast<ThreadActivityTracker*>(this_thread_tracker_.Get());
-  }
-
-  // Gets the thread's activity-tracker or creates one if none exists. This
-  // is inline for performance reasons. Ownership remains with the global
-  // tracker.
-  ThreadActivityTracker* GetOrCreateTrackerForCurrentThread() {
-    ThreadActivityTracker* tracker = GetTrackerForCurrentThread();
-    if (tracker)
-      return tracker;
-    return CreateTrackerForCurrentThread();
-  }
-
-  // Creates an activity-tracker for the current thread.
-  ThreadActivityTracker* CreateTrackerForCurrentThread();
-
-  // Releases the activity-tracker for the current thread (for testing only).
-  void ReleaseTrackerForCurrentThreadForTesting();
-
-  // Sets a task-runner that can be used for background work.
-  void SetBackgroundTaskRunner(const scoped_refptr<TaskRunner>& runner);
-
-  // Sets an optional callback to be called when a process exits.
-  void SetProcessExitCallback(ProcessExitCallback callback);
-
-  // Manages process lifetimes. These are called by the process that launched
-  // and reaped the subprocess, not the subprocess itself. If it is expensive
-  // to generate the parameters, Get() the global tracker and call these
-  // conditionally rather than using the static versions.
-  void RecordProcessLaunch(ProcessId process_id,
-                           const FilePath::StringType& cmd);
-  void RecordProcessLaunch(ProcessId process_id,
-                           const FilePath::StringType& exe,
-                           const FilePath::StringType& args);
-  void RecordProcessExit(ProcessId process_id, int exit_code);
-  static void RecordProcessLaunchIfEnabled(ProcessId process_id,
-                                           const FilePath::StringType& cmd) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->RecordProcessLaunch(process_id, cmd);
-  }
-  static void RecordProcessLaunchIfEnabled(ProcessId process_id,
-                                           const FilePath::StringType& exe,
-                                           const FilePath::StringType& args) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->RecordProcessLaunch(process_id, exe, args);
-  }
-  static void RecordProcessExitIfEnabled(ProcessId process_id, int exit_code) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->RecordProcessExit(process_id, exit_code);
-  }
-
-  // Sets the "phase" of the current process, useful for knowing what it was
-  // doing when it last reported.
-  void SetProcessPhase(ProcessPhase phase);
-  static void SetProcessPhaseIfEnabled(ProcessPhase phase) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->SetProcessPhase(phase);
-  }
-
-  // Records a log message. The current implementation does NOT recycle these
-  // only store critical messages such as FATAL ones.
-  void RecordLogMessage(StringPiece message);
-  static void RecordLogMessageIfEnabled(StringPiece message) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->RecordLogMessage(message);
-  }
-
-  // Records a module load/unload event. This is safe to call multiple times
-  // even with the same information.
-  void RecordModuleInfo(const ModuleInfo& info);
-  static void RecordModuleInfoIfEnabled(const ModuleInfo& info) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->RecordModuleInfo(info);
-  }
-
-  // Record field trial information. This call is thread-safe. In addition to
-  // this, construction of a GlobalActivityTracker will cause all existing
-  // active field trials to be fetched and recorded.
-  void RecordFieldTrial(const std::string& trial_name, StringPiece group_name);
-  static void RecordFieldTrialIfEnabled(const std::string& trial_name,
-                                        StringPiece group_name) {
-    GlobalActivityTracker* tracker = Get();
-    if (tracker)
-      tracker->RecordFieldTrial(trial_name, group_name);
-  }
-
-  // Record exception information for the current thread.
-  ALWAYS_INLINE
-  void RecordException(const void* origin, uint32_t code) {
-    return RecordExceptionImpl(GetProgramCounter(), origin, code);
-  }
-  void RecordException(const void* pc, const void* origin, uint32_t code);
-
-  // Marks the tracked data as deleted.
-  void MarkDeleted();
-
-  // Gets the process ID used for tracking. This is typically the same as what
-  // the OS thinks is the current process but can be overridden for testing.
-  int64_t process_id() { return process_id_; }
-
-  // Accesses the process data record for storing arbitrary key/value pairs.
-  // Updates to this are thread-safe.
-  ActivityUserData& process_data() { return process_data_; }
-
- private:
-  friend class GlobalActivityAnalyzer;
-  friend class ScopedThreadActivity;
-  friend class ActivityTrackerTest;
-
-  enum : int {
-    // The maximum number of threads that can be tracked within a process. If
-    // more than this number run concurrently, tracking of new ones may cease.
-    kMaxThreadCount = 100,
-    kCachedThreadMemories = 10,
-    kCachedUserDataMemories = 10,
-  };
-
-  // A wrapper around ActivityUserData that is thread-safe and thus can be used
-  // in the global scope without the requirement of being called from only one
-  // thread.
-  class ThreadSafeUserData : public ActivityUserData {
-   public:
-    ThreadSafeUserData(void* memory, size_t size, int64_t pid = 0);
-    ~ThreadSafeUserData() override;
-
-   private:
-    void Set(StringPiece name,
-             ValueType type,
-             const void* memory,
-             size_t size) override;
-
-    Lock data_lock_;
-
-    DISALLOW_COPY_AND_ASSIGN(ThreadSafeUserData);
-  };
-
-  // State of a module as stored in persistent memory. This supports a single
-  // loading of a module only. If modules are loaded multiple times at
-  // different addresses, only the last will be recorded and an unload will
-  // not revert to the information of any other addresses.
-  struct BASE_EXPORT ModuleInfoRecord {
-    // SHA1(ModuleInfoRecord): Increment this if structure changes!
-    static constexpr uint32_t kPersistentTypeId = 0x05DB5F41 + 1;
-
-    // Expected size for 32/64-bit check by PersistentMemoryAllocator.
-    static constexpr size_t kExpectedInstanceSize =
-        OwningProcess::kExpectedInstanceSize + 56;
-
-    // The atomic unfortunately makes this a "complex" class on some compilers
-    // and thus requires an out-of-line constructor & destructor even though
-    // they do nothing.
-    ModuleInfoRecord();
-    ~ModuleInfoRecord();
-
-    OwningProcess owner;            // The process that created this record.
-    uint64_t address;               // The base address of the module.
-    uint64_t load_time;             // Time of last load/unload.
-    uint64_t size;                  // The size of the module in bytes.
-    uint32_t timestamp;             // Opaque timestamp of the module.
-    uint32_t age;                   // Opaque "age" associated with the module.
-    uint8_t identifier[16];         // Opaque identifier for the module.
-    std::atomic<uint32_t> changes;  // Number load/unload actions.
-    uint16_t pickle_size;           // The size of the following pickle.
-    uint8_t loaded;                 // Flag if module is loaded or not.
-    char pickle[1];                 // Other strings; may allocate larger.
-
-    // Decodes/encodes storage structure from more generic info structure.
-    bool DecodeTo(GlobalActivityTracker::ModuleInfo* info,
-                  size_t record_size) const;
-    static ModuleInfoRecord* CreateFrom(
-        const GlobalActivityTracker::ModuleInfo& info,
-        PersistentMemoryAllocator* allocator);
-
-    // Updates the core information without changing the encoded strings. This
-    // is useful when a known module changes state (i.e. new load or unload).
-    bool UpdateFrom(const GlobalActivityTracker::ModuleInfo& info);
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(ModuleInfoRecord);
-  };
-
-  // A thin wrapper around the main thread-tracker that keeps additional
-  // information that the global tracker needs to handle joined threads.
-  class ManagedActivityTracker : public ThreadActivityTracker {
-   public:
-    ManagedActivityTracker(PersistentMemoryAllocator::Reference mem_reference,
-                           void* base,
-                           size_t size);
-    ~ManagedActivityTracker() override;
-
-    // The reference into persistent memory from which the thread-tracker's
-    // memory was created.
-    const PersistentMemoryAllocator::Reference mem_reference_;
-
-    // The physical address used for the thread-tracker's memory.
-    void* const mem_base_;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(ManagedActivityTracker);
-  };
-
-  // Creates a global tracker using a given persistent-memory |allocator| and
-  // providing the given |stack_depth| to each thread tracker it manages. The
-  // created object is activated so tracking has already started upon return.
-  // The |process_id| can be zero to get it from the OS but is taken for testing
-  // purposes.
-  GlobalActivityTracker(std::unique_ptr<PersistentMemoryAllocator> allocator,
-                        int stack_depth,
-                        int64_t process_id);
-
-  // Returns the memory used by an activity-tracker managed by this class.
-  // It is called during the destruction of a ManagedActivityTracker object.
-  void ReturnTrackerMemory(ManagedActivityTracker* tracker);
-
-  // Records exception information.
-  void RecordExceptionImpl(const void* pc, const void* origin, uint32_t code);
-
-  // Releases the activity-tracker associcated with thread. It is called
-  // automatically when a thread is joined and thus there is nothing more to
-  // be tracked. |value| is a pointer to a ManagedActivityTracker.
-  static void OnTLSDestroy(void* value);
-
-  // Does process-exit work. This can be run on any thread.
-  void CleanupAfterProcess(int64_t process_id,
-                           int64_t exit_stamp,
-                           int exit_code,
-                           std::string&& command_line);
-
-  // The persistent-memory allocator from which the memory for all trackers
-  // is taken.
-  std::unique_ptr<PersistentMemoryAllocator> allocator_;
-
-  // The size (in bytes) of memory required by a ThreadActivityTracker to
-  // provide the stack-depth requested during construction.
-  const size_t stack_memory_size_;
-
-  // The process-id of the current process. This is kept as a member variable,
-  // defined during initialization, for testing purposes.
-  const int64_t process_id_;
-
-  // The activity tracker for the currently executing thread.
-  ThreadLocalStorage::Slot this_thread_tracker_;
-
-  // The number of thread trackers currently active.
-  std::atomic<int> thread_tracker_count_;
-
-  // A caching memory allocator for thread-tracker objects.
-  ActivityTrackerMemoryAllocator thread_tracker_allocator_;
-  Lock thread_tracker_allocator_lock_;
-
-  // A caching memory allocator for user data attached to activity data.
-  ActivityTrackerMemoryAllocator user_data_allocator_;
-  Lock user_data_allocator_lock_;
-
-  // An object for holding arbitrary key value pairs with thread-safe access.
-  ThreadSafeUserData process_data_;
-
-  // A map of global module information, keyed by module path.
-  std::map<const std::string, ModuleInfoRecord*> modules_;
-  Lock modules_lock_;
-
-  // The active global activity tracker.
-  static subtle::AtomicWord g_tracker_;
-
-  // A lock that is used to protect access to the following fields.
-  Lock global_tracker_lock_;
-
-  // The collection of processes being tracked and their command-lines.
-  std::map<int64_t, std::string> known_processes_;
-
-  // A task-runner that can be used for doing background processing.
-  scoped_refptr<TaskRunner> background_task_runner_;
-
-  // A callback performed when a subprocess exits, including its exit-code
-  // and the phase it was in when that occurred. This will be called via
-  // the |background_task_runner_| if one is set or whatever thread reaped
-  // the process otherwise.
-  ProcessExitCallback process_exit_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(GlobalActivityTracker);
-};
-
-
-// Record entry in to and out of an arbitrary block of code.
-class BASE_EXPORT ScopedActivity
-    : public GlobalActivityTracker::ScopedThreadActivity {
- public:
-  // Track activity at the specified FROM_HERE location for an arbitrary
-  // 4-bit |action|, an arbitrary 32-bit |id|, and 32-bits of arbitrary
-  // |info|. None of these values affect operation; they're all purely
-  // for association and analysis. To have unique identifiers across a
-  // diverse code-base, create the number by taking the first 8 characters
-  // of the hash of the activity being tracked.
-  //
-  // For example:
-  //   Tracking method: void MayNeverExit(uint32_t foo) {...}
-  //   echo -n "MayNeverExit" | sha1sum   =>   e44873ccab21e2b71270da24aa1...
-  //
-  //   void MayNeverExit(int32_t foo) {
-  //     base::debug::ScopedActivity track_me(0, 0xE44873CC, foo);
-  //     ...
-  //   }
-  ALWAYS_INLINE
-  ScopedActivity(uint8_t action, uint32_t id, int32_t info)
-      : ScopedActivity(GetProgramCounter(), action, id, info) {}
-  ScopedActivity() : ScopedActivity(0, 0, 0) {}
-
-  // Changes the |action| and/or |info| of this activity on the stack. This
-  // is useful for tracking progress through a function, updating the action
-  // to indicate "milestones" in the block (max 16 milestones: 0-15) or the
-  // info to reflect other changes. Changing both is not atomic so a snapshot
-  // operation could occur between the update of |action| and |info|.
-  void ChangeAction(uint8_t action);
-  void ChangeInfo(int32_t info);
-  void ChangeActionAndInfo(uint8_t action, int32_t info);
-
- private:
-  // Constructs the object using a passed-in program-counter.
-  ScopedActivity(const void* program_counter,
-                 uint8_t action,
-                 uint32_t id,
-                 int32_t info);
-
-  // A copy of the ID code so it doesn't have to be passed by the caller when
-  // changing the |info| field.
-  uint32_t id_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedActivity);
-};
-
-
-// These "scoped" classes provide easy tracking of various blocking actions.
-
-class BASE_EXPORT ScopedTaskRunActivity
-    : public GlobalActivityTracker::ScopedThreadActivity {
- public:
-  ALWAYS_INLINE
-  explicit ScopedTaskRunActivity(const PendingTask& task)
-      : ScopedTaskRunActivity(GetProgramCounter(), task) {}
-
- private:
-  ScopedTaskRunActivity(const void* program_counter, const PendingTask& task);
-  DISALLOW_COPY_AND_ASSIGN(ScopedTaskRunActivity);
-};
-
-class BASE_EXPORT ScopedLockAcquireActivity
-    : public GlobalActivityTracker::ScopedThreadActivity {
- public:
-  ALWAYS_INLINE
-  explicit ScopedLockAcquireActivity(const base::internal::LockImpl* lock)
-      : ScopedLockAcquireActivity(GetProgramCounter(), lock) {}
-
- private:
-  ScopedLockAcquireActivity(const void* program_counter,
-                            const base::internal::LockImpl* lock);
-  DISALLOW_COPY_AND_ASSIGN(ScopedLockAcquireActivity);
-};
-
-class BASE_EXPORT ScopedEventWaitActivity
-    : public GlobalActivityTracker::ScopedThreadActivity {
- public:
-  ALWAYS_INLINE
-  explicit ScopedEventWaitActivity(const WaitableEvent* event)
-      : ScopedEventWaitActivity(GetProgramCounter(), event) {}
-
- private:
-  ScopedEventWaitActivity(const void* program_counter,
-                          const WaitableEvent* event);
-  DISALLOW_COPY_AND_ASSIGN(ScopedEventWaitActivity);
-};
-
-class BASE_EXPORT ScopedThreadJoinActivity
-    : public GlobalActivityTracker::ScopedThreadActivity {
- public:
-  ALWAYS_INLINE
-  explicit ScopedThreadJoinActivity(const PlatformThreadHandle* thread)
-      : ScopedThreadJoinActivity(GetProgramCounter(), thread) {}
-
- private:
-  ScopedThreadJoinActivity(const void* program_counter,
-                           const PlatformThreadHandle* thread);
-  DISALLOW_COPY_AND_ASSIGN(ScopedThreadJoinActivity);
-};
-
-// Some systems don't have base::Process
-#if !defined(OS_NACL) && !defined(OS_IOS)
-class BASE_EXPORT ScopedProcessWaitActivity
-    : public GlobalActivityTracker::ScopedThreadActivity {
- public:
-  ALWAYS_INLINE
-  explicit ScopedProcessWaitActivity(const Process* process)
-      : ScopedProcessWaitActivity(GetProgramCounter(), process) {}
-
- private:
-  ScopedProcessWaitActivity(const void* program_counter,
-                            const Process* process);
-  DISALLOW_COPY_AND_ASSIGN(ScopedProcessWaitActivity);
-};
-#endif
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_ACTIVITY_TRACKER_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/alias.cc b/native/zucchini/vendor/libchrome/base/debug/alias.cc
deleted file mode 100644
index ebc8b5a..0000000
--- a/native/zucchini/vendor/libchrome/base/debug/alias.cc
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/debug/alias.h"
-#include "build/build_config.h"
-
-namespace base {
-namespace debug {
-
-#if defined(COMPILER_MSVC)
-#pragma optimize("", off)
-#elif defined(__clang__)
-#pragma clang optimize off
-#endif
-
-void Alias(const void* var) {
-}
-
-#if defined(COMPILER_MSVC)
-#pragma optimize("", on)
-#elif defined(__clang__)
-#pragma clang optimize on
-#endif
-
-}  // namespace debug
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/debug/alias.h b/native/zucchini/vendor/libchrome/base/debug/alias.h
deleted file mode 100644
index 128fdaa..0000000
--- a/native/zucchini/vendor/libchrome/base/debug/alias.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_DEBUG_ALIAS_H_
-#define BASE_DEBUG_ALIAS_H_
-
-#include "base/base_export.h"
-#include "base/strings/string_util.h"
-
-namespace base {
-namespace debug {
-
-// Make the optimizer think that var is aliased. This is to prevent it from
-// optimizing out local variables that would not otherwise be live at the point
-// of a potential crash.
-// base::debug::Alias should only be used for local variables, not globals,
-// object members, or function return values - these must be copied to locals if
-// you want to ensure they are recorded in crash dumps.
-// Note that if the local variable is a pointer then its value will be retained
-// but the memory that it points to will probably not be saved in the crash
-// dump - by default only stack memory is saved. Therefore the aliasing
-// technique is usually only worthwhile with non-pointer variables. If you have
-// a pointer to an object and you want to retain the object's state you need to
-// copy the object or its fields to local variables. Example usage:
-//   int last_error = err_;
-//   base::debug::Alias(&last_error);
-//   DEBUG_ALIAS_FOR_CSTR(name_copy, p->name, 16);
-//   CHECK(false);
-void BASE_EXPORT Alias(const void* var);
-
-}  // namespace debug
-}  // namespace base
-
-// Convenience macro that copies the null-terminated string from |c_str| into a
-// stack-allocated char array named |var_name| that holds up to |char_count|
-// characters and should be preserved in memory dumps.
-#define DEBUG_ALIAS_FOR_CSTR(var_name, c_str, char_count)  \
-  char var_name[char_count];                               \
-  ::base::strlcpy(var_name, (c_str), arraysize(var_name)); \
-  ::base::debug::Alias(var_name);
-
-#endif  // BASE_DEBUG_ALIAS_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/debugger.h b/native/zucchini/vendor/libchrome/base/debug/debugger.h
deleted file mode 100644
index 8680e28..0000000
--- a/native/zucchini/vendor/libchrome/base/debug/debugger.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This is a cross platform interface for helper functions related to
-// debuggers.  You should use this to test if you're running under a debugger,
-// and if you would like to yield (breakpoint) into the debugger.
-
-#ifndef BASE_DEBUG_DEBUGGER_H_
-#define BASE_DEBUG_DEBUGGER_H_
-
-#include "base/base_export.h"
-
-namespace base {
-namespace debug {
-
-// Waits wait_seconds seconds for a debugger to attach to the current process.
-// When silent is false, an exception is thrown when a debugger is detected.
-BASE_EXPORT bool WaitForDebugger(int wait_seconds, bool silent);
-
-// Returns true if the given process is being run under a debugger.
-//
-// On OS X, the underlying mechanism doesn't work when the sandbox is enabled.
-// To get around this, this function caches its value.
-//
-// WARNING: Because of this, on OS X, a call MUST be made to this function
-// BEFORE the sandbox is enabled.
-BASE_EXPORT bool BeingDebugged();
-
-// Break into the debugger, assumes a debugger is present.
-BASE_EXPORT void BreakDebugger();
-
-// Used in test code, this controls whether showing dialogs and breaking into
-// the debugger is suppressed for debug errors, even in debug mode (normally
-// release mode doesn't do this stuff --  this is controlled separately).
-// Normally UI is not suppressed.  This is normally used when running automated
-// tests where we want a crash rather than a dialog or a debugger.
-BASE_EXPORT void SetSuppressDebugUI(bool suppress);
-BASE_EXPORT bool IsDebugUISuppressed();
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_DEBUGGER_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/debugger_posix.cc b/native/zucchini/vendor/libchrome/base/debug/debugger_posix.cc
deleted file mode 100644
index b62bf01..0000000
--- a/native/zucchini/vendor/libchrome/base/debug/debugger_posix.cc
+++ /dev/null
@@ -1,272 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/debug/debugger.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/param.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <memory>
-#include <vector>
-
-#include "base/macros.h"
-#include "base/threading/platform_thread.h"
-#include "base/time/time.h"
-#include "build/build_config.h"
-
-#if defined(__GLIBCXX__)
-#include <cxxabi.h>
-#endif
-
-#if defined(OS_MACOSX)
-#include <AvailabilityMacros.h>
-#endif
-
-#if defined(OS_MACOSX) || defined(OS_BSD)
-#include <sys/sysctl.h>
-#endif
-
-#if defined(OS_FREEBSD)
-#include <sys/user.h>
-#endif
-
-#include <ostream>
-
-#include "base/debug/alias.h"
-#include "base/logging.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/strings/string_piece.h"
-
-#if defined(USE_SYMBOLIZE)
-#include "base/third_party/symbolize/symbolize.h"
-#endif
-
-#if defined(OS_ANDROID)
-#include "base/threading/platform_thread.h"
-#endif
-
-namespace base {
-namespace debug {
-
-#if defined(OS_MACOSX) || defined(OS_BSD)
-
-// Based on Apple's recommended method as described in
-// http://developer.apple.com/qa/qa2004/qa1361.html
-bool BeingDebugged() {
-  // NOTE: This code MUST be async-signal safe (it's used by in-process
-  // stack dumping signal handler). NO malloc or stdio is allowed here.
-  //
-  // While some code used below may be async-signal unsafe, note how
-  // the result is cached (see |is_set| and |being_debugged| static variables
-  // right below). If this code is properly warmed-up early
-  // in the start-up process, it should be safe to use later.
-
-  // If the process is sandboxed then we can't use the sysctl, so cache the
-  // value.
-  static bool is_set = false;
-  static bool being_debugged = false;
-
-  if (is_set)
-    return being_debugged;
-
-  // Initialize mib, which tells sysctl what info we want.  In this case,
-  // we're looking for information about a specific process ID.
-  int mib[] = {
-    CTL_KERN,
-    KERN_PROC,
-    KERN_PROC_PID,
-    getpid()
-#if defined(OS_OPENBSD)
-    , sizeof(struct kinfo_proc),
-    0
-#endif
-  };
-
-  // Caution: struct kinfo_proc is marked __APPLE_API_UNSTABLE.  The source and
-  // binary interfaces may change.
-  struct kinfo_proc info;
-  size_t info_size = sizeof(info);
-
-#if defined(OS_OPENBSD)
-  if (sysctl(mib, arraysize(mib), NULL, &info_size, NULL, 0) < 0)
-    return -1;
-
-  mib[5] = (info_size / sizeof(struct kinfo_proc));
-#endif
-
-  int sysctl_result = sysctl(mib, arraysize(mib), &info, &info_size, NULL, 0);
-  DCHECK_EQ(sysctl_result, 0);
-  if (sysctl_result != 0) {
-    is_set = true;
-    being_debugged = false;
-    return being_debugged;
-  }
-
-  // This process is being debugged if the P_TRACED flag is set.
-  is_set = true;
-#if defined(OS_FREEBSD)
-  being_debugged = (info.ki_flag & P_TRACED) != 0;
-#elif defined(OS_BSD)
-  being_debugged = (info.p_flag & P_TRACED) != 0;
-#else
-  being_debugged = (info.kp_proc.p_flag & P_TRACED) != 0;
-#endif
-  return being_debugged;
-}
-
-#elif defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_AIX)
-
-// We can look in /proc/self/status for TracerPid.  We are likely used in crash
-// handling, so we are careful not to use the heap or have side effects.
-// Another option that is common is to try to ptrace yourself, but then we
-// can't detach without forking(), and that's not so great.
-// static
-bool BeingDebugged() {
-  // NOTE: This code MUST be async-signal safe (it's used by in-process
-  // stack dumping signal handler). NO malloc or stdio is allowed here.
-
-  int status_fd = open("/proc/self/status", O_RDONLY);
-  if (status_fd == -1)
-    return false;
-
-  // We assume our line will be in the first 1024 characters and that we can
-  // read this much all at once.  In practice this will generally be true.
-  // This simplifies and speeds up things considerably.
-  char buf[1024];
-
-  ssize_t num_read = HANDLE_EINTR(read(status_fd, buf, sizeof(buf)));
-  if (IGNORE_EINTR(close(status_fd)) < 0)
-    return false;
-
-  if (num_read <= 0)
-    return false;
-
-  StringPiece status(buf, num_read);
-  StringPiece tracer("TracerPid:\t");
-
-  StringPiece::size_type pid_index = status.find(tracer);
-  if (pid_index == StringPiece::npos)
-    return false;
-
-  // Our pid is 0 without a debugger, assume this for any pid starting with 0.
-  pid_index += tracer.size();
-  return pid_index < status.size() && status[pid_index] != '0';
-}
-
-#elif defined(OS_FUCHSIA)
-
-bool BeingDebugged() {
-  // TODO(fuchsia): No gdb/gdbserver in the SDK yet.
-  return false;
-}
-
-#else
-
-bool BeingDebugged() {
-  NOTIMPLEMENTED();
-  return false;
-}
-
-#endif
-
-// We want to break into the debugger in Debug mode, and cause a crash dump in
-// Release mode. Breakpad behaves as follows:
-//
-// +-------+-----------------+-----------------+
-// | OS    | Dump on SIGTRAP | Dump on SIGABRT |
-// +-------+-----------------+-----------------+
-// | Linux |       N         |        Y        |
-// | Mac   |       Y         |        N        |
-// +-------+-----------------+-----------------+
-//
-// Thus we do the following:
-// Linux: Debug mode if a debugger is attached, send SIGTRAP; otherwise send
-//        SIGABRT
-// Mac: Always send SIGTRAP.
-
-#if defined(ARCH_CPU_ARMEL)
-#define DEBUG_BREAK_ASM() asm("bkpt 0")
-#elif defined(ARCH_CPU_ARM64)
-#define DEBUG_BREAK_ASM() asm("brk 0")
-#elif defined(ARCH_CPU_MIPS_FAMILY)
-#define DEBUG_BREAK_ASM() asm("break 2")
-#elif defined(ARCH_CPU_X86_FAMILY)
-#define DEBUG_BREAK_ASM() asm("int3")
-#endif
-
-#if defined(NDEBUG) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
-#define DEBUG_BREAK() abort()
-#elif defined(OS_NACL)
-// The NaCl verifier doesn't let use use int3.  For now, we call abort().  We
-// should ask for advice from some NaCl experts about the optimum thing here.
-// http://code.google.com/p/nativeclient/issues/detail?id=645
-#define DEBUG_BREAK() abort()
-#elif !defined(OS_MACOSX)
-// Though Android has a "helpful" process called debuggerd to catch native
-// signals on the general assumption that they are fatal errors. If no debugger
-// is attached, we call abort since Breakpad needs SIGABRT to create a dump.
-// When debugger is attached, for ARM platform the bkpt instruction appears
-// to cause SIGBUS which is trapped by debuggerd, and we've had great
-// difficulty continuing in a debugger once we stop from SIG triggered by native
-// code, use GDB to set |go| to 1 to resume execution; for X86 platform, use
-// "int3" to setup breakpiont and raise SIGTRAP.
-//
-// On other POSIX architectures, except Mac OS X, we use the same logic to
-// ensure that breakpad creates a dump on crashes while it is still possible to
-// use a debugger.
-namespace {
-void DebugBreak() {
-  if (!BeingDebugged()) {
-    abort();
-  } else {
-#if defined(DEBUG_BREAK_ASM)
-    DEBUG_BREAK_ASM();
-#else
-    volatile int go = 0;
-    while (!go) {
-      base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
-    }
-#endif
-  }
-}
-}  // namespace
-#define DEBUG_BREAK() DebugBreak()
-#elif defined(DEBUG_BREAK_ASM)
-#define DEBUG_BREAK() DEBUG_BREAK_ASM()
-#else
-#error "Don't know how to debug break on this architecture/OS"
-#endif
-
-void BreakDebugger() {
-  // NOTE: This code MUST be async-signal safe (it's used by in-process
-  // stack dumping signal handler). NO malloc or stdio is allowed here.
-
-  // Linker's ICF feature may merge this function with other functions with the
-  // same definition (e.g. any function whose sole job is to call abort()) and
-  // it may confuse the crash report processing system. http://crbug.com/508489
-  static int static_variable_to_make_this_function_unique = 0;
-  base::debug::Alias(&static_variable_to_make_this_function_unique);
-
-  DEBUG_BREAK();
-#if defined(OS_ANDROID) && !defined(OFFICIAL_BUILD)
-  // For Android development we always build release (debug builds are
-  // unmanageably large), so the unofficial build is used for debugging. It is
-  // helpful to be able to insert BreakDebugger() statements in the source,
-  // attach the debugger, inspect the state of the program and then resume it by
-  // setting the 'go' variable above.
-#elif defined(NDEBUG)
-  // Terminate the program after signaling the debug break.
-  _exit(1);
-#endif
-}
-
-}  // namespace debug
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/debug/debugging_buildflags.h b/native/zucchini/vendor/libchrome/base/debug/debugging_buildflags.h
deleted file mode 100644
index 33e3dd0..0000000
--- a/native/zucchini/vendor/libchrome/base/debug/debugging_buildflags.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// Generated by build/write_buildflag_header.py
-// From "base_debugging_flags"
-#ifndef BASE_DEBUG_DEBUGGING_FLAGS_H_
-#define BASE_DEBUG_DEBUGGING_FLAGS_H_
-#include "build/buildflag.h"
-#define BUILDFLAG_INTERNAL_ENABLE_PROFILING() (0)
-#define BUILDFLAG_INTERNAL_ENABLE_MEMORY_TASK_PROFILER() (0)
-#define BUILDFLAG_INTERNAL_CAN_UNWIND_WITH_FRAME_POINTERS() (0)
-#define BUILDFLAG_INTERNAL_ENABLE_LOCATION_SOURCE() (0)
-#define BUILDFLAG_INTERNAL_CFI_ENFORCEMENT_TRAP() (0)
-#define BUILDFLAG_INTERNAL_ENABLE_MUTEX_PRIORITY_INHERITANCE() (0)
-#endif  // BASE_DEBUG_DEBUGGING_FLAGS_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/leak_annotations.h b/native/zucchini/vendor/libchrome/base/debug/leak_annotations.h
deleted file mode 100644
index dc50246..0000000
--- a/native/zucchini/vendor/libchrome/base/debug/leak_annotations.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_DEBUG_LEAK_ANNOTATIONS_H_
-#define BASE_DEBUG_LEAK_ANNOTATIONS_H_
-
-#include "base/macros.h"
-#include "build/build_config.h"
-
-// This file defines macros which can be used to annotate intentional memory
-// leaks. Support for annotations is implemented in LeakSanitizer. Annotated
-// objects will be treated as a source of live pointers, i.e. any heap objects
-// reachable by following pointers from an annotated object will not be
-// reported as leaks.
-//
-// ANNOTATE_SCOPED_MEMORY_LEAK: all allocations made in the current scope
-// will be annotated as leaks.
-// ANNOTATE_LEAKING_OBJECT_PTR(X): the heap object referenced by pointer X will
-// be annotated as a leak.
-
-#if defined(LEAK_SANITIZER) && !defined(OS_NACL)
-
-#include <sanitizer/lsan_interface.h>
-
-class ScopedLeakSanitizerDisabler {
- public:
-  ScopedLeakSanitizerDisabler() { __lsan_disable(); }
-  ~ScopedLeakSanitizerDisabler() { __lsan_enable(); }
- private:
-  DISALLOW_COPY_AND_ASSIGN(ScopedLeakSanitizerDisabler);
-};
-
-#define ANNOTATE_SCOPED_MEMORY_LEAK \
-    ScopedLeakSanitizerDisabler leak_sanitizer_disabler; static_cast<void>(0)
-
-#define ANNOTATE_LEAKING_OBJECT_PTR(X) __lsan_ignore_object(X);
-
-#else
-
-#define ANNOTATE_SCOPED_MEMORY_LEAK ((void)0)
-#define ANNOTATE_LEAKING_OBJECT_PTR(X) ((void)0)
-
-#endif
-
-#endif  // BASE_DEBUG_LEAK_ANNOTATIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/proc_maps_linux.h b/native/zucchini/vendor/libchrome/base/debug/proc_maps_linux.h
deleted file mode 100644
index f5f8a59..0000000
--- a/native/zucchini/vendor/libchrome/base/debug/proc_maps_linux.h
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_DEBUG_PROC_MAPS_LINUX_H_
-#define BASE_DEBUG_PROC_MAPS_LINUX_H_
-
-#include <stdint.h>
-
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-
-namespace base {
-namespace debug {
-
-// Describes a region of mapped memory and the path of the file mapped.
-struct MappedMemoryRegion {
-  enum Permission {
-    READ = 1 << 0,
-    WRITE = 1 << 1,
-    EXECUTE = 1 << 2,
-    PRIVATE = 1 << 3,  // If set, region is private, otherwise it is shared.
-  };
-
-  // The address range [start,end) of mapped memory.
-  uintptr_t start;
-  uintptr_t end;
-
-  // Byte offset into |path| of the range mapped into memory.
-  unsigned long long offset;
-
-  // Image base, if this mapping corresponds to an ELF image.
-  uintptr_t base;
-
-  // Bitmask of read/write/execute/private/shared permissions.
-  uint8_t permissions;
-
-  // Name of the file mapped into memory.
-  //
-  // NOTE: path names aren't guaranteed to point at valid files. For example,
-  // "[heap]" and "[stack]" are used to represent the location of the process'
-  // heap and stack, respectively.
-  std::string path;
-};
-
-// Reads the data from /proc/self/maps and stores the result in |proc_maps|.
-// Returns true if successful, false otherwise.
-//
-// There is *NO* guarantee that the resulting contents will be free of
-// duplicates or even contain valid entries by time the method returns.
-//
-//
-// THE GORY DETAILS
-//
-// Did you know it's next-to-impossible to atomically read the whole contents
-// of /proc/<pid>/maps? You would think that if we passed in a large-enough
-// buffer to read() that It Should Just Work(tm), but sadly that's not the case.
-//
-// Linux's procfs uses seq_file [1] for handling iteration, text formatting,
-// and dealing with resulting data that is larger than the size of a page. That
-// last bit is especially important because it means that seq_file will never
-// return more than the size of a page in a single call to read().
-//
-// Unfortunately for a program like Chrome the size of /proc/self/maps is
-// larger than the size of page so we're forced to call read() multiple times.
-// If the virtual memory table changed in any way between calls to read() (e.g.,
-// a different thread calling mprotect()), it can make seq_file generate
-// duplicate entries or skip entries.
-//
-// Even if seq_file was changed to keep flushing the contents of its page-sized
-// buffer to the usermode buffer inside a single call to read(), it has to
-// release its lock on the virtual memory table to handle page faults while
-// copying data to usermode. This puts us in the same situation where the table
-// can change while we're copying data.
-//
-// Alternatives such as fork()-and-suspend-the-parent-while-child-reads were
-// attempted, but they present more subtle problems than it's worth. Depending
-// on your use case your best bet may be to read /proc/<pid>/maps prior to
-// starting other threads.
-//
-// [1] http://kernelnewbies.org/Documents/SeqFileHowTo
-BASE_EXPORT bool ReadProcMaps(std::string* proc_maps);
-
-// Parses /proc/<pid>/maps input data and stores in |regions|. Returns true
-// and updates |regions| if and only if all of |input| was successfully parsed.
-BASE_EXPORT bool ParseProcMaps(const std::string& input,
-                               std::vector<MappedMemoryRegion>* regions);
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_PROC_MAPS_LINUX_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/stack_trace.cc b/native/zucchini/vendor/libchrome/base/debug/stack_trace.cc
deleted file mode 100644
index 7715121..0000000
--- a/native/zucchini/vendor/libchrome/base/debug/stack_trace.cc
+++ /dev/null
@@ -1,277 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/debug/stack_trace.h"
-
-#include <string.h>
-
-#include <algorithm>
-#include <sstream>
-
-#include "base/logging.h"
-#include "base/macros.h"
-
-#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
-
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-#include <pthread.h>
-#include "base/process/process_handle.h"
-#include "base/threading/platform_thread.h"
-#endif
-
-#if defined(OS_MACOSX)
-#include <pthread.h>
-#endif
-
-#if defined(OS_LINUX) && defined(__GLIBC__)
-extern "C" void* __libc_stack_end;
-#endif
-
-#endif  // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
-
-namespace base {
-namespace debug {
-
-namespace {
-
-#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
-
-#if defined(__arm__) && defined(__GNUC__) && !defined(__clang__)
-// GCC and LLVM generate slightly different frames on ARM, see
-// https://llvm.org/bugs/show_bug.cgi?id=18505 - LLVM generates
-// x86-compatible frame, while GCC needs adjustment.
-constexpr size_t kStackFrameAdjustment = sizeof(uintptr_t);
-#else
-constexpr size_t kStackFrameAdjustment = 0;
-#endif
-
-uintptr_t GetNextStackFrame(uintptr_t fp) {
-  return reinterpret_cast<const uintptr_t*>(fp)[0] - kStackFrameAdjustment;
-}
-
-uintptr_t GetStackFramePC(uintptr_t fp) {
-  return reinterpret_cast<const uintptr_t*>(fp)[1];
-}
-
-bool IsStackFrameValid(uintptr_t fp, uintptr_t prev_fp, uintptr_t stack_end) {
-  // With the stack growing downwards, older stack frame must be
-  // at a greater address that the current one.
-  if (fp <= prev_fp) return false;
-
-  // Assume huge stack frames are bogus.
-  if (fp - prev_fp > 100000) return false;
-
-  // Check alignment.
-  if (fp & (sizeof(uintptr_t) - 1)) return false;
-
-  if (stack_end) {
-    // Both fp[0] and fp[1] must be within the stack.
-    if (fp > stack_end - 2 * sizeof(uintptr_t)) return false;
-
-    // Additional check to filter out false positives.
-    if (GetStackFramePC(fp) < 32768) return false;
-  }
-
-  return true;
-};
-
-// ScanStackForNextFrame() scans the stack for a valid frame to allow unwinding
-// past system libraries. Only supported on Linux where system libraries are
-// usually in the middle of the trace:
-//
-//   TraceStackFramePointers
-//   <more frames from Chrome>
-//   base::WorkSourceDispatch   <-- unwinding stops (next frame is invalid),
-//   g_main_context_dispatch        ScanStackForNextFrame() is called
-//   <more frames from glib>
-//   g_main_context_iteration
-//   base::MessagePumpGlib::Run <-- ScanStackForNextFrame() finds valid frame,
-//   base::RunLoop::Run             unwinding resumes
-//   <more frames from Chrome>
-//   __libc_start_main
-//
-// For stack scanning to be efficient it's very important for the thread to
-// be started by Chrome. In that case we naturally terminate unwinding once
-// we reach the origin of the stack (i.e. GetStackEnd()). If the thread is
-// not started by Chrome (e.g. Android's main thread), then we end up always
-// scanning area at the origin of the stack, wasting time and not finding any
-// frames (since Android libraries don't have frame pointers).
-//
-// ScanStackForNextFrame() returns 0 if it couldn't find a valid frame
-// (or if stack scanning is not supported on the current platform).
-uintptr_t ScanStackForNextFrame(uintptr_t fp, uintptr_t stack_end) {
-#if defined(OS_LINUX)
-  // Enough to resume almost all prematurely terminated traces.
-  constexpr size_t kMaxStackScanArea = 8192;
-
-  if (!stack_end) {
-    // Too dangerous to scan without knowing where the stack ends.
-    return 0;
-  }
-
-  fp += sizeof(uintptr_t);  // current frame is known to be invalid
-  uintptr_t last_fp_to_scan = std::min(fp + kMaxStackScanArea, stack_end) -
-                                  sizeof(uintptr_t);
-  for (;fp <= last_fp_to_scan; fp += sizeof(uintptr_t)) {
-    uintptr_t next_fp = GetNextStackFrame(fp);
-    if (IsStackFrameValid(next_fp, fp, stack_end)) {
-      // Check two frames deep. Since stack frame is just a pointer to
-      // a higher address on the stack, it's relatively easy to find
-      // something that looks like one. However two linked frames are
-      // far less likely to be bogus.
-      uintptr_t next2_fp = GetNextStackFrame(next_fp);
-      if (IsStackFrameValid(next2_fp, next_fp, stack_end)) {
-        return fp;
-      }
-    }
-  }
-#endif  // defined(OS_LINUX)
-
-  return 0;
-}
-
-// Links stack frame |fp| to |parent_fp|, so that during stack unwinding
-// TraceStackFramePointers() visits |parent_fp| after visiting |fp|.
-// Both frame pointers must come from __builtin_frame_address().
-// Returns previous stack frame |fp| was linked to.
-void* LinkStackFrames(void* fpp, void* parent_fp) {
-  uintptr_t fp = reinterpret_cast<uintptr_t>(fpp) - kStackFrameAdjustment;
-  void* prev_parent_fp = reinterpret_cast<void**>(fp)[0];
-  reinterpret_cast<void**>(fp)[0] = parent_fp;
-  return prev_parent_fp;
-}
-
-#endif  // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
-
-}  // namespace
-
-#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
-uintptr_t GetStackEnd() {
-#if defined(OS_ANDROID)
-  // Bionic reads proc/maps on every call to pthread_getattr_np() when called
-  // from the main thread. So we need to cache end of stack in that case to get
-  // acceptable performance.
-  // For all other threads pthread_getattr_np() is fast enough as it just reads
-  // values from its pthread_t argument.
-  static uintptr_t main_stack_end = 0;
-
-  bool is_main_thread = GetCurrentProcId() == PlatformThread::CurrentId();
-  if (is_main_thread && main_stack_end) {
-    return main_stack_end;
-  }
-
-  uintptr_t stack_begin = 0;
-  size_t stack_size = 0;
-  pthread_attr_t attributes;
-  int error = pthread_getattr_np(pthread_self(), &attributes);
-  if (!error) {
-    error = pthread_attr_getstack(
-        &attributes, reinterpret_cast<void**>(&stack_begin), &stack_size);
-    pthread_attr_destroy(&attributes);
-  }
-  DCHECK(!error);
-
-  uintptr_t stack_end = stack_begin + stack_size;
-  if (is_main_thread) {
-    main_stack_end = stack_end;
-  }
-  return stack_end;  // 0 in case of error
-
-#elif defined(OS_LINUX) && defined(__GLIBC__)
-
-  if (GetCurrentProcId() == PlatformThread::CurrentId()) {
-    // For the main thread we have a shortcut.
-    return reinterpret_cast<uintptr_t>(__libc_stack_end);
-  }
-
-// No easy way to get end of the stack for non-main threads,
-// see crbug.com/617730.
-#elif defined(OS_MACOSX)
-  return reinterpret_cast<uintptr_t>(pthread_get_stackaddr_np(pthread_self()));
-#endif
-
-  // Don't know how to get end of the stack.
-  return 0;
-}
-#endif  // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
-
-StackTrace::StackTrace() : StackTrace(arraysize(trace_)) {}
-
-StackTrace::StackTrace(const void* const* trace, size_t count) {
-  count = std::min(count, arraysize(trace_));
-  if (count)
-    memcpy(trace_, trace, count * sizeof(trace_[0]));
-  count_ = count;
-}
-
-const void *const *StackTrace::Addresses(size_t* count) const {
-  *count = count_;
-  if (count_)
-    return trace_;
-  return nullptr;
-}
-
-std::string StackTrace::ToString() const {
-  std::stringstream stream;
-#if !defined(__UCLIBC__) && !defined(_AIX)
-  OutputToStream(&stream);
-#endif
-  return stream.str();
-}
-
-#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
-
-size_t TraceStackFramePointers(const void** out_trace,
-                               size_t max_depth,
-                               size_t skip_initial) {
-  // Usage of __builtin_frame_address() enables frame pointers in this
-  // function even if they are not enabled globally. So 'fp' will always
-  // be valid.
-  uintptr_t fp = reinterpret_cast<uintptr_t>(__builtin_frame_address(0)) -
-                    kStackFrameAdjustment;
-
-  uintptr_t stack_end = GetStackEnd();
-
-  size_t depth = 0;
-  while (depth < max_depth) {
-    if (skip_initial != 0) {
-      skip_initial--;
-    } else {
-      out_trace[depth++] = reinterpret_cast<const void*>(GetStackFramePC(fp));
-    }
-
-    uintptr_t next_fp = GetNextStackFrame(fp);
-    if (IsStackFrameValid(next_fp, fp, stack_end)) {
-      fp = next_fp;
-      continue;
-    }
-
-    next_fp = ScanStackForNextFrame(fp, stack_end);
-    if (next_fp) {
-      fp = next_fp;
-      continue;
-    }
-
-    // Failed to find next frame.
-    break;
-  }
-
-  return depth;
-}
-
-ScopedStackFrameLinker::ScopedStackFrameLinker(void* fp, void* parent_fp)
-    : fp_(fp),
-      parent_fp_(parent_fp),
-      original_parent_fp_(LinkStackFrames(fp, parent_fp)) {}
-
-ScopedStackFrameLinker::~ScopedStackFrameLinker() {
-  void* previous_parent_fp = LinkStackFrames(fp_, original_parent_fp_);
-  CHECK_EQ(parent_fp_, previous_parent_fp)
-      << "Stack frame's parent pointer has changed!";
-}
-
-#endif  // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
-
-}  // namespace debug
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/debug/stack_trace.h b/native/zucchini/vendor/libchrome/base/debug/stack_trace.h
deleted file mode 100644
index 81e6672..0000000
--- a/native/zucchini/vendor/libchrome/base/debug/stack_trace.h
+++ /dev/null
@@ -1,197 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_DEBUG_STACK_TRACE_H_
-#define BASE_DEBUG_STACK_TRACE_H_
-
-#include <stddef.h>
-
-#include <iosfwd>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/debug/debugging_buildflags.h"
-#include "base/macros.h"
-#include "build/build_config.h"
-
-#if defined(OS_POSIX)
-#include <unistd.h>
-#endif
-
-#if defined(OS_WIN)
-struct _EXCEPTION_POINTERS;
-struct _CONTEXT;
-#endif
-
-namespace base {
-namespace debug {
-
-// Enables stack dump to console output on exception and signals.
-// When enabled, the process will quit immediately. This is meant to be used in
-// unit_tests only! This is not thread-safe: only call from main thread.
-// In sandboxed processes, this has to be called before the sandbox is turned
-// on.
-// Calling this function on Linux opens /proc/self/maps and caches its
-// contents. In non-official builds, this function also opens the object files
-// that are loaded in memory and caches their file descriptors (this cannot be
-// done in official builds because it has security implications).
-BASE_EXPORT bool EnableInProcessStackDumping();
-
-#if defined(OS_POSIX)
-BASE_EXPORT void SetStackDumpFirstChanceCallback(bool (*handler)(int,
-                                                                 void*,
-                                                                 void*));
-#endif
-
-// Returns end of the stack, or 0 if we couldn't get it.
-#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
-BASE_EXPORT uintptr_t GetStackEnd();
-#endif
-
-// A stacktrace can be helpful in debugging. For example, you can include a
-// stacktrace member in a object (probably around #ifndef NDEBUG) so that you
-// can later see where the given object was created from.
-class BASE_EXPORT StackTrace {
- public:
-  // Creates a stacktrace from the current location.
-  StackTrace();
-
-  // Creates a stacktrace from the current location, of up to |count| entries.
-  // |count| will be limited to at most |kMaxTraces|.
-  explicit StackTrace(size_t count);
-
-  // Creates a stacktrace from an existing array of instruction
-  // pointers (such as returned by Addresses()).  |count| will be
-  // limited to at most |kMaxTraces|.
-  StackTrace(const void* const* trace, size_t count);
-
-#if defined(OS_WIN)
-  // Creates a stacktrace for an exception.
-  // Note: this function will throw an import not found (StackWalk64) exception
-  // on system without dbghelp 5.1.
-  StackTrace(_EXCEPTION_POINTERS* exception_pointers);
-  StackTrace(const _CONTEXT* context);
-#endif
-
-  // Copying and assignment are allowed with the default functions.
-
-  // Gets an array of instruction pointer values. |*count| will be set to the
-  // number of elements in the returned array.
-  const void* const* Addresses(size_t* count) const;
-
-  // Prints the stack trace to stderr.
-  void Print() const;
-
-#if !defined(__UCLIBC__) & !defined(_AIX)
-  // Resolves backtrace to symbols and write to stream.
-  void OutputToStream(std::ostream* os) const;
-#endif
-
-  // Resolves backtrace to symbols and returns as string.
-  std::string ToString() const;
-
- private:
-#if defined(OS_WIN)
-  void InitTrace(const _CONTEXT* context_record);
-#endif
-
-  // From http://msdn.microsoft.com/en-us/library/bb204633.aspx,
-  // the sum of FramesToSkip and FramesToCapture must be less than 63,
-  // so set it to 62. Even if on POSIX it could be a larger value, it usually
-  // doesn't give much more information.
-  static const int kMaxTraces = 62;
-
-  void* trace_[kMaxTraces];
-
-  // The number of valid frames in |trace_|.
-  size_t count_;
-};
-
-#if BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
-// Traces the stack by using frame pointers. This function is faster but less
-// reliable than StackTrace. It should work for debug and profiling builds,
-// but not for release builds (although there are some exceptions).
-//
-// Writes at most |max_depth| frames (instruction pointers) into |out_trace|
-// after skipping |skip_initial| frames. Note that the function itself is not
-// added to the trace so |skip_initial| should be 0 in most cases.
-// Returns number of frames written.
-BASE_EXPORT size_t TraceStackFramePointers(const void** out_trace,
-                                           size_t max_depth,
-                                           size_t skip_initial);
-
-// Links stack frame |fp| to |parent_fp|, so that during stack unwinding
-// TraceStackFramePointers() visits |parent_fp| after visiting |fp|.
-// Both frame pointers must come from __builtin_frame_address().
-// Destructor restores original linkage of |fp| to avoid corrupting caller's
-// frame register on return.
-//
-// This class can be used to repair broken stack frame chain in cases
-// when execution flow goes into code built without frame pointers:
-//
-// void DoWork() {
-//   Call_SomeLibrary();
-// }
-// static __thread void*  g_saved_fp;
-// void Call_SomeLibrary() {
-//   g_saved_fp = __builtin_frame_address(0);
-//   some_library_call(...); // indirectly calls SomeLibrary_Callback()
-// }
-// void SomeLibrary_Callback() {
-//   ScopedStackFrameLinker linker(__builtin_frame_address(0), g_saved_fp);
-//   ...
-//   TraceStackFramePointers(...);
-// }
-//
-// This produces the following trace:
-//
-// #0 SomeLibrary_Callback()
-// #1 <address of the code inside SomeLibrary that called #0>
-// #2 DoWork()
-// ...rest of the trace...
-//
-// SomeLibrary doesn't use frame pointers, so when SomeLibrary_Callback()
-// is called, stack frame register contains bogus value that becomes callback'
-// parent frame address. Without ScopedStackFrameLinker unwinding would've
-// stopped at that bogus frame address yielding just two first frames (#0, #1).
-// ScopedStackFrameLinker overwrites callback's parent frame address with
-// Call_SomeLibrary's frame, so unwinder produces full trace without even
-// noticing that stack frame chain was broken.
-class BASE_EXPORT ScopedStackFrameLinker {
- public:
-  ScopedStackFrameLinker(void* fp, void* parent_fp);
-  ~ScopedStackFrameLinker();
-
- private:
-  void* fp_;
-  void* parent_fp_;
-  void* original_parent_fp_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedStackFrameLinker);
-};
-
-#endif  // BUILDFLAG(CAN_UNWIND_WITH_FRAME_POINTERS)
-
-namespace internal {
-
-#if defined(OS_POSIX) && !defined(OS_ANDROID)
-// POSIX doesn't define any async-signal safe function for converting
-// an integer to ASCII. We'll have to define our own version.
-// itoa_r() converts a (signed) integer to ASCII. It returns "buf", if the
-// conversion was successful or NULL otherwise. It never writes more than "sz"
-// bytes. Output will be truncated as needed, and a NUL character is always
-// appended.
-BASE_EXPORT char *itoa_r(intptr_t i,
-                         char *buf,
-                         size_t sz,
-                         int base,
-                         size_t padding);
-#endif  // defined(OS_POSIX) && !defined(OS_ANDROID)
-
-}  // namespace internal
-
-}  // namespace debug
-}  // namespace base
-
-#endif  // BASE_DEBUG_STACK_TRACE_H_
diff --git a/native/zucchini/vendor/libchrome/base/debug/stack_trace_posix.cc b/native/zucchini/vendor/libchrome/base/debug/stack_trace_posix.cc
deleted file mode 100644
index f3f05da..0000000
--- a/native/zucchini/vendor/libchrome/base/debug/stack_trace_posix.cc
+++ /dev/null
@@ -1,898 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/debug/stack_trace.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#include <signal.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/param.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <algorithm>
-#include <map>
-#include <memory>
-#include <ostream>
-#include <string>
-#include <vector>
-
-#if !defined(USE_SYMBOLIZE)
-#include <cxxabi.h>
-#endif
-#if !defined(__UCLIBC__) && !defined(_AIX)
-#include <execinfo.h>
-#endif
-
-#if defined(OS_MACOSX)
-#include <AvailabilityMacros.h>
-#endif
-
-#if defined(OS_LINUX)
-#include "base/debug/proc_maps_linux.h"
-#endif
-
-#include "base/cfi_buildflags.h"
-#include "base/debug/debugger.h"
-#include "base/files/scoped_file.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/free_deleter.h"
-#include "base/memory/singleton.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/strings/string_number_conversions.h"
-#include "build/build_config.h"
-
-#if defined(USE_SYMBOLIZE)
-#include "base/third_party/symbolize/symbolize.h"
-#endif
-
-namespace base {
-namespace debug {
-
-namespace {
-
-volatile sig_atomic_t in_signal_handler = 0;
-
-bool (*try_handle_signal)(int, void*, void*) = nullptr;
-
-#if !defined(USE_SYMBOLIZE)
-// The prefix used for mangled symbols, per the Itanium C++ ABI:
-// http://www.codesourcery.com/cxx-abi/abi.html#mangling
-const char kMangledSymbolPrefix[] = "_Z";
-
-// Characters that can be used for symbols, generated by Ruby:
-// (('a'..'z').to_a+('A'..'Z').to_a+('0'..'9').to_a + ['_']).join
-const char kSymbolCharacters[] =
-    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
-#endif  // !defined(USE_SYMBOLIZE)
-
-#if !defined(USE_SYMBOLIZE)
-// Demangles C++ symbols in the given text. Example:
-//
-// "out/Debug/base_unittests(_ZN10StackTraceC1Ev+0x20) [0x817778c]"
-// =>
-// "out/Debug/base_unittests(StackTrace::StackTrace()+0x20) [0x817778c]"
-void DemangleSymbols(std::string* text) {
-  // Note: code in this function is NOT async-signal safe (std::string uses
-  // malloc internally).
-
-#if !defined(__UCLIBC__) && !defined(_AIX)
-  std::string::size_type search_from = 0;
-  while (search_from < text->size()) {
-    // Look for the start of a mangled symbol, from search_from.
-    std::string::size_type mangled_start =
-        text->find(kMangledSymbolPrefix, search_from);
-    if (mangled_start == std::string::npos) {
-      break;  // Mangled symbol not found.
-    }
-
-    // Look for the end of the mangled symbol.
-    std::string::size_type mangled_end =
-        text->find_first_not_of(kSymbolCharacters, mangled_start);
-    if (mangled_end == std::string::npos) {
-      mangled_end = text->size();
-    }
-    std::string mangled_symbol =
-        text->substr(mangled_start, mangled_end - mangled_start);
-
-    // Try to demangle the mangled symbol candidate.
-    int status = 0;
-    std::unique_ptr<char, base::FreeDeleter> demangled_symbol(
-        abi::__cxa_demangle(mangled_symbol.c_str(), nullptr, 0, &status));
-    if (status == 0) {  // Demangling is successful.
-      // Remove the mangled symbol.
-      text->erase(mangled_start, mangled_end - mangled_start);
-      // Insert the demangled symbol.
-      text->insert(mangled_start, demangled_symbol.get());
-      // Next time, we'll start right after the demangled symbol we inserted.
-      search_from = mangled_start + strlen(demangled_symbol.get());
-    } else {
-      // Failed to demangle.  Retry after the "_Z" we just found.
-      search_from = mangled_start + 2;
-    }
-  }
-#endif  // !defined(__UCLIBC__) && !defined(_AIX)
-}
-#endif  // !defined(USE_SYMBOLIZE)
-
-class BacktraceOutputHandler {
- public:
-  virtual void HandleOutput(const char* output) = 0;
-
- protected:
-  virtual ~BacktraceOutputHandler() = default;
-};
-
-#if !defined(__UCLIBC__) && !defined(_AIX)
-void OutputPointer(void* pointer, BacktraceOutputHandler* handler) {
-  // This should be more than enough to store a 64-bit number in hex:
-  // 16 hex digits + 1 for null-terminator.
-  char buf[17] = { '\0' };
-  handler->HandleOutput("0x");
-  internal::itoa_r(reinterpret_cast<intptr_t>(pointer),
-                   buf, sizeof(buf), 16, 12);
-  handler->HandleOutput(buf);
-}
-
-#if defined(USE_SYMBOLIZE)
-void OutputFrameId(intptr_t frame_id, BacktraceOutputHandler* handler) {
-  // Max unsigned 64-bit number in decimal has 20 digits (18446744073709551615).
-  // Hence, 30 digits should be more than enough to represent it in decimal
-  // (including the null-terminator).
-  char buf[30] = { '\0' };
-  handler->HandleOutput("#");
-  internal::itoa_r(frame_id, buf, sizeof(buf), 10, 1);
-  handler->HandleOutput(buf);
-}
-#endif  // defined(USE_SYMBOLIZE)
-
-void ProcessBacktrace(void *const *trace,
-                      size_t size,
-                      BacktraceOutputHandler* handler) {
-  // NOTE: This code MUST be async-signal safe (it's used by in-process
-  // stack dumping signal handler). NO malloc or stdio is allowed here.
-
-#if defined(USE_SYMBOLIZE)
-  for (size_t i = 0; i < size; ++i) {
-    OutputFrameId(i, handler);
-    handler->HandleOutput(" ");
-    OutputPointer(trace[i], handler);
-    handler->HandleOutput(" ");
-
-    char buf[1024] = { '\0' };
-
-    // Subtract by one as return address of function may be in the next
-    // function when a function is annotated as noreturn.
-    void* address = static_cast<char*>(trace[i]) - 1;
-    if (google::Symbolize(address, buf, sizeof(buf)))
-      handler->HandleOutput(buf);
-    else
-      handler->HandleOutput("<unknown>");
-
-    handler->HandleOutput("\n");
-  }
-#else
-  bool printed = false;
-
-  // Below part is async-signal unsafe (uses malloc), so execute it only
-  // when we are not executing the signal handler.
-  if (in_signal_handler == 0) {
-    std::unique_ptr<char*, FreeDeleter> trace_symbols(
-        backtrace_symbols(trace, size));
-    if (trace_symbols.get()) {
-      for (size_t i = 0; i < size; ++i) {
-        std::string trace_symbol = trace_symbols.get()[i];
-        DemangleSymbols(&trace_symbol);
-        handler->HandleOutput(trace_symbol.c_str());
-        handler->HandleOutput("\n");
-      }
-
-      printed = true;
-    }
-  }
-
-  if (!printed) {
-    for (size_t i = 0; i < size; ++i) {
-      handler->HandleOutput(" [");
-      OutputPointer(trace[i], handler);
-      handler->HandleOutput("]\n");
-    }
-  }
-#endif  // defined(USE_SYMBOLIZE)
-}
-#endif  // !defined(__UCLIBC__) && !defined(_AIX)
-
-void PrintToStderr(const char* output) {
-  // NOTE: This code MUST be async-signal safe (it's used by in-process
-  // stack dumping signal handler). NO malloc or stdio is allowed here.
-  ignore_result(HANDLE_EINTR(write(STDERR_FILENO, output, strlen(output))));
-}
-
-void StackDumpSignalHandler(int signal, siginfo_t* info, void* void_context) {
-  // NOTE: This code MUST be async-signal safe.
-  // NO malloc or stdio is allowed here.
-
-  // Give a registered callback a chance to recover from this signal
-  //
-  // V8 uses guard regions to guarantee memory safety in WebAssembly. This means
-  // some signals might be expected if they originate from Wasm code while
-  // accessing the guard region. We give V8 the chance to handle and recover
-  // from these signals first.
-  if (try_handle_signal != nullptr &&
-      try_handle_signal(signal, info, void_context)) {
-    // The first chance handler took care of this. The SA_RESETHAND flag
-    // replaced this signal handler upon entry, but we want to stay
-    // installed. Thus, we reinstall ourselves before returning.
-    struct sigaction action;
-    memset(&action, 0, sizeof(action));
-    action.sa_flags = SA_RESETHAND | SA_SIGINFO;
-    action.sa_sigaction = &StackDumpSignalHandler;
-    sigemptyset(&action.sa_mask);
-
-    sigaction(signal, &action, nullptr);
-    return;
-  }
-
-// Do not take the "in signal handler" code path on Mac in a DCHECK-enabled
-// build, as this prevents seeing a useful (symbolized) stack trace on a crash
-// or DCHECK() failure. While it may not be fully safe to run the stack symbol
-// printing code, in practice it's better to provide meaningful stack traces -
-// and the risk is low given we're likely crashing already.
-#if !defined(OS_MACOSX) || !DCHECK_IS_ON()
-  // Record the fact that we are in the signal handler now, so that the rest
-  // of StackTrace can behave in an async-signal-safe manner.
-  in_signal_handler = 1;
-#endif
-
-  if (BeingDebugged())
-    BreakDebugger();
-
-  PrintToStderr("Received signal ");
-  char buf[1024] = { 0 };
-  internal::itoa_r(signal, buf, sizeof(buf), 10, 0);
-  PrintToStderr(buf);
-  if (signal == SIGBUS) {
-    if (info->si_code == BUS_ADRALN)
-      PrintToStderr(" BUS_ADRALN ");
-    else if (info->si_code == BUS_ADRERR)
-      PrintToStderr(" BUS_ADRERR ");
-    else if (info->si_code == BUS_OBJERR)
-      PrintToStderr(" BUS_OBJERR ");
-    else
-      PrintToStderr(" <unknown> ");
-  } else if (signal == SIGFPE) {
-    if (info->si_code == FPE_FLTDIV)
-      PrintToStderr(" FPE_FLTDIV ");
-    else if (info->si_code == FPE_FLTINV)
-      PrintToStderr(" FPE_FLTINV ");
-    else if (info->si_code == FPE_FLTOVF)
-      PrintToStderr(" FPE_FLTOVF ");
-    else if (info->si_code == FPE_FLTRES)
-      PrintToStderr(" FPE_FLTRES ");
-    else if (info->si_code == FPE_FLTSUB)
-      PrintToStderr(" FPE_FLTSUB ");
-    else if (info->si_code == FPE_FLTUND)
-      PrintToStderr(" FPE_FLTUND ");
-    else if (info->si_code == FPE_INTDIV)
-      PrintToStderr(" FPE_INTDIV ");
-    else if (info->si_code == FPE_INTOVF)
-      PrintToStderr(" FPE_INTOVF ");
-    else
-      PrintToStderr(" <unknown> ");
-  } else if (signal == SIGILL) {
-    if (info->si_code == ILL_BADSTK)
-      PrintToStderr(" ILL_BADSTK ");
-    else if (info->si_code == ILL_COPROC)
-      PrintToStderr(" ILL_COPROC ");
-    else if (info->si_code == ILL_ILLOPN)
-      PrintToStderr(" ILL_ILLOPN ");
-    else if (info->si_code == ILL_ILLADR)
-      PrintToStderr(" ILL_ILLADR ");
-    else if (info->si_code == ILL_ILLTRP)
-      PrintToStderr(" ILL_ILLTRP ");
-    else if (info->si_code == ILL_PRVOPC)
-      PrintToStderr(" ILL_PRVOPC ");
-    else if (info->si_code == ILL_PRVREG)
-      PrintToStderr(" ILL_PRVREG ");
-    else
-      PrintToStderr(" <unknown> ");
-  } else if (signal == SIGSEGV) {
-    if (info->si_code == SEGV_MAPERR)
-      PrintToStderr(" SEGV_MAPERR ");
-    else if (info->si_code == SEGV_ACCERR)
-      PrintToStderr(" SEGV_ACCERR ");
-    else
-      PrintToStderr(" <unknown> ");
-  }
-  if (signal == SIGBUS || signal == SIGFPE ||
-      signal == SIGILL || signal == SIGSEGV) {
-    internal::itoa_r(reinterpret_cast<intptr_t>(info->si_addr),
-                     buf, sizeof(buf), 16, 12);
-    PrintToStderr(buf);
-  }
-  PrintToStderr("\n");
-
-#if BUILDFLAG(CFI_ENFORCEMENT_TRAP)
-  if (signal == SIGILL && info->si_code == ILL_ILLOPN) {
-    PrintToStderr(
-        "CFI: Most likely a control flow integrity violation; for more "
-        "information see:\n");
-    PrintToStderr(
-        "https://www.chromium.org/developers/testing/control-flow-integrity\n");
-  }
-#endif  // BUILDFLAG(CFI_ENFORCEMENT_TRAP)
-
-  debug::StackTrace().Print();
-
-#if defined(OS_LINUX)
-#if ARCH_CPU_X86_FAMILY
-  ucontext_t* context = reinterpret_cast<ucontext_t*>(void_context);
-  const struct {
-    const char* label;
-    greg_t value;
-  } registers[] = {
-#if ARCH_CPU_32_BITS
-    { "  gs: ", context->uc_mcontext.gregs[REG_GS] },
-    { "  fs: ", context->uc_mcontext.gregs[REG_FS] },
-    { "  es: ", context->uc_mcontext.gregs[REG_ES] },
-    { "  ds: ", context->uc_mcontext.gregs[REG_DS] },
-    { " edi: ", context->uc_mcontext.gregs[REG_EDI] },
-    { " esi: ", context->uc_mcontext.gregs[REG_ESI] },
-    { " ebp: ", context->uc_mcontext.gregs[REG_EBP] },
-    { " esp: ", context->uc_mcontext.gregs[REG_ESP] },
-    { " ebx: ", context->uc_mcontext.gregs[REG_EBX] },
-    { " edx: ", context->uc_mcontext.gregs[REG_EDX] },
-    { " ecx: ", context->uc_mcontext.gregs[REG_ECX] },
-    { " eax: ", context->uc_mcontext.gregs[REG_EAX] },
-    { " trp: ", context->uc_mcontext.gregs[REG_TRAPNO] },
-    { " err: ", context->uc_mcontext.gregs[REG_ERR] },
-    { "  ip: ", context->uc_mcontext.gregs[REG_EIP] },
-    { "  cs: ", context->uc_mcontext.gregs[REG_CS] },
-    { " efl: ", context->uc_mcontext.gregs[REG_EFL] },
-    { " usp: ", context->uc_mcontext.gregs[REG_UESP] },
-    { "  ss: ", context->uc_mcontext.gregs[REG_SS] },
-#elif ARCH_CPU_64_BITS
-    { "  r8: ", context->uc_mcontext.gregs[REG_R8] },
-    { "  r9: ", context->uc_mcontext.gregs[REG_R9] },
-    { " r10: ", context->uc_mcontext.gregs[REG_R10] },
-    { " r11: ", context->uc_mcontext.gregs[REG_R11] },
-    { " r12: ", context->uc_mcontext.gregs[REG_R12] },
-    { " r13: ", context->uc_mcontext.gregs[REG_R13] },
-    { " r14: ", context->uc_mcontext.gregs[REG_R14] },
-    { " r15: ", context->uc_mcontext.gregs[REG_R15] },
-    { "  di: ", context->uc_mcontext.gregs[REG_RDI] },
-    { "  si: ", context->uc_mcontext.gregs[REG_RSI] },
-    { "  bp: ", context->uc_mcontext.gregs[REG_RBP] },
-    { "  bx: ", context->uc_mcontext.gregs[REG_RBX] },
-    { "  dx: ", context->uc_mcontext.gregs[REG_RDX] },
-    { "  ax: ", context->uc_mcontext.gregs[REG_RAX] },
-    { "  cx: ", context->uc_mcontext.gregs[REG_RCX] },
-    { "  sp: ", context->uc_mcontext.gregs[REG_RSP] },
-    { "  ip: ", context->uc_mcontext.gregs[REG_RIP] },
-    { " efl: ", context->uc_mcontext.gregs[REG_EFL] },
-    { " cgf: ", context->uc_mcontext.gregs[REG_CSGSFS] },
-    { " erf: ", context->uc_mcontext.gregs[REG_ERR] },
-    { " trp: ", context->uc_mcontext.gregs[REG_TRAPNO] },
-    { " msk: ", context->uc_mcontext.gregs[REG_OLDMASK] },
-    { " cr2: ", context->uc_mcontext.gregs[REG_CR2] },
-#endif  // ARCH_CPU_32_BITS
-  };
-
-#if ARCH_CPU_32_BITS
-  const int kRegisterPadding = 8;
-#elif ARCH_CPU_64_BITS
-  const int kRegisterPadding = 16;
-#endif
-
-  for (size_t i = 0; i < arraysize(registers); i++) {
-    PrintToStderr(registers[i].label);
-    internal::itoa_r(registers[i].value, buf, sizeof(buf),
-                     16, kRegisterPadding);
-    PrintToStderr(buf);
-
-    if ((i + 1) % 4 == 0)
-      PrintToStderr("\n");
-  }
-  PrintToStderr("\n");
-#endif  // ARCH_CPU_X86_FAMILY
-#endif  // defined(OS_LINUX)
-
-  PrintToStderr("[end of stack trace]\n");
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  if (::signal(signal, SIG_DFL) == SIG_ERR)
-    _exit(1);
-#else
-  // Non-Mac OSes should probably reraise the signal as well, but the Linux
-  // sandbox tests break on CrOS devices.
-  // https://code.google.com/p/chromium/issues/detail?id=551681
-  PrintToStderr("Calling _exit(1). Core file will not be generated.\n");
-  _exit(1);
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
-}
-
-class PrintBacktraceOutputHandler : public BacktraceOutputHandler {
- public:
-  PrintBacktraceOutputHandler() = default;
-
-  void HandleOutput(const char* output) override {
-    // NOTE: This code MUST be async-signal safe (it's used by in-process
-    // stack dumping signal handler). NO malloc or stdio is allowed here.
-    PrintToStderr(output);
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(PrintBacktraceOutputHandler);
-};
-
-class StreamBacktraceOutputHandler : public BacktraceOutputHandler {
- public:
-  explicit StreamBacktraceOutputHandler(std::ostream* os) : os_(os) {
-  }
-
-  void HandleOutput(const char* output) override { (*os_) << output; }
-
- private:
-  std::ostream* os_;
-
-  DISALLOW_COPY_AND_ASSIGN(StreamBacktraceOutputHandler);
-};
-
-void WarmUpBacktrace() {
-  // Warm up stack trace infrastructure. It turns out that on the first
-  // call glibc initializes some internal data structures using pthread_once,
-  // and even backtrace() can call malloc(), leading to hangs.
-  //
-  // Example stack trace snippet (with tcmalloc):
-  //
-  // #8  0x0000000000a173b5 in tc_malloc
-  //             at ./third_party/tcmalloc/chromium/src/debugallocation.cc:1161
-  // #9  0x00007ffff7de7900 in _dl_map_object_deps at dl-deps.c:517
-  // #10 0x00007ffff7ded8a9 in dl_open_worker at dl-open.c:262
-  // #11 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178
-  // #12 0x00007ffff7ded31a in _dl_open (file=0x7ffff625e298 "libgcc_s.so.1")
-  //             at dl-open.c:639
-  // #13 0x00007ffff6215602 in do_dlopen at dl-libc.c:89
-  // #14 0x00007ffff7de9176 in _dl_catch_error at dl-error.c:178
-  // #15 0x00007ffff62156c4 in dlerror_run at dl-libc.c:48
-  // #16 __GI___libc_dlopen_mode at dl-libc.c:165
-  // #17 0x00007ffff61ef8f5 in init
-  //             at ../sysdeps/x86_64/../ia64/backtrace.c:53
-  // #18 0x00007ffff6aad400 in pthread_once
-  //             at ../nptl/sysdeps/unix/sysv/linux/x86_64/pthread_once.S:104
-  // #19 0x00007ffff61efa14 in __GI___backtrace
-  //             at ../sysdeps/x86_64/../ia64/backtrace.c:104
-  // #20 0x0000000000752a54 in base::debug::StackTrace::StackTrace
-  //             at base/debug/stack_trace_posix.cc:175
-  // #21 0x00000000007a4ae5 in
-  //             base::(anonymous namespace)::StackDumpSignalHandler
-  //             at base/process_util_posix.cc:172
-  // #22 <signal handler called>
-  StackTrace stack_trace;
-}
-
-#if defined(USE_SYMBOLIZE)
-
-// class SandboxSymbolizeHelper.
-//
-// The purpose of this class is to prepare and install a "file open" callback
-// needed by the stack trace symbolization code
-// (base/third_party/symbolize/symbolize.h) so that it can function properly
-// in a sandboxed process.  The caveat is that this class must be instantiated
-// before the sandboxing is enabled so that it can get the chance to open all
-// the object files that are loaded in the virtual address space of the current
-// process.
-class SandboxSymbolizeHelper {
- public:
-  // Returns the singleton instance.
-  static SandboxSymbolizeHelper* GetInstance() {
-    return Singleton<SandboxSymbolizeHelper,
-                     LeakySingletonTraits<SandboxSymbolizeHelper>>::get();
-  }
-
- private:
-  friend struct DefaultSingletonTraits<SandboxSymbolizeHelper>;
-
-  SandboxSymbolizeHelper()
-      : is_initialized_(false) {
-    Init();
-  }
-
-  ~SandboxSymbolizeHelper() {
-    UnregisterCallback();
-    CloseObjectFiles();
-  }
-
-  // Returns a O_RDONLY file descriptor for |file_path| if it was opened
-  // successfully during the initialization.  The file is repositioned at
-  // offset 0.
-  // IMPORTANT: This function must be async-signal-safe because it can be
-  // called from a signal handler (symbolizing stack frames for a crash).
-  int GetFileDescriptor(const char* file_path) {
-    int fd = -1;
-
-#if !defined(OFFICIAL_BUILD)
-    if (file_path) {
-      // The assumption here is that iterating over std::map<std::string, int>
-      // using a const_iterator does not allocate dynamic memory, hense it is
-      // async-signal-safe.
-      std::map<std::string, int>::const_iterator it;
-      for (it = modules_.begin(); it != modules_.end(); ++it) {
-        if (strcmp((it->first).c_str(), file_path) == 0) {
-          // POSIX.1-2004 requires an implementation to guarantee that dup()
-          // is async-signal-safe.
-          fd = HANDLE_EINTR(dup(it->second));
-          break;
-        }
-      }
-      // POSIX.1-2004 requires an implementation to guarantee that lseek()
-      // is async-signal-safe.
-      if (fd >= 0 && lseek(fd, 0, SEEK_SET) < 0) {
-        // Failed to seek.
-        fd = -1;
-      }
-    }
-#endif  // !defined(OFFICIAL_BUILD)
-
-    return fd;
-  }
-
-  // Searches for the object file (from /proc/self/maps) that contains
-  // the specified pc.  If found, sets |start_address| to the start address
-  // of where this object file is mapped in memory, sets the module base
-  // address into |base_address|, copies the object file name into
-  // |out_file_name|, and attempts to open the object file.  If the object
-  // file is opened successfully, returns the file descriptor.  Otherwise,
-  // returns -1.  |out_file_name_size| is the size of the file name buffer
-  // (including the null terminator).
-  // IMPORTANT: This function must be async-signal-safe because it can be
-  // called from a signal handler (symbolizing stack frames for a crash).
-  static int OpenObjectFileContainingPc(uint64_t pc, uint64_t& start_address,
-                                        uint64_t& base_address, char* file_path,
-                                        int file_path_size) {
-    // This method can only be called after the singleton is instantiated.
-    // This is ensured by the following facts:
-    // * This is the only static method in this class, it is private, and
-    //   the class has no friends (except for the DefaultSingletonTraits).
-    //   The compiler guarantees that it can only be called after the
-    //   singleton is instantiated.
-    // * This method is used as a callback for the stack tracing code and
-    //   the callback registration is done in the constructor, so logically
-    //   it cannot be called before the singleton is created.
-    SandboxSymbolizeHelper* instance = GetInstance();
-
-    // The assumption here is that iterating over
-    // std::vector<MappedMemoryRegion> using a const_iterator does not allocate
-    // dynamic memory, hence it is async-signal-safe.
-    for (const MappedMemoryRegion& region : instance->regions_) {
-      if (region.start <= pc && pc < region.end) {
-        start_address = region.start;
-        base_address = region.base;
-        if (file_path && file_path_size > 0) {
-          strncpy(file_path, region.path.c_str(), file_path_size);
-          // Ensure null termination.
-          file_path[file_path_size - 1] = '\0';
-        }
-        return instance->GetFileDescriptor(region.path.c_str());
-      }
-    }
-    return -1;
-  }
-
-  // Set the base address for each memory region by reading ELF headers in
-  // process memory.
-  void SetBaseAddressesForMemoryRegions() {
-    base::ScopedFD mem_fd(
-        HANDLE_EINTR(open("/proc/self/mem", O_RDONLY | O_CLOEXEC)));
-    if (!mem_fd.is_valid())
-      return;
-
-    auto safe_memcpy = [&mem_fd](void* dst, uintptr_t src, size_t size) {
-      return HANDLE_EINTR(pread(mem_fd.get(), dst, size, src)) == ssize_t(size);
-    };
-
-    uintptr_t cur_base = 0;
-    for (auto& r : regions_) {
-      ElfW(Ehdr) ehdr;
-      static_assert(SELFMAG <= sizeof(ElfW(Ehdr)), "SELFMAG too large");
-      if ((r.permissions & MappedMemoryRegion::READ) &&
-          safe_memcpy(&ehdr, r.start, sizeof(ElfW(Ehdr))) &&
-          memcmp(ehdr.e_ident, ELFMAG, SELFMAG) == 0) {
-        switch (ehdr.e_type) {
-          case ET_EXEC:
-            cur_base = 0;
-            break;
-          case ET_DYN:
-            // Find the segment containing file offset 0. This will correspond
-            // to the ELF header that we just read. Normally this will have
-            // virtual address 0, but this is not guaranteed. We must subtract
-            // the virtual address from the address where the ELF header was
-            // mapped to get the base address.
-            //
-            // If we fail to find a segment for file offset 0, use the address
-            // of the ELF header as the base address.
-            cur_base = r.start;
-            for (unsigned i = 0; i != ehdr.e_phnum; ++i) {
-              ElfW(Phdr) phdr;
-              if (safe_memcpy(&phdr, r.start + ehdr.e_phoff + i * sizeof(phdr),
-                              sizeof(phdr)) &&
-                  phdr.p_type == PT_LOAD && phdr.p_offset == 0) {
-                cur_base = r.start - phdr.p_vaddr;
-                break;
-              }
-            }
-            break;
-          default:
-            // ET_REL or ET_CORE. These aren't directly executable, so they
-            // don't affect the base address.
-            break;
-        }
-      }
-
-      r.base = cur_base;
-    }
-  }
-
-  // Parses /proc/self/maps in order to compile a list of all object file names
-  // for the modules that are loaded in the current process.
-  // Returns true on success.
-  bool CacheMemoryRegions() {
-    // Reads /proc/self/maps.
-    std::string contents;
-    if (!ReadProcMaps(&contents)) {
-      LOG(ERROR) << "Failed to read /proc/self/maps";
-      return false;
-    }
-
-    // Parses /proc/self/maps.
-    if (!ParseProcMaps(contents, &regions_)) {
-      LOG(ERROR) << "Failed to parse the contents of /proc/self/maps";
-      return false;
-    }
-
-    SetBaseAddressesForMemoryRegions();
-
-    is_initialized_ = true;
-    return true;
-  }
-
-  // Opens all object files and caches their file descriptors.
-  void OpenSymbolFiles() {
-    // Pre-opening and caching the file descriptors of all loaded modules is
-    // not safe for production builds.  Hence it is only done in non-official
-    // builds.  For more details, take a look at: http://crbug.com/341966.
-#if !defined(OFFICIAL_BUILD)
-    // Open the object files for all read-only executable regions and cache
-    // their file descriptors.
-    std::vector<MappedMemoryRegion>::const_iterator it;
-    for (it = regions_.begin(); it != regions_.end(); ++it) {
-      const MappedMemoryRegion& region = *it;
-      // Only interesed in read-only executable regions.
-      if ((region.permissions & MappedMemoryRegion::READ) ==
-              MappedMemoryRegion::READ &&
-          (region.permissions & MappedMemoryRegion::WRITE) == 0 &&
-          (region.permissions & MappedMemoryRegion::EXECUTE) ==
-              MappedMemoryRegion::EXECUTE) {
-        if (region.path.empty()) {
-          // Skip regions with empty file names.
-          continue;
-        }
-        if (region.path[0] == '[') {
-          // Skip pseudo-paths, like [stack], [vdso], [heap], etc ...
-          continue;
-        }
-        // Avoid duplicates.
-        if (modules_.find(region.path) == modules_.end()) {
-          int fd = open(region.path.c_str(), O_RDONLY | O_CLOEXEC);
-          if (fd >= 0) {
-            modules_.insert(std::make_pair(region.path, fd));
-          } else {
-            LOG(WARNING) << "Failed to open file: " << region.path
-                         << "\n  Error: " << strerror(errno);
-          }
-        }
-      }
-    }
-#endif  // !defined(OFFICIAL_BUILD)
-  }
-
-  // Initializes and installs the symbolization callback.
-  void Init() {
-    if (CacheMemoryRegions()) {
-      OpenSymbolFiles();
-      google::InstallSymbolizeOpenObjectFileCallback(
-          &OpenObjectFileContainingPc);
-    }
-  }
-
-  // Unregister symbolization callback.
-  void UnregisterCallback() {
-    if (is_initialized_) {
-      google::InstallSymbolizeOpenObjectFileCallback(nullptr);
-      is_initialized_ = false;
-    }
-  }
-
-  // Closes all file descriptors owned by this instance.
-  void CloseObjectFiles() {
-#if !defined(OFFICIAL_BUILD)
-    std::map<std::string, int>::iterator it;
-    for (it = modules_.begin(); it != modules_.end(); ++it) {
-      int ret = IGNORE_EINTR(close(it->second));
-      DCHECK(!ret);
-      it->second = -1;
-    }
-    modules_.clear();
-#endif  // !defined(OFFICIAL_BUILD)
-  }
-
-  // Set to true upon successful initialization.
-  bool is_initialized_;
-
-#if !defined(OFFICIAL_BUILD)
-  // Mapping from file name to file descriptor.  Includes file descriptors
-  // for all successfully opened object files and the file descriptor for
-  // /proc/self/maps.  This code is not safe for production builds.
-  std::map<std::string, int> modules_;
-#endif  // !defined(OFFICIAL_BUILD)
-
-  // Cache for the process memory regions.  Produced by parsing the contents
-  // of /proc/self/maps cache.
-  std::vector<MappedMemoryRegion> regions_;
-
-  DISALLOW_COPY_AND_ASSIGN(SandboxSymbolizeHelper);
-};
-#endif  // USE_SYMBOLIZE
-
-}  // namespace
-
-bool EnableInProcessStackDumping() {
-#if defined(USE_SYMBOLIZE)
-  SandboxSymbolizeHelper::GetInstance();
-#endif  // USE_SYMBOLIZE
-
-  // When running in an application, our code typically expects SIGPIPE
-  // to be ignored.  Therefore, when testing that same code, it should run
-  // with SIGPIPE ignored as well.
-  struct sigaction sigpipe_action;
-  memset(&sigpipe_action, 0, sizeof(sigpipe_action));
-  sigpipe_action.sa_handler = SIG_IGN;
-  sigemptyset(&sigpipe_action.sa_mask);
-  bool success = (sigaction(SIGPIPE, &sigpipe_action, nullptr) == 0);
-
-  // Avoid hangs during backtrace initialization, see above.
-  WarmUpBacktrace();
-
-  struct sigaction action;
-  memset(&action, 0, sizeof(action));
-  action.sa_flags = SA_RESETHAND | SA_SIGINFO;
-  action.sa_sigaction = &StackDumpSignalHandler;
-  sigemptyset(&action.sa_mask);
-
-  success &= (sigaction(SIGILL, &action, nullptr) == 0);
-  success &= (sigaction(SIGABRT, &action, nullptr) == 0);
-  success &= (sigaction(SIGFPE, &action, nullptr) == 0);
-  success &= (sigaction(SIGBUS, &action, nullptr) == 0);
-  success &= (sigaction(SIGSEGV, &action, nullptr) == 0);
-// On Linux, SIGSYS is reserved by the kernel for seccomp-bpf sandboxing.
-#if !defined(OS_LINUX)
-  success &= (sigaction(SIGSYS, &action, nullptr) == 0);
-#endif  // !defined(OS_LINUX)
-
-  return success;
-}
-
-void SetStackDumpFirstChanceCallback(bool (*handler)(int, void*, void*)) {
-  DCHECK(try_handle_signal == nullptr || handler == nullptr);
-  try_handle_signal = handler;
-}
-
-StackTrace::StackTrace(size_t count) {
-// NOTE: This code MUST be async-signal safe (it's used by in-process
-// stack dumping signal handler). NO malloc or stdio is allowed here.
-
-#if !defined(__UCLIBC__) && !defined(_AIX)
-  count = std::min(arraysize(trace_), count);
-
-  // Though the backtrace API man page does not list any possible negative
-  // return values, we take no chance.
-  count_ = base::saturated_cast<size_t>(backtrace(trace_, count));
-#else
-  count_ = 0;
-#endif
-}
-
-void StackTrace::Print() const {
-  // NOTE: This code MUST be async-signal safe (it's used by in-process
-  // stack dumping signal handler). NO malloc or stdio is allowed here.
-
-#if !defined(__UCLIBC__) && !defined(_AIX)
-  PrintBacktraceOutputHandler handler;
-  ProcessBacktrace(trace_, count_, &handler);
-#endif
-}
-
-#if !defined(__UCLIBC__) && !defined(_AIX)
-void StackTrace::OutputToStream(std::ostream* os) const {
-  StreamBacktraceOutputHandler handler(os);
-  ProcessBacktrace(trace_, count_, &handler);
-}
-#endif
-
-namespace internal {
-
-// NOTE: code from sandbox/linux/seccomp-bpf/demo.cc.
-char* itoa_r(intptr_t i, char* buf, size_t sz, int base, size_t padding) {
-  // Make sure we can write at least one NUL byte.
-  size_t n = 1;
-  if (n > sz)
-    return nullptr;
-
-  if (base < 2 || base > 16) {
-    buf[0] = '\000';
-    return nullptr;
-  }
-
-  char* start = buf;
-
-  uintptr_t j = i;
-
-  // Handle negative numbers (only for base 10).
-  if (i < 0 && base == 10) {
-    // This does "j = -i" while avoiding integer overflow.
-    j = static_cast<uintptr_t>(-(i + 1)) + 1;
-
-    // Make sure we can write the '-' character.
-    if (++n > sz) {
-      buf[0] = '\000';
-      return nullptr;
-    }
-    *start++ = '-';
-  }
-
-  // Loop until we have converted the entire number. Output at least one
-  // character (i.e. '0').
-  char* ptr = start;
-  do {
-    // Make sure there is still enough space left in our output buffer.
-    if (++n > sz) {
-      buf[0] = '\000';
-      return nullptr;
-    }
-
-    // Output the next digit.
-    *ptr++ = "0123456789abcdef"[j % base];
-    j /= base;
-
-    if (padding > 0)
-      padding--;
-  } while (j > 0 || padding > 0);
-
-  // Terminate the output with a NUL character.
-  *ptr = '\000';
-
-  // Conversion to ASCII actually resulted in the digits being in reverse
-  // order. We can't easily generate them in forward order, as we can't tell
-  // the number of characters needed until we are done converting.
-  // So, now, we reverse the string (except for the possible "-" sign).
-  while (--ptr > start) {
-    char ch = *ptr;
-    *ptr = *start;
-    *start++ = ch;
-  }
-  return buf;
-}
-
-}  // namespace internal
-
-}  // namespace debug
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/environment.h b/native/zucchini/vendor/libchrome/base/environment.h
deleted file mode 100644
index e842ab0..0000000
--- a/native/zucchini/vendor/libchrome/base/environment.h
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_ENVIRONMENT_H_
-#define BASE_ENVIRONMENT_H_
-
-#include <map>
-#include <memory>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-#include "build/build_config.h"
-
-namespace base {
-
-namespace env_vars {
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-BASE_EXPORT extern const char kHome[];
-#endif
-
-}  // namespace env_vars
-
-class BASE_EXPORT Environment {
- public:
-  virtual ~Environment();
-
-  // Returns the appropriate platform-specific instance.
-  static std::unique_ptr<Environment> Create();
-
-  // Gets an environment variable's value and stores it in |result|.
-  // Returns false if the key is unset.
-  virtual bool GetVar(StringPiece variable_name, std::string* result) = 0;
-
-  // Syntactic sugar for GetVar(variable_name, nullptr);
-  virtual bool HasVar(StringPiece variable_name);
-
-  // Returns true on success, otherwise returns false.
-  virtual bool SetVar(StringPiece variable_name,
-                      const std::string& new_value) = 0;
-
-  // Returns true on success, otherwise returns false.
-  virtual bool UnSetVar(StringPiece variable_name) = 0;
-};
-
-
-#if defined(OS_WIN)
-
-typedef string16 NativeEnvironmentString;
-typedef std::map<NativeEnvironmentString, NativeEnvironmentString>
-    EnvironmentMap;
-
-// Returns a modified environment vector constructed from the given environment
-// and the list of changes given in |changes|. Each key in the environment is
-// matched against the first element of the pairs. In the event of a match, the
-// value is replaced by the second of the pair, unless the second is empty, in
-// which case the key-value is removed.
-//
-// This Windows version takes and returns a Windows-style environment block
-// which is a concatenated list of null-terminated 16-bit strings. The end is
-// marked by a double-null terminator. The size of the returned string will
-// include the terminators.
-BASE_EXPORT string16 AlterEnvironment(const wchar_t* env,
-                                      const EnvironmentMap& changes);
-
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-typedef std::string NativeEnvironmentString;
-typedef std::map<NativeEnvironmentString, NativeEnvironmentString>
-    EnvironmentMap;
-
-// See general comments for the Windows version above.
-//
-// This Posix version takes and returns a Posix-style environment block, which
-// is a null-terminated list of pointers to null-terminated strings. The
-// returned array will have appended to it the storage for the array itself so
-// there is only one pointer to manage, but this means that you can't copy the
-// array without keeping the original around.
-BASE_EXPORT std::unique_ptr<char* []> AlterEnvironment(
-    const char* const* env,
-    const EnvironmentMap& changes);
-
-#endif
-
-}  // namespace base
-
-#endif  // BASE_ENVIRONMENT_H_
diff --git a/native/zucchini/vendor/libchrome/base/feature_list.h b/native/zucchini/vendor/libchrome/base/feature_list.h
deleted file mode 100644
index 2237507..0000000
--- a/native/zucchini/vendor/libchrome/base/feature_list.h
+++ /dev/null
@@ -1,310 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_FEATURE_LIST_H_
-#define BASE_FEATURE_LIST_H_
-
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/gtest_prod_util.h"
-#include "base/macros.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/strings/string_piece.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-class FieldTrial;
-
-// Specifies whether a given feature is enabled or disabled by default.
-enum FeatureState {
-  FEATURE_DISABLED_BY_DEFAULT,
-  FEATURE_ENABLED_BY_DEFAULT,
-};
-
-// The Feature struct is used to define the default state for a feature. See
-// comment below for more details. There must only ever be one struct instance
-// for a given feature name - generally defined as a constant global variable or
-// file static. It should never be used as a constexpr as it breaks
-// pointer-based identity lookup.
-struct BASE_EXPORT Feature {
-  // The name of the feature. This should be unique to each feature and is used
-  // for enabling/disabling features via command line flags and experiments.
-  // It is strongly recommended to use CamelCase style for feature names, e.g.
-  // "MyGreatFeature".
-  const char* const name;
-
-  // The default state (i.e. enabled or disabled) for this feature.
-  const FeatureState default_state;
-};
-
-#if DCHECK_IS_CONFIGURABLE
-// DCHECKs have been built-in, and are configurable at run-time to be fatal, or
-// not, via a DcheckIsFatal feature. We define the Feature here since it is
-// checked in FeatureList::SetInstance(). See https://crbug.com/596231.
-extern BASE_EXPORT const Feature kDCheckIsFatalFeature;
-#endif  // DCHECK_IS_CONFIGURABLE
-
-// The FeatureList class is used to determine whether a given feature is on or
-// off. It provides an authoritative answer, taking into account command-line
-// overrides and experimental control.
-//
-// The basic use case is for any feature that can be toggled (e.g. through
-// command-line or an experiment) to have a defined Feature struct, e.g.:
-//
-//   const base::Feature kMyGreatFeature {
-//     "MyGreatFeature", base::FEATURE_ENABLED_BY_DEFAULT
-//   };
-//
-// Then, client code that wishes to query the state of the feature would check:
-//
-//   if (base::FeatureList::IsEnabled(kMyGreatFeature)) {
-//     // Feature code goes here.
-//   }
-//
-// Behind the scenes, the above call would take into account any command-line
-// flags to enable or disable the feature, any experiments that may control it
-// and finally its default state (in that order of priority), to determine
-// whether the feature is on.
-//
-// Features can be explicitly forced on or off by specifying a list of comma-
-// separated feature names via the following command-line flags:
-//
-//   --enable-features=Feature5,Feature7
-//   --disable-features=Feature1,Feature2,Feature3
-//
-// To enable/disable features in a test, do NOT append --enable-features or
-// --disable-features to the command-line directly. Instead, use
-// ScopedFeatureList. See base/test/scoped_feature_list.h for details.
-//
-// After initialization (which should be done single-threaded), the FeatureList
-// API is thread safe.
-//
-// Note: This class is a singleton, but does not use base/memory/singleton.h in
-// order to have control over its initialization sequence. Specifically, the
-// intended use is to create an instance of this class and fully initialize it,
-// before setting it as the singleton for a process, via SetInstance().
-class BASE_EXPORT FeatureList {
- public:
-  FeatureList();
-  ~FeatureList();
-
-  // Initializes feature overrides via command-line flags |enable_features| and
-  // |disable_features|, each of which is a comma-separated list of features to
-  // enable or disable, respectively. If a feature appears on both lists, then
-  // it will be disabled. If a list entry has the format "FeatureName<TrialName"
-  // then this initialization will also associate the feature state override
-  // with the named field trial, if it exists. If a feature name is prefixed
-  // with the '*' character, it will be created with OVERRIDE_USE_DEFAULT -
-  // which is useful for associating with a trial while using the default state.
-  // Must only be invoked during the initialization phase (before
-  // FinalizeInitialization() has been called).
-  void InitializeFromCommandLine(const std::string& enable_features,
-                                 const std::string& disable_features);
-
-  // Initializes feature overrides through the field trial allocator, which
-  // we're using to store the feature names, their override state, and the name
-  // of the associated field trial.
-  void InitializeFromSharedMemory(PersistentMemoryAllocator* allocator);
-
-  // Specifies whether a feature override enables or disables the feature.
-  enum OverrideState {
-    OVERRIDE_USE_DEFAULT,
-    OVERRIDE_DISABLE_FEATURE,
-    OVERRIDE_ENABLE_FEATURE,
-  };
-
-  // Returns true if the state of |feature_name| has been overridden via
-  // |InitializeFromCommandLine()|.
-  bool IsFeatureOverriddenFromCommandLine(const std::string& feature_name,
-                                          OverrideState state) const;
-
-  // Associates a field trial for reporting purposes corresponding to the
-  // command-line setting the feature state to |for_overridden_state|. The trial
-  // will be activated when the state of the feature is first queried. This
-  // should be called during registration, after InitializeFromCommandLine() has
-  // been called but before the instance is registered via SetInstance().
-  void AssociateReportingFieldTrial(const std::string& feature_name,
-                                    OverrideState for_overridden_state,
-                                    FieldTrial* field_trial);
-
-  // Registers a field trial to override the enabled state of the specified
-  // feature to |override_state|. Command-line overrides still take precedence
-  // over field trials, so this will have no effect if the feature is being
-  // overridden from the command-line. The associated field trial will be
-  // activated when the feature state for this feature is queried. This should
-  // be called during registration, after InitializeFromCommandLine() has been
-  // called but before the instance is registered via SetInstance().
-  void RegisterFieldTrialOverride(const std::string& feature_name,
-                                  OverrideState override_state,
-                                  FieldTrial* field_trial);
-
-  // Loops through feature overrides and serializes them all into |allocator|.
-  void AddFeaturesToAllocator(PersistentMemoryAllocator* allocator);
-
-  // Returns comma-separated lists of feature names (in the same format that is
-  // accepted by InitializeFromCommandLine()) corresponding to features that
-  // have been overridden - either through command-line or via FieldTrials. For
-  // those features that have an associated FieldTrial, the output entry will be
-  // of the format "FeatureName<TrialName", where "TrialName" is the name of the
-  // FieldTrial. Features that have overrides with OVERRIDE_USE_DEFAULT will be
-  // added to |enable_overrides| with a '*' character prefix. Must be called
-  // only after the instance has been initialized and registered.
-  void GetFeatureOverrides(std::string* enable_overrides,
-                           std::string* disable_overrides);
-
-  // Like GetFeatureOverrides(), but only returns overrides that were specified
-  // explicitly on the command-line, omitting the ones from field trials.
-  void GetCommandLineFeatureOverrides(std::string* enable_overrides,
-                                      std::string* disable_overrides);
-
-  // Returns whether the given |feature| is enabled. Must only be called after
-  // the singleton instance has been registered via SetInstance(). Additionally,
-  // a feature with a given name must only have a single corresponding Feature
-  // struct, which is checked in builds with DCHECKs enabled.
-  static bool IsEnabled(const Feature& feature);
-
-  // Returns the field trial associated with the given |feature|. Must only be
-  // called after the singleton instance has been registered via SetInstance().
-  static FieldTrial* GetFieldTrial(const Feature& feature);
-
-  // Splits a comma-separated string containing feature names into a vector. The
-  // resulting pieces point to parts of |input|.
-  static std::vector<base::StringPiece> SplitFeatureListString(
-      base::StringPiece input);
-
-  // Initializes and sets an instance of FeatureList with feature overrides via
-  // command-line flags |enable_features| and |disable_features| if one has not
-  // already been set from command-line flags. Returns true if an instance did
-  // not previously exist. See InitializeFromCommandLine() for more details
-  // about |enable_features| and |disable_features| parameters.
-  static bool InitializeInstance(const std::string& enable_features,
-                                 const std::string& disable_features);
-
-  // Returns the singleton instance of FeatureList. Will return null until an
-  // instance is registered via SetInstance().
-  static FeatureList* GetInstance();
-
-  // Registers the given |instance| to be the singleton feature list for this
-  // process. This should only be called once and |instance| must not be null.
-  // Note: If you are considering using this for the purposes of testing, take
-  // a look at using base/test/scoped_feature_list.h instead.
-  static void SetInstance(std::unique_ptr<FeatureList> instance);
-
-  // Clears the previously-registered singleton instance for tests and returns
-  // the old instance.
-  // Note: Most tests should never call this directly. Instead consider using
-  // base::test::ScopedFeatureList.
-  static std::unique_ptr<FeatureList> ClearInstanceForTesting();
-
-  // Sets a given (initialized) |instance| to be the singleton feature list,
-  // for testing. Existing instance must be null. This is primarily intended
-  // to support base::test::ScopedFeatureList helper class.
-  static void RestoreInstanceForTesting(std::unique_ptr<FeatureList> instance);
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(FeatureListTest, CheckFeatureIdentity);
-  FRIEND_TEST_ALL_PREFIXES(FeatureListTest,
-                           StoreAndRetrieveFeaturesFromSharedMemory);
-  FRIEND_TEST_ALL_PREFIXES(FeatureListTest,
-                           StoreAndRetrieveAssociatedFeaturesFromSharedMemory);
-
-  struct OverrideEntry {
-    // The overridden enable (on/off) state of the feature.
-    const OverrideState overridden_state;
-
-    // An optional associated field trial, which will be activated when the
-    // state of the feature is queried for the first time. Weak pointer to the
-    // FieldTrial object that is owned by the FieldTrialList singleton.
-    base::FieldTrial* field_trial;
-
-    // Specifies whether the feature's state is overridden by |field_trial|.
-    // If it's not, and |field_trial| is not null, it means it is simply an
-    // associated field trial for reporting purposes (and |overridden_state|
-    // came from the command-line).
-    const bool overridden_by_field_trial;
-
-    // TODO(asvitkine): Expand this as more support is added.
-
-    // Constructs an OverrideEntry for the given |overridden_state|. If
-    // |field_trial| is not null, it implies that |overridden_state| comes from
-    // the trial, so |overridden_by_field_trial| will be set to true.
-    OverrideEntry(OverrideState overridden_state, FieldTrial* field_trial);
-  };
-
-  // Finalizes the initialization state of the FeatureList, so that no further
-  // overrides can be registered. This is called by SetInstance() on the
-  // singleton feature list that is being registered.
-  void FinalizeInitialization();
-
-  // Returns whether the given |feature| is enabled. This is invoked by the
-  // public FeatureList::IsEnabled() static function on the global singleton.
-  // Requires the FeatureList to have already been fully initialized.
-  bool IsFeatureEnabled(const Feature& feature);
-
-  // Returns the field trial associated with the given |feature|. This is
-  // invoked by the public FeatureList::GetFieldTrial() static function on the
-  // global singleton. Requires the FeatureList to have already been fully
-  // initialized.
-  base::FieldTrial* GetAssociatedFieldTrial(const Feature& feature);
-
-  // For each feature name in comma-separated list of strings |feature_list|,
-  // registers an override with the specified |overridden_state|. Also, will
-  // associate an optional named field trial if the entry is of the format
-  // "FeatureName<TrialName".
-  void RegisterOverridesFromCommandLine(const std::string& feature_list,
-                                        OverrideState overridden_state);
-
-  // Registers an override for feature |feature_name|. The override specifies
-  // whether the feature should be on or off (via |overridden_state|), which
-  // will take precedence over the feature's default state. If |field_trial| is
-  // not null, registers the specified field trial object to be associated with
-  // the feature, which will activate the field trial when the feature state is
-  // queried. If an override is already registered for the given feature, it
-  // will not be changed.
-  void RegisterOverride(StringPiece feature_name,
-                        OverrideState overridden_state,
-                        FieldTrial* field_trial);
-
-  // Implementation of GetFeatureOverrides() with a parameter that specifies
-  // whether only command-line enabled overrides should be emitted. See that
-  // function's comments for more details.
-  void GetFeatureOverridesImpl(std::string* enable_overrides,
-                               std::string* disable_overrides,
-                               bool command_line_only);
-
-  // Verifies that there's only a single definition of a Feature struct for a
-  // given feature name. Keeps track of the first seen Feature struct for each
-  // feature. Returns false when called on a Feature struct with a different
-  // address than the first one it saw for that feature name. Used only from
-  // DCHECKs and tests.
-  bool CheckFeatureIdentity(const Feature& feature);
-
-  // Map from feature name to an OverrideEntry struct for the feature, if it
-  // exists.
-  std::map<std::string, OverrideEntry> overrides_;
-
-  // Locked map that keeps track of seen features, to ensure a single feature is
-  // only defined once. This verification is only done in builds with DCHECKs
-  // enabled.
-  Lock feature_identity_tracker_lock_;
-  std::map<std::string, const Feature*> feature_identity_tracker_;
-
-  // Whether this object has been fully initialized. This gets set to true as a
-  // result of FinalizeInitialization().
-  bool initialized_ = false;
-
-  // Whether this object has been initialized from command line.
-  bool initialized_from_command_line_ = false;
-
-  DISALLOW_COPY_AND_ASSIGN(FeatureList);
-};
-
-}  // namespace base
-
-#endif  // BASE_FEATURE_LIST_H_
diff --git a/native/zucchini/vendor/libchrome/base/file_descriptor_posix.h b/native/zucchini/vendor/libchrome/base/file_descriptor_posix.h
deleted file mode 100644
index 2a36611..0000000
--- a/native/zucchini/vendor/libchrome/base/file_descriptor_posix.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_FILE_DESCRIPTOR_POSIX_H_
-#define BASE_FILE_DESCRIPTOR_POSIX_H_
-
-#include "base/files/file.h"
-#include "base/files/scoped_file.h"
-
-namespace base {
-
-// -----------------------------------------------------------------------------
-// We introduct a special structure for file descriptors in order that we are
-// able to use template specialisation to special-case their handling.
-//
-// IMPORTANT: This is primarily intended for use when sending file descriptors
-// over IPC. Even if |auto_close| is true, base::FileDescriptor does NOT close()
-// |fd| when going out of scope. Instead, a consumer of a base::FileDescriptor
-// must invoke close() on |fd| if |auto_close| is true.
-//
-// In the case of IPC, the the IPC subsystem knows to close() |fd| after sending
-// a message that contains a base::FileDescriptor if auto_close == true. On the
-// other end, the receiver must make sure to close() |fd| after it has finished
-// processing the IPC message. See the IPC::ParamTraits<> specialization in
-// ipc/ipc_message_utils.h for all the details.
-// -----------------------------------------------------------------------------
-struct FileDescriptor {
-  FileDescriptor() : fd(-1), auto_close(false) {}
-
-  FileDescriptor(int ifd, bool iauto_close) : fd(ifd), auto_close(iauto_close) {
-  }
-
-  FileDescriptor(File file) : fd(file.TakePlatformFile()), auto_close(true) {}
-  explicit FileDescriptor(ScopedFD fd) : fd(fd.release()), auto_close(true) {}
-
-  bool operator==(const FileDescriptor& other) const {
-    return (fd == other.fd && auto_close == other.auto_close);
-  }
-
-  bool operator!=(const FileDescriptor& other) const {
-    return !operator==(other);
-  }
-
-  // A comparison operator so that we can use these as keys in a std::map.
-  bool operator<(const FileDescriptor& other) const {
-    return other.fd < fd;
-  }
-
-  int fd;
-  // If true, this file descriptor should be closed after it has been used. For
-  // example an IPC system might interpret this flag as indicating that the
-  // file descriptor it has been given should be closed after use.
-  bool auto_close;
-};
-
-}  // namespace base
-
-#endif  // BASE_FILE_DESCRIPTOR_POSIX_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/file.h b/native/zucchini/vendor/libchrome/base/files/file.h
deleted file mode 100644
index 30f4053..0000000
--- a/native/zucchini/vendor/libchrome/base/files/file.h
+++ /dev/null
@@ -1,381 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_FILES_FILE_H_
-#define BASE_FILES_FILE_H_
-
-#include <stdint.h>
-
-#include <string>
-
-#include "base/base_export.h"
-#include "base/files/file_path.h"
-#include "base/files/file_tracing.h"
-#include "base/files/platform_file.h"
-#include "base/files/scoped_file.h"
-#include "base/macros.h"
-#include "base/time/time.h"
-#include "build/build_config.h"
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <sys/stat.h>
-#endif
-
-namespace base {
-
-#if defined(OS_BSD) || defined(OS_MACOSX) || defined(OS_NACL) || \
-  defined(OS_FUCHSIA) || (defined(OS_ANDROID) && __ANDROID_API__ < 21)
-typedef struct stat stat_wrapper_t;
-#elif defined(OS_POSIX)
-typedef struct stat64 stat_wrapper_t;
-#endif
-
-// Thin wrapper around an OS-level file.
-// Note that this class does not provide any support for asynchronous IO, other
-// than the ability to create asynchronous handles on Windows.
-//
-// Note about const: this class does not attempt to determine if the underlying
-// file system object is affected by a particular method in order to consider
-// that method const or not. Only methods that deal with member variables in an
-// obvious non-modifying way are marked as const. Any method that forward calls
-// to the OS is not considered const, even if there is no apparent change to
-// member variables.
-class BASE_EXPORT File {
- public:
-  // FLAG_(OPEN|CREATE).* are mutually exclusive. You should specify exactly one
-  // of the five (possibly combining with other flags) when opening or creating
-  // a file.
-  // FLAG_(WRITE|APPEND) are mutually exclusive. This is so that APPEND behavior
-  // will be consistent with O_APPEND on POSIX.
-  // FLAG_EXCLUSIVE_(READ|WRITE) only grant exclusive access to the file on
-  // creation on POSIX; for existing files, consider using Lock().
-  enum Flags {
-    FLAG_OPEN = 1 << 0,            // Opens a file, only if it exists.
-    FLAG_CREATE = 1 << 1,          // Creates a new file, only if it does not
-                                   // already exist.
-    FLAG_OPEN_ALWAYS = 1 << 2,     // May create a new file.
-    FLAG_CREATE_ALWAYS = 1 << 3,   // May overwrite an old file.
-    FLAG_OPEN_TRUNCATED = 1 << 4,  // Opens a file and truncates it, only if it
-                                   // exists.
-    FLAG_READ = 1 << 5,
-    FLAG_WRITE = 1 << 6,
-    FLAG_APPEND = 1 << 7,
-    FLAG_EXCLUSIVE_READ = 1 << 8,  // EXCLUSIVE is opposite of Windows SHARE.
-    FLAG_EXCLUSIVE_WRITE = 1 << 9,
-    FLAG_ASYNC = 1 << 10,
-    FLAG_TEMPORARY = 1 << 11,  // Used on Windows only.
-    FLAG_HIDDEN = 1 << 12,     // Used on Windows only.
-    FLAG_DELETE_ON_CLOSE = 1 << 13,
-    FLAG_WRITE_ATTRIBUTES = 1 << 14,     // Used on Windows only.
-    FLAG_SHARE_DELETE = 1 << 15,         // Used on Windows only.
-    FLAG_TERMINAL_DEVICE = 1 << 16,      // Serial port flags.
-    FLAG_BACKUP_SEMANTICS = 1 << 17,     // Used on Windows only.
-    FLAG_EXECUTE = 1 << 18,              // Used on Windows only.
-    FLAG_SEQUENTIAL_SCAN = 1 << 19,      // Used on Windows only.
-    FLAG_CAN_DELETE_ON_CLOSE = 1 << 20,  // Requests permission to delete a file
-                                         // via DeleteOnClose() (Windows only).
-                                         // See DeleteOnClose() for details.
-  };
-
-  // This enum has been recorded in multiple histograms using PlatformFileError
-  // enum. If the order of the fields needs to change, please ensure that those
-  // histograms are obsolete or have been moved to a different enum.
-  //
-  // FILE_ERROR_ACCESS_DENIED is returned when a call fails because of a
-  // filesystem restriction. FILE_ERROR_SECURITY is returned when a browser
-  // policy doesn't allow the operation to be executed.
-  enum Error {
-    FILE_OK = 0,
-    FILE_ERROR_FAILED = -1,
-    FILE_ERROR_IN_USE = -2,
-    FILE_ERROR_EXISTS = -3,
-    FILE_ERROR_NOT_FOUND = -4,
-    FILE_ERROR_ACCESS_DENIED = -5,
-    FILE_ERROR_TOO_MANY_OPENED = -6,
-    FILE_ERROR_NO_MEMORY = -7,
-    FILE_ERROR_NO_SPACE = -8,
-    FILE_ERROR_NOT_A_DIRECTORY = -9,
-    FILE_ERROR_INVALID_OPERATION = -10,
-    FILE_ERROR_SECURITY = -11,
-    FILE_ERROR_ABORT = -12,
-    FILE_ERROR_NOT_A_FILE = -13,
-    FILE_ERROR_NOT_EMPTY = -14,
-    FILE_ERROR_INVALID_URL = -15,
-    FILE_ERROR_IO = -16,
-    // Put new entries here and increment FILE_ERROR_MAX.
-    FILE_ERROR_MAX = -17
-  };
-
-  // This explicit mapping matches both FILE_ on Windows and SEEK_ on Linux.
-  enum Whence {
-    FROM_BEGIN   = 0,
-    FROM_CURRENT = 1,
-    FROM_END     = 2
-  };
-
-  // Used to hold information about a given file.
-  // If you add more fields to this structure (platform-specific fields are OK),
-  // make sure to update all functions that use it in file_util_{win|posix}.cc,
-  // too, and the ParamTraits<base::File::Info> implementation in
-  // ipc/ipc_message_utils.cc.
-  struct BASE_EXPORT Info {
-    Info();
-    ~Info();
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-    // Fills this struct with values from |stat_info|.
-    void FromStat(const stat_wrapper_t& stat_info);
-#endif
-
-    // The size of the file in bytes.  Undefined when is_directory is true.
-    int64_t size;
-
-    // True if the file corresponds to a directory.
-    bool is_directory;
-
-    // True if the file corresponds to a symbolic link.  For Windows currently
-    // not supported and thus always false.
-    bool is_symbolic_link;
-
-    // The last modified time of a file.
-    Time last_modified;
-
-    // The last accessed time of a file.
-    Time last_accessed;
-
-    // The creation time of a file.
-    Time creation_time;
-  };
-
-  File();
-
-  // Creates or opens the given file. This will fail with 'access denied' if the
-  // |path| contains path traversal ('..') components.
-  File(const FilePath& path, uint32_t flags);
-
-  // Takes ownership of |platform_file| and sets async to false.
-  explicit File(PlatformFile platform_file);
-
-  // Takes ownership of |platform_file| and sets async to the given value.
-  // This constructor exists because on Windows you can't check if platform_file
-  // is async or not.
-  File(PlatformFile platform_file, bool async);
-
-  // Creates an object with a specific error_details code.
-  explicit File(Error error_details);
-
-  File(File&& other);
-
-  ~File();
-
-  File& operator=(File&& other);
-
-  // Creates or opens the given file.
-  void Initialize(const FilePath& path, uint32_t flags);
-
-  // Returns |true| if the handle / fd wrapped by this object is valid.  This
-  // method doesn't interact with the file system (and is safe to be called from
-  // ThreadRestrictions::SetIOAllowed(false) threads).
-  bool IsValid() const;
-
-  // Returns true if a new file was created (or an old one truncated to zero
-  // length to simulate a new file, which can happen with
-  // FLAG_CREATE_ALWAYS), and false otherwise.
-  bool created() const { return created_; }
-
-  // Returns the OS result of opening this file. Note that the way to verify
-  // the success of the operation is to use IsValid(), not this method:
-  //   File file(path, flags);
-  //   if (!file.IsValid())
-  //     return;
-  Error error_details() const { return error_details_; }
-
-  PlatformFile GetPlatformFile() const;
-  PlatformFile TakePlatformFile();
-
-  // Destroying this object closes the file automatically.
-  void Close();
-
-  // Changes current position in the file to an |offset| relative to an origin
-  // defined by |whence|. Returns the resultant current position in the file
-  // (relative to the start) or -1 in case of error.
-  int64_t Seek(Whence whence, int64_t offset);
-
-  // Reads the given number of bytes (or until EOF is reached) starting with the
-  // given offset. Returns the number of bytes read, or -1 on error. Note that
-  // this function makes a best effort to read all data on all platforms, so it
-  // is not intended for stream oriented files but instead for cases when the
-  // normal expectation is that actually |size| bytes are read unless there is
-  // an error.
-  int Read(int64_t offset, char* data, int size);
-
-  // Same as above but without seek.
-  int ReadAtCurrentPos(char* data, int size);
-
-  // Reads the given number of bytes (or until EOF is reached) starting with the
-  // given offset, but does not make any effort to read all data on all
-  // platforms. Returns the number of bytes read, or -1 on error.
-  int ReadNoBestEffort(int64_t offset, char* data, int size);
-
-  // Same as above but without seek.
-  int ReadAtCurrentPosNoBestEffort(char* data, int size);
-
-  // Writes the given buffer into the file at the given offset, overwritting any
-  // data that was previously there. Returns the number of bytes written, or -1
-  // on error. Note that this function makes a best effort to write all data on
-  // all platforms. |data| can be nullptr when |size| is 0.
-  // Ignores the offset and writes to the end of the file if the file was opened
-  // with FLAG_APPEND.
-  int Write(int64_t offset, const char* data, int size);
-
-  // Save as above but without seek.
-  int WriteAtCurrentPos(const char* data, int size);
-
-  // Save as above but does not make any effort to write all data on all
-  // platforms. Returns the number of bytes written, or -1 on error.
-  int WriteAtCurrentPosNoBestEffort(const char* data, int size);
-
-  // Returns the current size of this file, or a negative number on failure.
-  int64_t GetLength();
-
-  // Truncates the file to the given length. If |length| is greater than the
-  // current size of the file, the file is extended with zeros. If the file
-  // doesn't exist, |false| is returned.
-  bool SetLength(int64_t length);
-
-  // Instructs the filesystem to flush the file to disk. (POSIX: fsync, Windows:
-  // FlushFileBuffers).
-  // Calling Flush() does not guarantee file integrity and thus is not a valid
-  // substitute for file integrity checks and recovery codepaths for malformed
-  // files. It can also be *really* slow, so avoid blocking on Flush(),
-  // especially please don't block shutdown on Flush().
-  // Latency percentiles of Flush() across all platforms as of July 2016:
-  // 50 %     > 5 ms
-  // 10 %     > 58 ms
-  //  1 %     > 357 ms
-  //  0.1 %   > 1.8 seconds
-  //  0.01 %  > 7.6 seconds
-  bool Flush();
-
-  // Updates the file times.
-  bool SetTimes(Time last_access_time, Time last_modified_time);
-
-  // Returns some basic information for the given file.
-  bool GetInfo(Info* info);
-
-#if !defined(OS_FUCHSIA)  // Fuchsia's POSIX API does not support file locking.
-
-  // Attempts to take an exclusive write lock on the file. Returns immediately
-  // (i.e. does not wait for another process to unlock the file). If the lock
-  // was obtained, the result will be FILE_OK. A lock only guarantees
-  // that other processes may not also take a lock on the same file with the
-  // same API - it may still be opened, renamed, unlinked, etc.
-  //
-  // Common semantics:
-  //  * Locks are held by processes, but not inherited by child processes.
-  //  * Locks are released by the OS on file close or process termination.
-  //  * Locks are reliable only on local filesystems.
-  //  * Duplicated file handles may also write to locked files.
-  // Windows-specific semantics:
-  //  * Locks are mandatory for read/write APIs, advisory for mapping APIs.
-  //  * Within a process, locking the same file (by the same or new handle)
-  //    will fail.
-  // POSIX-specific semantics:
-  //  * Locks are advisory only.
-  //  * Within a process, locking the same file (by the same or new handle)
-  //    will succeed.
-  //  * Closing any descriptor on a given file releases the lock.
-  Error Lock();
-
-  // Unlock a file previously locked.
-  Error Unlock();
-
-#endif  // !defined(OS_FUCHSIA)
-
-  // Returns a new object referencing this file for use within the current
-  // process. Handling of FLAG_DELETE_ON_CLOSE varies by OS. On POSIX, the File
-  // object that was created or initialized with this flag will have unlinked
-  // the underlying file when it was created or opened. On Windows, the
-  // underlying file is deleted when the last handle to it is closed.
-  File Duplicate() const;
-
-  bool async() const { return async_; }
-
-#if defined(OS_WIN)
-  // Sets or clears the DeleteFile disposition on the file. Returns true if
-  // the disposition was set or cleared, as indicated by |delete_on_close|.
-  //
-  // Microsoft Windows deletes a file only when the DeleteFile disposition is
-  // set on a file when the last handle to the last underlying kernel File
-  // object is closed. This disposition is be set by:
-  // - Calling the Win32 DeleteFile function with the path to a file.
-  // - Opening/creating a file with FLAG_DELETE_ON_CLOSE and then closing all
-  //   handles to that File object.
-  // - Opening/creating a file with FLAG_CAN_DELETE_ON_CLOSE and subsequently
-  //   calling DeleteOnClose(true).
-  //
-  // In all cases, all pre-existing handles to the file must have been opened
-  // with FLAG_SHARE_DELETE. Once the disposition has been set by any of the
-  // above means, no new File objects can be created for the file.
-  //
-  // So:
-  // - Use FLAG_SHARE_DELETE when creating/opening a file to allow another
-  //   entity on the system to cause it to be deleted when it is closed. (Note:
-  //   another entity can delete the file the moment after it is closed, so not
-  //   using this permission doesn't provide any protections.)
-  // - Use FLAG_DELETE_ON_CLOSE for any file that is to be deleted after use.
-  //   The OS will ensure it is deleted even in the face of process termination.
-  //   Note that it's possible for deletion to be cancelled via another File
-  //   object referencing the same file using DeleteOnClose(false) to clear the
-  //   DeleteFile disposition after the original File is closed.
-  // - Use FLAG_CAN_DELETE_ON_CLOSE in conjunction with DeleteOnClose() to alter
-  //   the DeleteFile disposition on an open handle. This fine-grained control
-  //   allows for marking a file for deletion during processing so that it is
-  //   deleted in the event of untimely process termination, and then clearing
-  //   this state once the file is suitable for persistence.
-  bool DeleteOnClose(bool delete_on_close);
-#endif
-
-#if defined(OS_WIN)
-  static Error OSErrorToFileError(DWORD last_error);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  static Error OSErrorToFileError(int saved_errno);
-#endif
-
-  // Gets the last global error (errno or GetLastError()) and converts it to the
-  // closest base::File::Error equivalent via OSErrorToFileError(). The returned
-  // value is only trustworthy immediately after another base::File method
-  // fails. base::File never resets the global error to zero.
-  static Error GetLastFileError();
-
-  // Converts an error value to a human-readable form. Used for logging.
-  static std::string ErrorToString(Error error);
-
- private:
-  friend class FileTracing::ScopedTrace;
-
-  // Creates or opens the given file. Only called if |path| has no
-  // traversal ('..') components.
-  void DoInitialize(const FilePath& path, uint32_t flags);
-
-  void SetPlatformFile(PlatformFile file);
-
-  ScopedPlatformFile file_;
-
-  // A path to use for tracing purposes. Set if file tracing is enabled during
-  // |Initialize()|.
-  FilePath tracing_path_;
-
-  // Object tied to the lifetime of |this| that enables/disables tracing.
-  FileTracing::ScopedEnabler trace_enabler_;
-
-  Error error_details_;
-  bool created_;
-  bool async_;
-
-  DISALLOW_COPY_AND_ASSIGN(File);
-};
-
-}  // namespace base
-
-#endif  // BASE_FILES_FILE_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/file_path.h b/native/zucchini/vendor/libchrome/base/files/file_path.h
deleted file mode 100644
index 2dc15f9..0000000
--- a/native/zucchini/vendor/libchrome/base/files/file_path.h
+++ /dev/null
@@ -1,481 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// FilePath is a container for pathnames stored in a platform's native string
-// type, providing containers for manipulation in according with the
-// platform's conventions for pathnames.  It supports the following path
-// types:
-//
-//                   POSIX            Windows
-//                   ---------------  ----------------------------------
-// Fundamental type  char[]           wchar_t[]
-// Encoding          unspecified*     UTF-16
-// Separator         /                \, tolerant of /
-// Drive letters     no               case-insensitive A-Z followed by :
-// Alternate root    // (surprise!)   \\, for UNC paths
-//
-// * The encoding need not be specified on POSIX systems, although some
-//   POSIX-compliant systems do specify an encoding.  Mac OS X uses UTF-8.
-//   Chrome OS also uses UTF-8.
-//   Linux does not specify an encoding, but in practice, the locale's
-//   character set may be used.
-//
-// For more arcane bits of path trivia, see below.
-//
-// FilePath objects are intended to be used anywhere paths are.  An
-// application may pass FilePath objects around internally, masking the
-// underlying differences between systems, only differing in implementation
-// where interfacing directly with the system.  For example, a single
-// OpenFile(const FilePath &) function may be made available, allowing all
-// callers to operate without regard to the underlying implementation.  On
-// POSIX-like platforms, OpenFile might wrap fopen, and on Windows, it might
-// wrap _wfopen_s, perhaps both by calling file_path.value().c_str().  This
-// allows each platform to pass pathnames around without requiring conversions
-// between encodings, which has an impact on performance, but more imporantly,
-// has an impact on correctness on platforms that do not have well-defined
-// encodings for pathnames.
-//
-// Several methods are available to perform common operations on a FilePath
-// object, such as determining the parent directory (DirName), isolating the
-// final path component (BaseName), and appending a relative pathname string
-// to an existing FilePath object (Append).  These methods are highly
-// recommended over attempting to split and concatenate strings directly.
-// These methods are based purely on string manipulation and knowledge of
-// platform-specific pathname conventions, and do not consult the filesystem
-// at all, making them safe to use without fear of blocking on I/O operations.
-// These methods do not function as mutators but instead return distinct
-// instances of FilePath objects, and are therefore safe to use on const
-// objects.  The objects themselves are safe to share between threads.
-//
-// To aid in initialization of FilePath objects from string literals, a
-// FILE_PATH_LITERAL macro is provided, which accounts for the difference
-// between char[]-based pathnames on POSIX systems and wchar_t[]-based
-// pathnames on Windows.
-//
-// As a precaution against premature truncation, paths can't contain NULs.
-//
-// Because a FilePath object should not be instantiated at the global scope,
-// instead, use a FilePath::CharType[] and initialize it with
-// FILE_PATH_LITERAL.  At runtime, a FilePath object can be created from the
-// character array.  Example:
-//
-// | const FilePath::CharType kLogFileName[] = FILE_PATH_LITERAL("log.txt");
-// |
-// | void Function() {
-// |   FilePath log_file_path(kLogFileName);
-// |   [...]
-// | }
-//
-// WARNING: FilePaths should ALWAYS be displayed with LTR directionality, even
-// when the UI language is RTL. This means you always need to pass filepaths
-// through base::i18n::WrapPathWithLTRFormatting() before displaying it in the
-// RTL UI.
-//
-// This is a very common source of bugs, please try to keep this in mind.
-//
-// ARCANE BITS OF PATH TRIVIA
-//
-//  - A double leading slash is actually part of the POSIX standard.  Systems
-//    are allowed to treat // as an alternate root, as Windows does for UNC
-//    (network share) paths.  Most POSIX systems don't do anything special
-//    with two leading slashes, but FilePath handles this case properly
-//    in case it ever comes across such a system.  FilePath needs this support
-//    for Windows UNC paths, anyway.
-//    References:
-//    The Open Group Base Specifications Issue 7, sections 3.267 ("Pathname")
-//    and 4.12 ("Pathname Resolution"), available at:
-//    http://www.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap03.html#tag_03_267
-//    http://www.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_12
-//
-//  - Windows treats c:\\ the same way it treats \\.  This was intended to
-//    allow older applications that require drive letters to support UNC paths
-//    like \\server\share\path, by permitting c:\\server\share\path as an
-//    equivalent.  Since the OS treats these paths specially, FilePath needs
-//    to do the same.  Since Windows can use either / or \ as the separator,
-//    FilePath treats c://, c:\\, //, and \\ all equivalently.
-//    Reference:
-//    The Old New Thing, "Why is a drive letter permitted in front of UNC
-//    paths (sometimes)?", available at:
-//    http://blogs.msdn.com/oldnewthing/archive/2005/11/22/495740.aspx
-
-#ifndef BASE_FILES_FILE_PATH_H_
-#define BASE_FILES_FILE_PATH_H_
-
-#include <stddef.h>
-
-#include <iosfwd>
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-#include "build/build_config.h"
-
-// Windows-style drive letter support and pathname separator characters can be
-// enabled and disabled independently, to aid testing.  These #defines are
-// here so that the same setting can be used in both the implementation and
-// in the unit test.
-#if defined(OS_WIN)
-#define FILE_PATH_USES_DRIVE_LETTERS
-#define FILE_PATH_USES_WIN_SEPARATORS
-#endif  // OS_WIN
-
-// To print path names portably use PRIsFP (based on PRIuS and friends from
-// C99 and format_macros.h) like this:
-// base::StringPrintf("Path is %" PRIsFP ".\n", path.value().c_str());
-#if defined(OS_WIN)
-#define PRIsFP "ls"
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#define PRIsFP "s"
-#endif  // OS_WIN
-
-namespace base {
-
-class Pickle;
-class PickleIterator;
-
-// An abstraction to isolate users from the differences between native
-// pathnames on different platforms.
-class BASE_EXPORT FilePath {
- public:
-#if defined(OS_WIN)
-  // On Windows, for Unicode-aware applications, native pathnames are wchar_t
-  // arrays encoded in UTF-16.
-  typedef std::wstring StringType;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  // On most platforms, native pathnames are char arrays, and the encoding
-  // may or may not be specified.  On Mac OS X, native pathnames are encoded
-  // in UTF-8.
-  typedef std::string StringType;
-#endif  // OS_WIN
-
-  typedef BasicStringPiece<StringType> StringPieceType;
-  typedef StringType::value_type CharType;
-
-  // Null-terminated array of separators used to separate components in
-  // hierarchical paths.  Each character in this array is a valid separator,
-  // but kSeparators[0] is treated as the canonical separator and will be used
-  // when composing pathnames.
-  static const CharType kSeparators[];
-
-  // arraysize(kSeparators).
-  static const size_t kSeparatorsLength;
-
-  // A special path component meaning "this directory."
-  static const CharType kCurrentDirectory[];
-
-  // A special path component meaning "the parent directory."
-  static const CharType kParentDirectory[];
-
-  // The character used to identify a file extension.
-  static const CharType kExtensionSeparator;
-
-  FilePath();
-  FilePath(const FilePath& that);
-  explicit FilePath(StringPieceType path);
-  ~FilePath();
-  FilePath& operator=(const FilePath& that);
-
-  // Constructs FilePath with the contents of |that|, which is left in valid but
-  // unspecified state.
-  FilePath(FilePath&& that) noexcept;
-  // Replaces the contents with those of |that|, which is left in valid but
-  // unspecified state.
-  FilePath& operator=(FilePath&& that);
-
-  bool operator==(const FilePath& that) const;
-
-  bool operator!=(const FilePath& that) const;
-
-  // Required for some STL containers and operations
-  bool operator<(const FilePath& that) const {
-    return path_ < that.path_;
-  }
-
-  const StringType& value() const { return path_; }
-
-  bool empty() const { return path_.empty(); }
-
-  void clear() { path_.clear(); }
-
-  // Returns true if |character| is in kSeparators.
-  static bool IsSeparator(CharType character);
-
-  // Returns a vector of all of the components of the provided path. It is
-  // equivalent to calling DirName().value() on the path's root component,
-  // and BaseName().value() on each child component.
-  //
-  // To make sure this is lossless so we can differentiate absolute and
-  // relative paths, the root slash will be included even though no other
-  // slashes will be. The precise behavior is:
-  //
-  // Posix:  "/foo/bar"  ->  [ "/", "foo", "bar" ]
-  // Windows:  "C:\foo\bar"  ->  [ "C:", "\\", "foo", "bar" ]
-  void GetComponents(std::vector<FilePath::StringType>* components) const;
-
-  // Returns true if this FilePath is a strict parent of the |child|. Absolute
-  // and relative paths are accepted i.e. is /foo parent to /foo/bar and
-  // is foo parent to foo/bar. Does not convert paths to absolute, follow
-  // symlinks or directory navigation (e.g. ".."). A path is *NOT* its own
-  // parent.
-  bool IsParent(const FilePath& child) const;
-
-  // If IsParent(child) holds, appends to path (if non-NULL) the
-  // relative path to child and returns true.  For example, if parent
-  // holds "/Users/johndoe/Library/Application Support", child holds
-  // "/Users/johndoe/Library/Application Support/Google/Chrome/Default", and
-  // *path holds "/Users/johndoe/Library/Caches", then after
-  // parent.AppendRelativePath(child, path) is called *path will hold
-  // "/Users/johndoe/Library/Caches/Google/Chrome/Default".  Otherwise,
-  // returns false.
-  bool AppendRelativePath(const FilePath& child, FilePath* path) const;
-
-  // Returns a FilePath corresponding to the directory containing the path
-  // named by this object, stripping away the file component.  If this object
-  // only contains one component, returns a FilePath identifying
-  // kCurrentDirectory.  If this object already refers to the root directory,
-  // returns a FilePath identifying the root directory. Please note that this
-  // doesn't resolve directory navigation, e.g. the result for "../a" is "..".
-  FilePath DirName() const WARN_UNUSED_RESULT;
-
-  // Returns a FilePath corresponding to the last path component of this
-  // object, either a file or a directory.  If this object already refers to
-  // the root directory, returns a FilePath identifying the root directory;
-  // this is the only situation in which BaseName will return an absolute path.
-  FilePath BaseName() const WARN_UNUSED_RESULT;
-
-  // Returns ".jpg" for path "C:\pics\jojo.jpg", or an empty string if
-  // the file has no extension.  If non-empty, Extension() will always start
-  // with precisely one ".".  The following code should always work regardless
-  // of the value of path.  For common double-extensions like .tar.gz and
-  // .user.js, this method returns the combined extension.  For a single
-  // component, use FinalExtension().
-  // new_path = path.RemoveExtension().value().append(path.Extension());
-  // ASSERT(new_path == path.value());
-  // NOTE: this is different from the original file_util implementation which
-  // returned the extension without a leading "." ("jpg" instead of ".jpg")
-  StringType Extension() const WARN_UNUSED_RESULT;
-
-  // Returns the path's file extension, as in Extension(), but will
-  // never return a double extension.
-  //
-  // TODO(davidben): Check all our extension-sensitive code to see if
-  // we can rename this to Extension() and the other to something like
-  // LongExtension(), defaulting to short extensions and leaving the
-  // long "extensions" to logic like base::GetUniquePathNumber().
-  StringType FinalExtension() const WARN_UNUSED_RESULT;
-
-  // Returns "C:\pics\jojo" for path "C:\pics\jojo.jpg"
-  // NOTE: this is slightly different from the similar file_util implementation
-  // which returned simply 'jojo'.
-  FilePath RemoveExtension() const WARN_UNUSED_RESULT;
-
-  // Removes the path's file extension, as in RemoveExtension(), but
-  // ignores double extensions.
-  FilePath RemoveFinalExtension() const WARN_UNUSED_RESULT;
-
-  // Inserts |suffix| after the file name portion of |path| but before the
-  // extension.  Returns "" if BaseName() == "." or "..".
-  // Examples:
-  // path == "C:\pics\jojo.jpg" suffix == " (1)", returns "C:\pics\jojo (1).jpg"
-  // path == "jojo.jpg"         suffix == " (1)", returns "jojo (1).jpg"
-  // path == "C:\pics\jojo"     suffix == " (1)", returns "C:\pics\jojo (1)"
-  // path == "C:\pics.old\jojo" suffix == " (1)", returns "C:\pics.old\jojo (1)"
-  FilePath InsertBeforeExtension(
-      StringPieceType suffix) const WARN_UNUSED_RESULT;
-  FilePath InsertBeforeExtensionASCII(
-      StringPiece suffix) const WARN_UNUSED_RESULT;
-
-  // Adds |extension| to |file_name|. Returns the current FilePath if
-  // |extension| is empty. Returns "" if BaseName() == "." or "..".
-  FilePath AddExtension(StringPieceType extension) const WARN_UNUSED_RESULT;
-
-  // 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|.
-  // Returns "" if BaseName() == "." or "..".
-  FilePath ReplaceExtension(StringPieceType extension) const WARN_UNUSED_RESULT;
-
-  // Returns true if the file path matches the specified extension. The test is
-  // case insensitive. Don't forget the leading period if appropriate.
-  bool MatchesExtension(StringPieceType extension) const;
-
-  // Returns a FilePath by appending a separator and the supplied path
-  // component to this object's path.  Append takes care to avoid adding
-  // excessive separators if this object's path already ends with a separator.
-  // If this object's path is kCurrentDirectory, a new FilePath corresponding
-  // only to |component| is returned.  |component| must be a relative path;
-  // it is an error to pass an absolute path.
-  FilePath Append(StringPieceType component) const WARN_UNUSED_RESULT;
-  FilePath Append(const FilePath& component) const WARN_UNUSED_RESULT;
-
-  // Although Windows StringType is std::wstring, since the encoding it uses for
-  // paths is well defined, it can handle ASCII path components as well.
-  // Mac uses UTF8, and since ASCII is a subset of that, it works there as well.
-  // On Linux, although it can use any 8-bit encoding for paths, we assume that
-  // ASCII is a valid subset, regardless of the encoding, since many operating
-  // system paths will always be ASCII.
-  FilePath AppendASCII(StringPiece component) const WARN_UNUSED_RESULT;
-
-  // 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
-  // platforms, an absolute path begins with a separator character.
-  bool IsAbsolute() const;
-
-  // Returns true if the patch ends with a path separator character.
-  bool EndsWithSeparator() const WARN_UNUSED_RESULT;
-
-  // Returns a copy of this FilePath that ends with a trailing separator. If
-  // the input path is empty, an empty FilePath will be returned.
-  FilePath AsEndingWithSeparator() const WARN_UNUSED_RESULT;
-
-  // Returns a copy of this FilePath that does not end with a trailing
-  // separator.
-  FilePath StripTrailingSeparators() const WARN_UNUSED_RESULT;
-
-  // Returns true if this FilePath contains an attempt to reference a parent
-  // directory (e.g. has a path component that is "..").
-  bool ReferencesParent() const;
-
-  // Return a Unicode human-readable version of this path.
-  // Warning: you can *not*, in general, go from a display name back to a real
-  // path.  Only use this when displaying paths to users, not just when you
-  // want to stuff a string16 into some other API.
-  string16 LossyDisplayName() const;
-
-  // Return the path as ASCII, or the empty string if the path is not ASCII.
-  // This should only be used for cases where the FilePath is representing a
-  // known-ASCII filename.
-  std::string MaybeAsASCII() const;
-
-  // Return the path as UTF-8.
-  //
-  // This function is *unsafe* as there is no way to tell what encoding is
-  // used in file names on POSIX systems other than Mac and Chrome OS,
-  // although UTF-8 is practically used everywhere these days. To mitigate
-  // the encoding issue, this function internally calls
-  // SysNativeMBToWide() on POSIX systems other than Mac and Chrome OS,
-  // per assumption that the current locale's encoding is used in file
-  // names, but this isn't a perfect solution.
-  //
-  // Once it becomes safe to to stop caring about non-UTF-8 file names,
-  // the SysNativeMBToWide() hack will be removed from the code, along
-  // with "Unsafe" in the function name.
-  std::string AsUTF8Unsafe() const;
-
-  // Similar to AsUTF8Unsafe, but returns UTF-16 instead.
-  string16 AsUTF16Unsafe() const;
-
-  // Returns a FilePath object from a path name in UTF-8. This function
-  // should only be used for cases where you are sure that the input
-  // string is UTF-8.
-  //
-  // Like AsUTF8Unsafe(), this function is unsafe. This function
-  // internally calls SysWideToNativeMB() on POSIX systems other than Mac
-  // and Chrome OS, to mitigate the encoding issue. See the comment at
-  // AsUTF8Unsafe() for details.
-  static FilePath FromUTF8Unsafe(StringPiece utf8);
-
-  // Similar to FromUTF8Unsafe, but accepts UTF-16 instead.
-  static FilePath FromUTF16Unsafe(StringPiece16 utf16);
-
-  void WriteToPickle(Pickle* pickle) const;
-  bool ReadFromPickle(PickleIterator* iter);
-
-  // Normalize all path separators to backslash on Windows
-  // (if FILE_PATH_USES_WIN_SEPARATORS is true), or do nothing on POSIX systems.
-  FilePath NormalizePathSeparators() const;
-
-  // Normalize all path separattors to given type on Windows
-  // (if FILE_PATH_USES_WIN_SEPARATORS is true), or do nothing on POSIX systems.
-  FilePath NormalizePathSeparatorsTo(CharType separator) const;
-
-  // Compare two strings in the same way the file system does.
-  // Note that these always ignore case, even on file systems that are case-
-  // sensitive. If case-sensitive comparison is ever needed, add corresponding
-  // methods here.
-  // The methods are written as a static method so that they can also be used
-  // on parts of a file path, e.g., just the extension.
-  // CompareIgnoreCase() returns -1, 0 or 1 for less-than, equal-to and
-  // greater-than respectively.
-  static int CompareIgnoreCase(StringPieceType string1,
-                               StringPieceType string2);
-  static bool CompareEqualIgnoreCase(StringPieceType string1,
-                                     StringPieceType string2) {
-    return CompareIgnoreCase(string1, string2) == 0;
-  }
-  static bool CompareLessIgnoreCase(StringPieceType string1,
-                                    StringPieceType string2) {
-    return CompareIgnoreCase(string1, string2) < 0;
-  }
-
-#if defined(OS_MACOSX)
-  // Returns the string in the special canonical decomposed form as defined for
-  // HFS, which is close to, but not quite, decomposition form D. See
-  // http://developer.apple.com/mac/library/technotes/tn/tn1150.html#UnicodeSubtleties
-  // for further comments.
-  // Returns the epmty string if the conversion failed.
-  static StringType GetHFSDecomposedForm(StringPieceType string);
-
-  // Special UTF-8 version of FastUnicodeCompare. Cf:
-  // http://developer.apple.com/mac/library/technotes/tn/tn1150.html#StringComparisonAlgorithm
-  // IMPORTANT: The input strings must be in the special HFS decomposed form!
-  // (cf. above GetHFSDecomposedForm method)
-  static int HFSFastUnicodeCompare(StringPieceType string1,
-                                   StringPieceType string2);
-#endif
-
-#if defined(OS_ANDROID)
-  // On android, file selection dialog can return a file with content uri
-  // scheme(starting with content://). Content uri needs to be opened with
-  // ContentResolver to guarantee that the app has appropriate permissions
-  // to access it.
-  // Returns true if the path is a content uri, or false otherwise.
-  bool IsContentUri() const;
-#endif
-
- private:
-  // Remove trailing separators from this object.  If the path is absolute, it
-  // will never be stripped any more than to refer to the absolute root
-  // directory, so "////" will become "/", not "".  A leading pair of
-  // separators is never stripped, to support alternate roots.  This is used to
-  // support UNC paths on Windows.
-  void StripTrailingSeparatorsInternal();
-
-  StringType path_;
-};
-
-BASE_EXPORT std::ostream& operator<<(std::ostream& out,
-                                     const FilePath& file_path);
-
-}  // namespace base
-
-// Macros for string literal initialization of FilePath::CharType[], and for
-// using a FilePath::CharType[] in a printf-style format string.
-#if defined(OS_WIN)
-#define FILE_PATH_LITERAL(x) L ## x
-#define PRFilePath "ls"
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#define FILE_PATH_LITERAL(x) x
-#define PRFilePath "s"
-#endif  // OS_WIN
-
-namespace std {
-
-template <>
-struct hash<base::FilePath> {
-  typedef base::FilePath argument_type;
-  typedef std::size_t result_type;
-  result_type operator()(argument_type const& f) const {
-    return hash<base::FilePath::StringType>()(f.value());
-  }
-};
-
-}  // namespace std
-
-#endif  // BASE_FILES_FILE_PATH_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/file_tracing.h b/native/zucchini/vendor/libchrome/base/files/file_tracing.h
deleted file mode 100644
index 1fbfcd4..0000000
--- a/native/zucchini/vendor/libchrome/base/files/file_tracing.h
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_FILES_FILE_TRACING_H_
-#define BASE_FILES_FILE_TRACING_H_
-
-#include <stdint.h>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-
-#define FILE_TRACING_PREFIX "File"
-
-#define SCOPED_FILE_TRACE_WITH_SIZE(name, size) \
-    FileTracing::ScopedTrace scoped_file_trace; \
-    if (FileTracing::IsCategoryEnabled()) \
-      scoped_file_trace.Initialize(FILE_TRACING_PREFIX "::" name, this, size)
-
-#define SCOPED_FILE_TRACE(name) SCOPED_FILE_TRACE_WITH_SIZE(name, 0)
-
-namespace base {
-
-class File;
-class FilePath;
-
-class BASE_EXPORT FileTracing {
- public:
-  // Whether the file tracing category is enabled.
-  static bool IsCategoryEnabled();
-
-  class Provider {
-   public:
-    virtual ~Provider() = default;
-
-    // Whether the file tracing category is currently enabled.
-    virtual bool FileTracingCategoryIsEnabled() const = 0;
-
-    // Enables file tracing for |id|. Must be called before recording events.
-    virtual void FileTracingEnable(const void* id) = 0;
-
-    // Disables file tracing for |id|.
-    virtual void FileTracingDisable(const void* id) = 0;
-
-    // Begins an event for |id| with |name|. |path| tells where in the directory
-    // structure the event is happening (and may be blank). |size| is the number
-    // of bytes involved in the event.
-    virtual void FileTracingEventBegin(const char* name,
-                                       const void* id,
-                                       const FilePath& path,
-                                       int64_t size) = 0;
-
-    // Ends an event for |id| with |name|.
-    virtual void FileTracingEventEnd(const char* name, const void* id) = 0;
-  };
-
-  // Sets a global file tracing provider to query categories and record events.
-  static void SetProvider(Provider* provider);
-
-  // Enables file tracing while in scope.
-  class ScopedEnabler {
-   public:
-    ScopedEnabler();
-    ~ScopedEnabler();
-  };
-
-  class ScopedTrace {
-   public:
-    ScopedTrace();
-    ~ScopedTrace();
-
-    // Called only if the tracing category is enabled. |name| is the name of the
-    // event to trace (e.g. "Read", "Write") and must have an application
-    // lifetime (e.g. static or literal). |file| is the file being traced; must
-    // outlive this class. |size| is the size (in bytes) of this event.
-    void Initialize(const char* name, const File* file, int64_t size);
-
-   private:
-    // The ID of this trace. Based on the |file| passed to |Initialize()|. Must
-    // outlive this class.
-    const void* id_;
-
-    // The name of the event to trace (e.g. "Read", "Write"). Prefixed with
-    // "File".
-    const char* name_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedTrace);
-  };
-
-  DISALLOW_COPY_AND_ASSIGN(FileTracing);
-};
-
-}  // namespace base
-
-#endif  // BASE_FILES_FILE_TRACING_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/file_util.h b/native/zucchini/vendor/libchrome/base/files/file_util.h
deleted file mode 100644
index 456962a..0000000
--- a/native/zucchini/vendor/libchrome/base/files/file_util.h
+++ /dev/null
@@ -1,498 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This file contains utility functions for dealing with the local
-// filesystem.
-
-#ifndef BASE_FILES_FILE_UTIL_H_
-#define BASE_FILES_FILE_UTIL_H_
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#include <set>
-#include <string>
-#include <vector>
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <sys/stat.h>
-#include <unistd.h>
-#endif
-
-#include "base/base_export.h"
-#include "base/files/file.h"
-#include "base/files/file_path.h"
-#include "base/strings/string16.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include "base/win/windows_types.h"
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include "base/file_descriptor_posix.h"
-#include "base/logging.h"
-#include "base/posix/eintr_wrapper.h"
-#endif
-
-namespace base {
-
-class Environment;
-class Time;
-
-//-----------------------------------------------------------------------------
-// Functions that involve filesystem access or modification:
-
-// Returns an absolute version of a relative path. Returns an empty path on
-// error. On POSIX, this function fails if the path does not exist. This
-// function can result in I/O so it can be slow.
-BASE_EXPORT FilePath MakeAbsoluteFilePath(const FilePath& input);
-
-// Returns the total number of bytes used by all the files under |root_path|.
-// If the path does not exist the function returns 0.
-//
-// This function is implemented using the FileEnumerator class so it is not
-// particularly speedy in any platform.
-BASE_EXPORT int64_t ComputeDirectorySize(const FilePath& root_path);
-
-// Deletes the given path, whether it's a file or a directory.
-// If it's a directory, it's perfectly happy to delete all of the
-// directory's contents.  Passing true to recursive deletes
-// subdirectories and their contents as well.
-// Returns true if successful, false otherwise. It is considered successful
-// to attempt to delete a file that does not exist.
-//
-// In posix environment and if |path| is a symbolic link, this deletes only
-// the symlink. (even if the symlink points to a non-existent file)
-//
-// WARNING: USING THIS WITH recursive==true IS EQUIVALENT
-//          TO "rm -rf", SO USE WITH CAUTION.
-BASE_EXPORT bool DeleteFile(const FilePath& path, bool recursive);
-
-#if defined(OS_WIN)
-// Schedules to delete the given path, whether it's a file or a directory, until
-// the operating system is restarted.
-// Note:
-// 1) The file/directory to be deleted should exist in a temp folder.
-// 2) The directory to be deleted must be empty.
-BASE_EXPORT bool DeleteFileAfterReboot(const FilePath& path);
-#endif
-
-// Moves the given path, whether it's a file or a directory.
-// If a simple rename is not possible, such as in the case where the paths are
-// on different volumes, this will attempt to copy and delete. Returns
-// true for success.
-// This function fails if either path contains traversal components ('..').
-BASE_EXPORT bool Move(const FilePath& from_path, const FilePath& to_path);
-
-// Renames file |from_path| to |to_path|. Both paths must be on the same
-// volume, or the function will fail. Destination file will be created
-// if it doesn't exist. Prefer this function over Move when dealing with
-// temporary files. On Windows it preserves attributes of the target file.
-// Returns true on success, leaving *error unchanged.
-// Returns false on failure and sets *error appropriately, if it is non-NULL.
-BASE_EXPORT bool ReplaceFile(const FilePath& from_path,
-                             const FilePath& to_path,
-                             File::Error* error);
-
-// Copies a single file. Use CopyDirectory() to copy directories.
-// This function fails if either path contains traversal components ('..').
-// This function also fails if |to_path| is a directory.
-//
-// On POSIX, if |to_path| is a symlink, CopyFile() will follow the symlink. This
-// may have security implications. Use with care.
-//
-// If |to_path| already exists and is a regular file, it will be overwritten,
-// though its permissions will stay the same.
-//
-// If |to_path| does not exist, it will be created. The new file's permissions
-// varies per platform:
-//
-// - This function keeps the metadata on Windows. The read only bit is not kept.
-// - On Mac and iOS, |to_path| retains |from_path|'s permissions, except user
-//   read/write permissions are always set.
-// - On Linux and Android, |to_path| has user read/write permissions only. i.e.
-//   Always 0600.
-// - On ChromeOS, |to_path| has user read/write permissions and group/others
-//   read permissions. i.e. Always 0644.
-BASE_EXPORT bool CopyFile(const FilePath& from_path, const FilePath& to_path);
-
-// Copies the given path, and optionally all subdirectories and their contents
-// as well.
-//
-// If there are files existing under to_path, always overwrite. Returns true
-// if successful, false otherwise. Wildcards on the names are not supported.
-//
-// This function has the same metadata behavior as CopyFile().
-//
-// If you only need to copy a file use CopyFile, it's faster.
-BASE_EXPORT bool CopyDirectory(const FilePath& from_path,
-                               const FilePath& to_path,
-                               bool recursive);
-
-// Like CopyDirectory() except trying to overwrite an existing file will not
-// work and will return false.
-BASE_EXPORT bool CopyDirectoryExcl(const FilePath& from_path,
-                                   const FilePath& to_path,
-                                   bool recursive);
-
-// Returns true if the given path exists on the local filesystem,
-// false otherwise.
-BASE_EXPORT bool PathExists(const FilePath& path);
-
-// Returns true if the given path is writable by the user, false otherwise.
-BASE_EXPORT bool PathIsWritable(const FilePath& path);
-
-// Returns true if the given path exists and is a directory, false otherwise.
-BASE_EXPORT bool DirectoryExists(const FilePath& path);
-
-// Returns true if the contents of the two files given are equal, false
-// otherwise.  If either file can't be read, returns false.
-BASE_EXPORT bool ContentsEqual(const FilePath& filename1,
-                               const FilePath& filename2);
-
-// Returns true if the contents of the two text files given are equal, false
-// otherwise.  This routine treats "\r\n" and "\n" as equivalent.
-BASE_EXPORT bool TextContentsEqual(const FilePath& filename1,
-                                   const FilePath& filename2);
-
-// Reads the file at |path| into |contents| and returns true on success and
-// false on error.  For security reasons, a |path| containing path traversal
-// components ('..') is treated as a read error and |contents| is set to empty.
-// In case of I/O error, |contents| holds the data that could be read from the
-// file before the error occurred.
-// |contents| may be NULL, in which case this function is useful for its side
-// effect of priming the disk cache (could be used for unit tests).
-BASE_EXPORT bool ReadFileToString(const FilePath& path, std::string* contents);
-
-// Reads the file at |path| into |contents| and returns true on success and
-// false on error.  For security reasons, a |path| containing path traversal
-// components ('..') is treated as a read error and |contents| is set to empty.
-// In case of I/O error, |contents| holds the data that could be read from the
-// file before the error occurred.  When the file size exceeds |max_size|, the
-// function returns false with |contents| holding the file truncated to
-// |max_size|.
-// |contents| may be NULL, in which case this function is useful for its side
-// effect of priming the disk cache (could be used for unit tests).
-BASE_EXPORT bool ReadFileToStringWithMaxSize(const FilePath& path,
-                                             std::string* contents,
-                                             size_t max_size);
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-// Read exactly |bytes| bytes from file descriptor |fd|, storing the result
-// in |buffer|. This function is protected against EINTR and partial reads.
-// Returns true iff |bytes| bytes have been successfully read from |fd|.
-BASE_EXPORT bool ReadFromFD(int fd, char* buffer, size_t bytes);
-
-// Performs the same function as CreateAndOpenTemporaryFileInDir(), but returns
-// the file-descriptor directly, rather than wrapping it into a FILE. Returns
-// -1 on failure.
-BASE_EXPORT int CreateAndOpenFdForTemporaryFileInDir(const FilePath& dir,
-                                                     FilePath* path);
-
-#endif  // OS_POSIX || OS_FUCHSIA
-
-#if defined(OS_POSIX)
-
-// Creates a symbolic link at |symlink| pointing to |target|.  Returns
-// false on failure.
-BASE_EXPORT bool CreateSymbolicLink(const FilePath& target,
-                                    const FilePath& symlink);
-
-// Reads the given |symlink| and returns where it points to in |target|.
-// Returns false upon failure.
-BASE_EXPORT bool ReadSymbolicLink(const FilePath& symlink, FilePath* target);
-
-// Bits and masks of the file permission.
-enum FilePermissionBits {
-  FILE_PERMISSION_MASK              = S_IRWXU | S_IRWXG | S_IRWXO,
-  FILE_PERMISSION_USER_MASK         = S_IRWXU,
-  FILE_PERMISSION_GROUP_MASK        = S_IRWXG,
-  FILE_PERMISSION_OTHERS_MASK       = S_IRWXO,
-
-  FILE_PERMISSION_READ_BY_USER      = S_IRUSR,
-  FILE_PERMISSION_WRITE_BY_USER     = S_IWUSR,
-  FILE_PERMISSION_EXECUTE_BY_USER   = S_IXUSR,
-  FILE_PERMISSION_READ_BY_GROUP     = S_IRGRP,
-  FILE_PERMISSION_WRITE_BY_GROUP    = S_IWGRP,
-  FILE_PERMISSION_EXECUTE_BY_GROUP  = S_IXGRP,
-  FILE_PERMISSION_READ_BY_OTHERS    = S_IROTH,
-  FILE_PERMISSION_WRITE_BY_OTHERS   = S_IWOTH,
-  FILE_PERMISSION_EXECUTE_BY_OTHERS = S_IXOTH,
-};
-
-// Reads the permission of the given |path|, storing the file permission
-// bits in |mode|. If |path| is symbolic link, |mode| is the permission of
-// a file which the symlink points to.
-BASE_EXPORT bool GetPosixFilePermissions(const FilePath& path, int* mode);
-// Sets the permission of the given |path|. If |path| is symbolic link, sets
-// the permission of a file which the symlink points to.
-BASE_EXPORT bool SetPosixFilePermissions(const FilePath& path, int mode);
-
-// Returns true iff |executable| can be found in any directory specified by the
-// environment variable in |env|.
-BASE_EXPORT bool ExecutableExistsInPath(Environment* env,
-                                        const FilePath::StringType& executable);
-
-#if defined(OS_LINUX) || defined(OS_AIX)
-// Determine if files under a given |path| can be mapped and then mprotect'd
-// PROT_EXEC. This depends on the mount options used for |path|, which vary
-// among different Linux distributions and possibly local configuration. It also
-// depends on details of kernel--ChromeOS uses the noexec option for /dev/shm
-// but its kernel allows mprotect with PROT_EXEC anyway.
-BASE_EXPORT bool IsPathExecutable(const FilePath& path);
-#endif  // OS_LINUX || OS_AIX
-
-#endif  // OS_POSIX
-
-// Returns true if the given directory is empty
-BASE_EXPORT bool IsDirectoryEmpty(const FilePath& dir_path);
-
-// Get the temporary directory provided by the system.
-//
-// WARNING: In general, you should use CreateTemporaryFile variants below
-// instead of this function. Those variants will ensure that the proper
-// permissions are set so that other users on the system can't edit them while
-// they're open (which can lead to security issues).
-BASE_EXPORT bool GetTempDir(FilePath* path);
-
-// Get the home directory. This is more complicated than just getenv("HOME")
-// as it knows to fall back on getpwent() etc.
-//
-// You should not generally call this directly. Instead use DIR_HOME with the
-// path service which will use this function but cache the value.
-// Path service may also override DIR_HOME.
-BASE_EXPORT FilePath GetHomeDir();
-
-// Creates a temporary file. The full path is placed in |path|, and the
-// function returns true if was successful in creating the file. The file will
-// be empty and all handles closed after this function returns.
-BASE_EXPORT bool CreateTemporaryFile(FilePath* path);
-
-// Same as CreateTemporaryFile but the file is created in |dir|.
-BASE_EXPORT bool CreateTemporaryFileInDir(const FilePath& dir,
-                                          FilePath* temp_file);
-
-// Create and open a temporary file.  File is opened for read/write.
-// The full path is placed in |path|.
-// Returns a handle to the opened file or NULL if an error occurred.
-BASE_EXPORT FILE* CreateAndOpenTemporaryFile(FilePath* path);
-
-// Similar to CreateAndOpenTemporaryFile, but the file is created in |dir|.
-BASE_EXPORT FILE* CreateAndOpenTemporaryFileInDir(const FilePath& dir,
-                                                  FilePath* path);
-
-// Create a new directory. If prefix is provided, the new directory name is in
-// the format of prefixyyyy.
-// NOTE: prefix is ignored in the POSIX implementation.
-// If success, return true and output the full path of the directory created.
-BASE_EXPORT bool CreateNewTempDirectory(const FilePath::StringType& prefix,
-                                        FilePath* new_temp_path);
-
-// Create a directory within another directory.
-// 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,
-                                         const FilePath::StringType& prefix,
-                                         FilePath* new_dir);
-
-// Creates a directory, as well as creating any parent directories, if they
-// don't exist. Returns 'true' on successful creation, or if the directory
-// already exists.  The directory is only readable by the current user.
-// Returns true on success, leaving *error unchanged.
-// Returns false on failure and sets *error appropriately, if it is non-NULL.
-BASE_EXPORT bool CreateDirectoryAndGetError(const FilePath& full_path,
-                                            File::Error* error);
-
-// Backward-compatible convenience method for the above.
-BASE_EXPORT bool CreateDirectory(const FilePath& full_path);
-
-// Returns the file size. Returns true on success.
-BASE_EXPORT bool GetFileSize(const FilePath& file_path, int64_t* file_size);
-
-// Sets |real_path| to |path| with symbolic links and junctions expanded.
-// On windows, make sure the path starts with a lettered drive.
-// |path| must reference a file.  Function will fail if |path| points to
-// a directory or to a nonexistent path.  On windows, this function will
-// fail if |path| is a junction or symlink that points to an empty file,
-// or if |real_path| would be longer than MAX_PATH characters.
-BASE_EXPORT bool NormalizeFilePath(const FilePath& path, FilePath* real_path);
-
-#if defined(OS_WIN)
-
-// Given a path in NT native form ("\Device\HarddiskVolumeXX\..."),
-// return in |drive_letter_path| the equivalent path that starts with
-// a drive letter ("C:\...").  Return false if no such path exists.
-BASE_EXPORT bool DevicePathToDriveLetterPath(const FilePath& device_path,
-                                             FilePath* drive_letter_path);
-
-// Given an existing file in |path|, set |real_path| to the path
-// in native NT format, of the form "\Device\HarddiskVolumeXX\..".
-// Returns false if the path can not be found. Empty files cannot
-// be resolved with this function.
-BASE_EXPORT bool NormalizeToNativeFilePath(const FilePath& path,
-                                           FilePath* nt_path);
-#endif
-
-// This function will return if the given file is a symlink or not.
-BASE_EXPORT bool IsLink(const FilePath& file_path);
-
-// Returns information about the given file path.
-BASE_EXPORT bool GetFileInfo(const FilePath& file_path, File::Info* info);
-
-// Sets the time of the last access and the time of the last modification.
-BASE_EXPORT bool TouchFile(const FilePath& path,
-                           const Time& last_accessed,
-                           const Time& last_modified);
-
-// Wrapper for fopen-like calls. Returns non-NULL FILE* on success. The
-// underlying file descriptor (POSIX) or handle (Windows) is unconditionally
-// configured to not be propagated to child processes.
-BASE_EXPORT FILE* OpenFile(const FilePath& filename, const char* mode);
-
-// Closes file opened by OpenFile. Returns true on success.
-BASE_EXPORT bool CloseFile(FILE* file);
-
-// Associates a standard FILE stream with an existing File. Note that this
-// functions take ownership of the existing File.
-BASE_EXPORT FILE* FileToFILE(File file, const char* mode);
-
-// Truncates an open file to end at the location of the current file pointer.
-// This is a cross-platform analog to Windows' SetEndOfFile() function.
-BASE_EXPORT bool TruncateFile(FILE* file);
-
-// Reads at most the given number of bytes from the file into the buffer.
-// Returns the number of read bytes, or -1 on error.
-BASE_EXPORT int ReadFile(const FilePath& filename, char* data, int max_size);
-
-// Writes the given buffer into the file, overwriting any data that was
-// previously there.  Returns the number of bytes written, or -1 on error.
-BASE_EXPORT int WriteFile(const FilePath& filename, const char* data,
-                          int size);
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-// Appends |data| to |fd|. Does not close |fd| when done.  Returns true iff
-// |size| bytes of |data| were written to |fd|.
-BASE_EXPORT bool WriteFileDescriptor(const int fd, const char* data, int size);
-#endif
-
-// Appends |data| to |filename|.  Returns true iff |size| bytes of |data| were
-// written to |filename|.
-BASE_EXPORT bool AppendToFile(const FilePath& filename,
-                              const char* data,
-                              int size);
-
-// Gets the current working directory for the process.
-BASE_EXPORT bool GetCurrentDirectory(FilePath* path);
-
-// Sets the current working directory for the process.
-BASE_EXPORT bool SetCurrentDirectory(const FilePath& path);
-
-// Attempts to find a number that can be appended to the |path| to make it
-// unique. If |path| does not exist, 0 is returned.  If it fails to find such
-// a number, -1 is returned. If |suffix| is not empty, also checks the
-// existence of it with the given suffix.
-BASE_EXPORT int GetUniquePathNumber(const FilePath& path,
-                                    const FilePath::StringType& suffix);
-
-// Sets the given |fd| to non-blocking mode.
-// Returns true if it was able to set it in the non-blocking mode, otherwise
-// false.
-BASE_EXPORT bool SetNonBlocking(int fd);
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-// Creates a non-blocking, close-on-exec pipe.
-// This creates a non-blocking pipe that is not intended to be shared with any
-// child process. This will be done atomically if the operating system supports
-// it. Returns true if it was able to create the pipe, otherwise false.
-BASE_EXPORT bool CreateLocalNonBlockingPipe(int fds[2]);
-
-// Sets the given |fd| to close-on-exec mode.
-// Returns true if it was able to set it in the close-on-exec mode, otherwise
-// false.
-BASE_EXPORT bool SetCloseOnExec(int fd);
-
-// Test that |path| can only be changed by a given user and members of
-// a given set of groups.
-// Specifically, test that all parts of |path| under (and including) |base|:
-// * Exist.
-// * Are owned by a specific user.
-// * Are not writable by all users.
-// * Are owned by a member of a given set of groups, or are not writable by
-//   their group.
-// * Are not symbolic links.
-// This is useful for checking that a config file is administrator-controlled.
-// |base| must contain |path|.
-BASE_EXPORT bool VerifyPathControlledByUser(const base::FilePath& base,
-                                            const base::FilePath& path,
-                                            uid_t owner_uid,
-                                            const std::set<gid_t>& group_gids);
-#endif  // defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-// Is |path| writable only by a user with administrator privileges?
-// This function uses Mac OS conventions.  The super user is assumed to have
-// uid 0, and the administrator group is assumed to be named "admin".
-// Testing that |path|, and every parent directory including the root of
-// the filesystem, are owned by the superuser, controlled by the group
-// "admin", are not writable by all users, and contain no symbolic links.
-// Will return false if |path| does not exist.
-BASE_EXPORT bool VerifyPathControlledByAdmin(const base::FilePath& path);
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
-
-// Returns the maximum length of path component on the volume containing
-// the directory |path|, in the number of FilePath::CharType, or -1 on failure.
-BASE_EXPORT int GetMaximumPathComponentLength(const base::FilePath& path);
-
-#if defined(OS_LINUX) || defined(OS_AIX)
-// Broad categories of file systems as returned by statfs() on Linux.
-enum FileSystemType {
-  FILE_SYSTEM_UNKNOWN,  // statfs failed.
-  FILE_SYSTEM_0,        // statfs.f_type == 0 means unknown, may indicate AFS.
-  FILE_SYSTEM_ORDINARY,       // on-disk filesystem like ext2
-  FILE_SYSTEM_NFS,
-  FILE_SYSTEM_SMB,
-  FILE_SYSTEM_CODA,
-  FILE_SYSTEM_MEMORY,         // in-memory file system
-  FILE_SYSTEM_CGROUP,         // cgroup control.
-  FILE_SYSTEM_OTHER,          // any other value.
-  FILE_SYSTEM_TYPE_COUNT
-};
-
-// Attempts determine the FileSystemType for |path|.
-// Returns false if |path| doesn't exist.
-BASE_EXPORT bool GetFileSystemType(const FilePath& path, FileSystemType* type);
-#endif
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-// Get a temporary directory for shared memory files. The directory may depend
-// on whether the destination is intended for executable files, which in turn
-// depends on how /dev/shmem was mounted. As a result, you must supply whether
-// you intend to create executable shmem segments so this function can find
-// an appropriate location.
-BASE_EXPORT bool GetShmemTempDir(bool executable, FilePath* path);
-#endif
-
-// Internal --------------------------------------------------------------------
-
-namespace internal {
-
-// Same as Move but allows paths with traversal components.
-// Use only with extreme care.
-BASE_EXPORT bool MoveUnsafe(const FilePath& from_path,
-                            const FilePath& to_path);
-
-#if defined(OS_WIN)
-// Copy from_path to to_path recursively and then delete from_path recursively.
-// Returns true if all operations succeed.
-// This function simulates Move(), but unlike Move() it works across volumes.
-// This function is not transactional.
-BASE_EXPORT bool CopyAndDeleteDirectory(const FilePath& from_path,
-                                        const FilePath& to_path);
-#endif  // defined(OS_WIN)
-
-}  // namespace internal
-}  // namespace base
-
-#endif  // BASE_FILES_FILE_UTIL_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/memory_mapped_file.h b/native/zucchini/vendor/libchrome/base/files/memory_mapped_file.h
deleted file mode 100644
index 04f4336..0000000
--- a/native/zucchini/vendor/libchrome/base/files/memory_mapped_file.h
+++ /dev/null
@@ -1,136 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_FILES_MEMORY_MAPPED_FILE_H_
-#define BASE_FILES_MEMORY_MAPPED_FILE_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/base_export.h"
-#include "base/files/file.h"
-#include "base/macros.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-#endif
-
-namespace base {
-
-class FilePath;
-
-class BASE_EXPORT MemoryMappedFile {
- public:
-  enum Access {
-    // Mapping a file into memory effectively allows for file I/O on any thread.
-    // The accessing thread could be paused while data from the file is paged
-    // into memory. Worse, a corrupted filesystem could cause a SEGV within the
-    // program instead of just an I/O error.
-    READ_ONLY,
-
-    // This provides read/write access to a file and must be used with care of
-    // the additional subtleties involved in doing so. Though the OS will do
-    // the writing of data on its own time, too many dirty pages can cause
-    // the OS to pause the thread while it writes them out. The pause can
-    // be as much as 1s on some systems.
-    READ_WRITE,
-
-    // This provides read/write access but with the ability to write beyond
-    // the end of the existing file up to a maximum size specified as the
-    // "region". Depending on the OS, the file may or may not be immediately
-    // extended to the maximum size though it won't be loaded in RAM until
-    // needed. Note, however, that the maximum size will still be reserved
-    // in the process address space.
-    READ_WRITE_EXTEND,
-  };
-
-  // The default constructor sets all members to invalid/null values.
-  MemoryMappedFile();
-  ~MemoryMappedFile();
-
-  // Used to hold information about a region [offset + size] of a file.
-  struct BASE_EXPORT Region {
-    static const Region kWholeFile;
-
-    bool operator==(const Region& other) const;
-    bool operator!=(const Region& other) const;
-
-    // Start of the region (measured in bytes from the beginning of the file).
-    int64_t offset;
-
-    // Length of the region in bytes.
-    size_t size;
-  };
-
-  // Opens an existing file and maps it into memory. |access| can be read-only
-  // or read/write but not read/write+extend. If this object already points
-  // to a valid memory mapped file then this method will fail and return
-  // false. If it cannot open the file, the file does not exist, or the
-  // memory mapping fails, it will return false.
-  bool Initialize(const FilePath& file_name, Access access);
-  bool Initialize(const FilePath& file_name) {
-    return Initialize(file_name, READ_ONLY);
-  }
-
-  // As above, but works with an already-opened file. |access| can be read-only
-  // or read/write but not read/write+extend. MemoryMappedFile takes ownership
-  // of |file| and closes it when done. |file| must have been opened with
-  // permissions suitable for |access|. If the memory mapping fails, it will
-  // return false.
-  bool Initialize(File file, Access access);
-  bool Initialize(File file) {
-    return Initialize(std::move(file), READ_ONLY);
-  }
-
-  // As above, but works with a region of an already-opened file. All forms of
-  // |access| are allowed. If READ_WRITE_EXTEND is specified then |region|
-  // provides the maximum size of the file. If the memory mapping fails, it
-  // return false.
-  bool Initialize(File file, const Region& region, Access access);
-  bool Initialize(File file, const Region& region) {
-    return Initialize(std::move(file), region, READ_ONLY);
-  }
-
-  const uint8_t* data() const { return data_; }
-  uint8_t* data() { return data_; }
-  size_t length() const { return length_; }
-
-  // Is file_ a valid file handle that points to an open, memory mapped file?
-  bool IsValid() const;
-
- private:
-  // Given the arbitrarily aligned memory region [start, size], returns the
-  // boundaries of the region aligned to the granularity specified by the OS,
-  // (a page on Linux, ~32k on Windows) as follows:
-  // - |aligned_start| is page aligned and <= |start|.
-  // - |aligned_size| is a multiple of the VM granularity and >= |size|.
-  // - |offset| is the displacement of |start| w.r.t |aligned_start|.
-  static void CalculateVMAlignedBoundaries(int64_t start,
-                                           size_t size,
-                                           int64_t* aligned_start,
-                                           size_t* aligned_size,
-                                           int32_t* offset);
-
-  // Map the file to memory, set data_ to that memory address. Return true on
-  // success, false on any kind of failure. This is a helper for Initialize().
-  bool MapFileRegionToMemory(const Region& region, Access access);
-
-  // Closes all open handles.
-  void CloseHandles();
-
-  File file_;
-  uint8_t* data_;
-  size_t length_;
-
-#if defined(OS_WIN)
-  win::ScopedHandle file_mapping_;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(MemoryMappedFile);
-};
-
-}  // namespace base
-
-#endif  // BASE_FILES_MEMORY_MAPPED_FILE_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/platform_file.h b/native/zucchini/vendor/libchrome/base/files/platform_file.h
deleted file mode 100644
index 3929a0d..0000000
--- a/native/zucchini/vendor/libchrome/base/files/platform_file.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_FILES_PLATFORM_FILE_H_
-#define BASE_FILES_PLATFORM_FILE_H_
-
-#include "base/files/scoped_file.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include "base/win/scoped_handle.h"
-#include "base/win/windows_types.h"
-#endif
-
-// This file defines platform-independent types for dealing with
-// platform-dependent files. If possible, use the higher-level base::File class
-// rather than these primitives.
-
-namespace base {
-
-#if defined(OS_WIN)
-
-using PlatformFile = HANDLE;
-using ScopedPlatformFile = ::base::win::ScopedHandle;
-
-// It would be nice to make this constexpr but INVALID_HANDLE_VALUE is a
-// ((void*)(-1)) which Clang rejects since reinterpret_cast is technically
-// disallowed in constexpr. Visual Studio accepts this, however.
-const PlatformFile kInvalidPlatformFile = INVALID_HANDLE_VALUE;
-
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-using PlatformFile = int;
-using ScopedPlatformFile = ::base::ScopedFD;
-
-constexpr PlatformFile kInvalidPlatformFile = -1;
-
-#endif
-
-}  // namespace
-
-#endif  // BASE_FILES_PLATFORM_FILE_H_
diff --git a/native/zucchini/vendor/libchrome/base/files/scoped_file.h b/native/zucchini/vendor/libchrome/base/files/scoped_file.h
deleted file mode 100644
index e32a603..0000000
--- a/native/zucchini/vendor/libchrome/base/files/scoped_file.h
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_FILES_SCOPED_FILE_H_
-#define BASE_FILES_SCOPED_FILE_H_
-
-#include <stdio.h>
-
-#include <memory>
-
-#include "base/base_export.h"
-#include "base/logging.h"
-#include "base/scoped_generic.h"
-#include "build/build_config.h"
-
-namespace base {
-
-namespace internal {
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-struct BASE_EXPORT ScopedFDCloseTraits {
-  static int InvalidValue() {
-    return -1;
-  }
-  static void Free(int fd);
-};
-#endif
-
-// Functor for |ScopedFILE| (below).
-struct ScopedFILECloser {
-  inline void operator()(FILE* x) const {
-    if (x)
-      fclose(x);
-  }
-};
-
-}  // namespace internal
-
-// -----------------------------------------------------------------------------
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-// A low-level Posix file descriptor closer class. Use this when writing
-// platform-specific code, especially that does non-file-like things with the
-// FD (like sockets).
-//
-// If you're writing low-level Windows code, see base/win/scoped_handle.h
-// which provides some additional functionality.
-//
-// If you're writing cross-platform code that deals with actual files, you
-// should generally use base::File instead which can be constructed with a
-// handle, and in addition to handling ownership, has convenient cross-platform
-// file manipulation functions on it.
-typedef ScopedGeneric<int, internal::ScopedFDCloseTraits> ScopedFD;
-#endif
-
-// Automatically closes |FILE*|s.
-typedef std::unique_ptr<FILE, internal::ScopedFILECloser> ScopedFILE;
-
-}  // namespace base
-
-#endif  // BASE_FILES_SCOPED_FILE_H_
diff --git a/native/zucchini/vendor/libchrome/base/format_macros.h b/native/zucchini/vendor/libchrome/base/format_macros.h
deleted file mode 100644
index 1279ff7..0000000
--- a/native/zucchini/vendor/libchrome/base/format_macros.h
+++ /dev/null
@@ -1,97 +0,0 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_FORMAT_MACROS_H_
-#define BASE_FORMAT_MACROS_H_
-
-// This file defines the format macros for some integer types.
-
-// To print a 64-bit value in a portable way:
-//   int64_t value;
-//   printf("xyz:%" PRId64, value);
-// The "d" in the macro corresponds to %d; you can also use PRIu64 etc.
-//
-// For wide strings, prepend "Wide" to the macro:
-//   int64_t value;
-//   StringPrintf(L"xyz: %" WidePRId64, value);
-//
-// To print a size_t value in a portable way:
-//   size_t size;
-//   printf("xyz: %" PRIuS, size);
-// The "u" in the macro corresponds to %u, and S is for "size".
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "build/build_config.h"
-
-#if (defined(OS_POSIX) || defined(OS_FUCHSIA)) && \
-    (defined(_INTTYPES_H) || defined(_INTTYPES_H_)) && !defined(PRId64)
-#error "inttypes.h has already been included before this header file, but "
-#error "without __STDC_FORMAT_MACROS defined."
-#endif
-
-#if (defined(OS_POSIX) || defined(OS_FUCHSIA)) && !defined(__STDC_FORMAT_MACROS)
-#define __STDC_FORMAT_MACROS
-#endif
-
-#include <inttypes.h>
-
-#if defined(OS_WIN)
-
-#if !defined(PRId64) || !defined(PRIu64) || !defined(PRIx64)
-#error "inttypes.h provided by win toolchain should define these."
-#endif
-
-#define WidePRId64 L"I64d"
-#define WidePRIu64 L"I64u"
-#define WidePRIx64 L"I64x"
-
-#if !defined(PRIuS)
-#define PRIuS "Iu"
-#endif
-
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-
-// GCC will concatenate wide and narrow strings correctly, so nothing needs to
-// be done here.
-#define WidePRId64 PRId64
-#define WidePRIu64 PRIu64
-#define WidePRIx64 PRIx64
-
-#if !defined(PRIuS)
-#define PRIuS "zu"
-#endif
-
-#endif  // defined(OS_WIN)
-
-// The size of NSInteger and NSUInteger varies between 32-bit and 64-bit
-// architectures and Apple does not provides standard format macros and
-// recommends casting. This has many drawbacks, so instead define macros
-// for formatting those types.
-#if defined(OS_MACOSX)
-#if defined(ARCH_CPU_64_BITS)
-#if !defined(PRIdNS)
-#define PRIdNS "ld"
-#endif
-#if !defined(PRIuNS)
-#define PRIuNS "lu"
-#endif
-#if !defined(PRIxNS)
-#define PRIxNS "lx"
-#endif
-#else  // defined(ARCH_CPU_64_BITS)
-#if !defined(PRIdNS)
-#define PRIdNS "d"
-#endif
-#if !defined(PRIuNS)
-#define PRIuNS "u"
-#endif
-#if !defined(PRIxNS)
-#define PRIxNS "x"
-#endif
-#endif
-#endif  // defined(OS_MACOSX)
-
-#endif  // BASE_FORMAT_MACROS_H_
diff --git a/native/zucchini/vendor/libchrome/base/gtest_prod_util.h b/native/zucchini/vendor/libchrome/base/gtest_prod_util.h
deleted file mode 100644
index 2ca267e..0000000
--- a/native/zucchini/vendor/libchrome/base/gtest_prod_util.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_GTEST_PROD_UTIL_H_
-#define BASE_GTEST_PROD_UTIL_H_
-
-#include "testing/gtest/include/gtest/gtest_prod.h"  // nogncheck
-
-// This is a wrapper for gtest's FRIEND_TEST macro that friends
-// test with all possible prefixes. This is very helpful when changing the test
-// prefix, because the friend declarations don't need to be updated.
-//
-// Example usage:
-//
-// class MyClass {
-//  private:
-//   void MyMethod();
-//   FRIEND_TEST_ALL_PREFIXES(MyClassTest, MyMethod);
-// };
-#define FRIEND_TEST_ALL_PREFIXES(test_case_name, test_name) \
-  FRIEND_TEST(test_case_name, test_name); \
-  FRIEND_TEST(test_case_name, DISABLED_##test_name); \
-  FRIEND_TEST(test_case_name, FLAKY_##test_name)
-
-// C++ compilers will refuse to compile the following code:
-//
-// namespace foo {
-// class MyClass {
-//  private:
-//   FRIEND_TEST_ALL_PREFIXES(MyClassTest, TestMethod);
-//   bool private_var;
-// };
-// }  // namespace foo
-//
-// class MyClassTest::TestMethod() {
-//   foo::MyClass foo_class;
-//   foo_class.private_var = true;
-// }
-//
-// Unless you forward declare MyClassTest::TestMethod outside of namespace foo.
-// Use FORWARD_DECLARE_TEST to do so for all possible prefixes.
-//
-// Example usage:
-//
-// FORWARD_DECLARE_TEST(MyClassTest, TestMethod);
-//
-// namespace foo {
-// class MyClass {
-//  private:
-//   FRIEND_TEST_ALL_PREFIXES(::MyClassTest, TestMethod);  // NOTE use of ::
-//   bool private_var;
-// };
-// }  // namespace foo
-//
-// class MyClassTest::TestMethod() {
-//   foo::MyClass foo_class;
-//   foo_class.private_var = true;
-// }
-
-#define FORWARD_DECLARE_TEST(test_case_name, test_name) \
-  class test_case_name##_##test_name##_Test; \
-  class test_case_name##_##DISABLED_##test_name##_Test; \
-  class test_case_name##_##FLAKY_##test_name##_Test
-
-#endif  // BASE_GTEST_PROD_UTIL_H_
diff --git a/native/zucchini/vendor/libchrome/base/hash.h b/native/zucchini/vendor/libchrome/base/hash.h
deleted file mode 100644
index 165899e..0000000
--- a/native/zucchini/vendor/libchrome/base/hash.h
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_HASH_H_
-#define BASE_HASH_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <limits>
-#include <string>
-#include <utility>
-
-#include "base/base_export.h"
-#include "base/logging.h"
-#include "base/strings/string16.h"
-
-namespace base {
-
-// Computes a hash of a memory buffer. This hash function is subject to change
-// in the future, so use only for temporary in-memory structures. If you need
-// to persist a change on disk or between computers, use PersistentHash().
-//
-// WARNING: This hash function should not be used for any cryptographic purpose.
-BASE_EXPORT uint32_t Hash(const void* data, size_t length);
-BASE_EXPORT uint32_t Hash(const std::string& str);
-BASE_EXPORT uint32_t Hash(const string16& str);
-
-// Computes a hash of a memory buffer. This hash function must not change so
-// that code can use the hashed values for persistent storage purposes or
-// sending across the network. If a new persistent hash function is desired, a
-// new version will have to be added in addition.
-//
-// WARNING: This hash function should not be used for any cryptographic purpose.
-BASE_EXPORT uint32_t PersistentHash(const void* data, size_t length);
-BASE_EXPORT uint32_t PersistentHash(const std::string& str);
-
-// Hash pairs of 32-bit or 64-bit numbers.
-BASE_EXPORT size_t HashInts32(uint32_t value1, uint32_t value2);
-BASE_EXPORT size_t HashInts64(uint64_t value1, uint64_t value2);
-
-template <typename T1, typename T2>
-inline size_t HashInts(T1 value1, T2 value2) {
-  // This condition is expected to be compile-time evaluated and optimised away
-  // in release builds.
-  if (sizeof(T1) > sizeof(uint32_t) || (sizeof(T2) > sizeof(uint32_t)))
-    return HashInts64(value1, value2);
-
-  return HashInts32(value1, value2);
-}
-
-// A templated hasher for pairs of integer types. Example:
-//
-//   using MyPair = std::pair<int32_t, int32_t>;
-//   std::unordered_set<MyPair, base::IntPairHash<MyPair>> set;
-template <typename T>
-struct IntPairHash;
-
-template <typename Type1, typename Type2>
-struct IntPairHash<std::pair<Type1, Type2>> {
-  size_t operator()(std::pair<Type1, Type2> value) const {
-    return HashInts(value.first, value.second);
-  }
-};
-
-}  // namespace base
-
-#endif  // BASE_HASH_H_
diff --git a/native/zucchini/vendor/libchrome/base/lazy_instance.h b/native/zucchini/vendor/libchrome/base/lazy_instance.h
deleted file mode 100644
index 4449373..0000000
--- a/native/zucchini/vendor/libchrome/base/lazy_instance.h
+++ /dev/null
@@ -1,210 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DEPRECATED !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-// Please don't introduce new instances of LazyInstance<T>. Use a function-local
-// static of type base::NoDestructor<T> instead:
-//
-// Factory& Factory::GetInstance() {
-//   static base::NoDestructor<Factory> instance;
-//   return *instance;
-// }
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-//
-// The LazyInstance<Type, Traits> class manages a single instance of Type,
-// which will be lazily created on the first time it's accessed.  This class is
-// useful for places you would normally use a function-level static, but you
-// need to have guaranteed thread-safety.  The Type constructor will only ever
-// be called once, even if two threads are racing to create the object.  Get()
-// and Pointer() will always return the same, completely initialized instance.
-// When the instance is constructed it is registered with AtExitManager.  The
-// destructor will be called on program exit.
-//
-// LazyInstance is completely thread safe, assuming that you create it safely.
-// The class was designed to be POD initialized, so it shouldn't require a
-// static constructor.  It really only makes sense to declare a LazyInstance as
-// a global variable using the LAZY_INSTANCE_INITIALIZER initializer.
-//
-// LazyInstance is similar to Singleton, except it does not have the singleton
-// property.  You can have multiple LazyInstance's of the same type, and each
-// will manage a unique instance.  It also preallocates the space for Type, as
-// to avoid allocating the Type instance on the heap.  This may help with the
-// performance of creating the instance, and reducing heap fragmentation.  This
-// requires that Type be a complete type so we can determine the size.
-//
-// Example usage:
-//   static LazyInstance<MyClass>::Leaky inst = LAZY_INSTANCE_INITIALIZER;
-//   void SomeMethod() {
-//     inst.Get().SomeMethod();  // MyClass::SomeMethod()
-//
-//     MyClass* ptr = inst.Pointer();
-//     ptr->DoDoDo();  // MyClass::DoDoDo
-//   }
-
-#ifndef BASE_LAZY_INSTANCE_H_
-#define BASE_LAZY_INSTANCE_H_
-
-#include <new>  // For placement new.
-
-#include "base/atomicops.h"
-#include "base/debug/leak_annotations.h"
-#include "base/lazy_instance_helpers.h"
-#include "base/logging.h"
-#include "base/threading/thread_restrictions.h"
-
-// LazyInstance uses its own struct initializer-list style static
-// initialization, which does not require a constructor.
-#define LAZY_INSTANCE_INITIALIZER {}
-
-namespace base {
-
-template <typename Type>
-struct LazyInstanceTraitsBase {
-  static Type* New(void* instance) {
-    DCHECK_EQ(reinterpret_cast<uintptr_t>(instance) & (alignof(Type) - 1), 0u);
-    // Use placement new to initialize our instance in our preallocated space.
-    // The parenthesis is very important here to force POD type initialization.
-    return new (instance) Type();
-  }
-
-  static void CallDestructor(Type* instance) {
-    // Explicitly call the destructor.
-    instance->~Type();
-  }
-};
-
-// We pull out some of the functionality into non-templated functions, so we
-// can implement the more complicated pieces out of line in the .cc file.
-namespace internal {
-
-// This traits class causes destruction the contained Type at process exit via
-// AtExitManager. This is probably generally not what you want. Instead, prefer
-// Leaky below.
-template <typename Type>
-struct DestructorAtExitLazyInstanceTraits {
-  static const bool kRegisterOnExit = true;
-#if DCHECK_IS_ON()
-  static const bool kAllowedToAccessOnNonjoinableThread = false;
-#endif
-
-  static Type* New(void* instance) {
-    return LazyInstanceTraitsBase<Type>::New(instance);
-  }
-
-  static void Delete(Type* instance) {
-    LazyInstanceTraitsBase<Type>::CallDestructor(instance);
-  }
-};
-
-// Use LazyInstance<T>::Leaky for a less-verbose call-site typedef; e.g.:
-// base::LazyInstance<T>::Leaky my_leaky_lazy_instance;
-// instead of:
-// base::LazyInstance<T, base::internal::LeakyLazyInstanceTraits<T> >
-// my_leaky_lazy_instance;
-// (especially when T is MyLongTypeNameImplClientHolderFactory).
-// Only use this internal::-qualified verbose form to extend this traits class
-// (depending on its implementation details).
-template <typename Type>
-struct LeakyLazyInstanceTraits {
-  static const bool kRegisterOnExit = false;
-#if DCHECK_IS_ON()
-  static const bool kAllowedToAccessOnNonjoinableThread = true;
-#endif
-
-  static Type* New(void* instance) {
-    ANNOTATE_SCOPED_MEMORY_LEAK;
-    return LazyInstanceTraitsBase<Type>::New(instance);
-  }
-  static void Delete(Type* instance) {
-  }
-};
-
-template <typename Type>
-struct ErrorMustSelectLazyOrDestructorAtExitForLazyInstance {};
-
-}  // namespace internal
-
-template <
-    typename Type,
-    typename Traits =
-        internal::ErrorMustSelectLazyOrDestructorAtExitForLazyInstance<Type>>
-class LazyInstance {
- public:
-  // Do not define a destructor, as doing so makes LazyInstance a
-  // non-POD-struct. We don't want that because then a static initializer will
-  // be created to register the (empty) destructor with atexit() under MSVC, for
-  // example. We handle destruction of the contained Type class explicitly via
-  // the OnExit member function, where needed.
-  // ~LazyInstance() {}
-
-  // Convenience typedef to avoid having to repeat Type for leaky lazy
-  // instances.
-  typedef LazyInstance<Type, internal::LeakyLazyInstanceTraits<Type>> Leaky;
-  typedef LazyInstance<Type, internal::DestructorAtExitLazyInstanceTraits<Type>>
-      DestructorAtExit;
-
-  Type& Get() {
-    return *Pointer();
-  }
-
-  Type* Pointer() {
-#if DCHECK_IS_ON()
-    if (!Traits::kAllowedToAccessOnNonjoinableThread)
-      ThreadRestrictions::AssertSingletonAllowed();
-#endif
-
-    return subtle::GetOrCreateLazyPointer(
-        &private_instance_, &Traits::New, private_buf_,
-        Traits::kRegisterOnExit ? OnExit : nullptr, this);
-  }
-
-  // Returns true if the lazy instance has been created.  Unlike Get() and
-  // Pointer(), calling IsCreated() will not instantiate the object of Type.
-  bool IsCreated() {
-    // Return true (i.e. "created") if |private_instance_| is either being
-    // created right now (i.e. |private_instance_| has value of
-    // internal::kLazyInstanceStateCreating) or was already created (i.e.
-    // |private_instance_| has any other non-zero value).
-    return 0 != subtle::NoBarrier_Load(&private_instance_);
-  }
-
-  // MSVC gives a warning that the alignment expands the size of the
-  // LazyInstance struct to make the size a multiple of the alignment. This
-  // is expected in this case.
-#if defined(OS_WIN)
-#pragma warning(push)
-#pragma warning(disable: 4324)
-#endif
-
-  // Effectively private: member data is only public to allow the linker to
-  // statically initialize it and to maintain a POD class. DO NOT USE FROM
-  // OUTSIDE THIS CLASS.
-  subtle::AtomicWord private_instance_;
-
-  // Preallocated space for the Type instance.
-  alignas(Type) char private_buf_[sizeof(Type)];
-
-#if defined(OS_WIN)
-#pragma warning(pop)
-#endif
-
- private:
-  Type* instance() {
-    return reinterpret_cast<Type*>(subtle::NoBarrier_Load(&private_instance_));
-  }
-
-  // Adapter function for use with AtExit.  This should be called single
-  // threaded, so don't synchronize across threads.
-  // Calling OnExit while the instance is in use by other threads is a mistake.
-  static void OnExit(void* lazy_instance) {
-    LazyInstance<Type, Traits>* me =
-        reinterpret_cast<LazyInstance<Type, Traits>*>(lazy_instance);
-    Traits::Delete(me->instance());
-    subtle::NoBarrier_Store(&me->private_instance_, 0);
-  }
-};
-
-}  // namespace base
-
-#endif  // BASE_LAZY_INSTANCE_H_
diff --git a/native/zucchini/vendor/libchrome/base/lazy_instance_helpers.cc b/native/zucchini/vendor/libchrome/base/lazy_instance_helpers.cc
deleted file mode 100644
index 7b9e0de..0000000
--- a/native/zucchini/vendor/libchrome/base/lazy_instance_helpers.cc
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/lazy_instance_helpers.h"
-
-#include "base/at_exit.h"
-#include "base/atomicops.h"
-#include "base/threading/platform_thread.h"
-
-namespace base {
-namespace internal {
-
-bool NeedsLazyInstance(subtle::AtomicWord* state) {
-  // Try to create the instance, if we're the first, will go from 0 to
-  // kLazyInstanceStateCreating, otherwise we've already been beaten here.
-  // The memory access has no memory ordering as state 0 and
-  // kLazyInstanceStateCreating have no associated data (memory barriers are
-  // all about ordering of memory accesses to *associated* data).
-  if (subtle::NoBarrier_CompareAndSwap(state, 0, kLazyInstanceStateCreating) ==
-      0) {
-    // Caller must create instance
-    return true;
-  }
-
-  // It's either in the process of being created, or already created. Spin.
-  // The load has acquire memory ordering as a thread which sees
-  // state_ == STATE_CREATED needs to acquire visibility over
-  // the associated data (buf_). Pairing Release_Store is in
-  // CompleteLazyInstance().
-  if (subtle::Acquire_Load(state) == kLazyInstanceStateCreating) {
-    const base::TimeTicks start = base::TimeTicks::Now();
-    do {
-      const base::TimeDelta elapsed = base::TimeTicks::Now() - start;
-      // Spin with YieldCurrentThread for at most one ms - this ensures maximum
-      // responsiveness. After that spin with Sleep(1ms) so that we don't burn
-      // excessive CPU time - this also avoids infinite loops due to priority
-      // inversions (https://crbug.com/797129).
-      if (elapsed < TimeDelta::FromMilliseconds(1))
-        PlatformThread::YieldCurrentThread();
-      else
-        PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
-    } while (subtle::Acquire_Load(state) == kLazyInstanceStateCreating);
-  }
-  // Someone else created the instance.
-  return false;
-}
-
-void CompleteLazyInstance(subtle::AtomicWord* state,
-                          subtle::AtomicWord new_instance,
-                          void (*destructor)(void*),
-                          void* destructor_arg) {
-  // Instance is created, go from CREATING to CREATED (or reset it if
-  // |new_instance| is null). Releases visibility over |private_buf_| to
-  // readers. Pairing Acquire_Load is in NeedsLazyInstance().
-  subtle::Release_Store(state, new_instance);
-
-  // Make sure that the lazily instantiated object will get destroyed at exit.
-  if (new_instance && destructor)
-    AtExitManager::RegisterCallback(destructor, destructor_arg);
-}
-
-}  // namespace internal
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/lazy_instance_helpers.h b/native/zucchini/vendor/libchrome/base/lazy_instance_helpers.h
deleted file mode 100644
index 5a43d8b..0000000
--- a/native/zucchini/vendor/libchrome/base/lazy_instance_helpers.h
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_LAZY_INSTANCE_INTERNAL_H_
-#define BASE_LAZY_INSTANCE_INTERNAL_H_
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/logging.h"
-
-// Helper methods used by LazyInstance and a few other base APIs for thread-safe
-// lazy construction.
-
-namespace base {
-namespace internal {
-
-// Our AtomicWord doubles as a spinlock, where a value of
-// kLazyInstanceStateCreating means the spinlock is being held for creation.
-constexpr subtle::AtomicWord kLazyInstanceStateCreating = 1;
-
-// Helper for GetOrCreateLazyPointer(). Checks if instance needs to be created.
-// If so returns true otherwise if another thread has beat us, waits for
-// instance to be created and returns false.
-BASE_EXPORT bool NeedsLazyInstance(subtle::AtomicWord* state);
-
-// Helper for GetOrCreateLazyPointer(). After creating an instance, this is
-// called to register the dtor to be called at program exit and to update the
-// atomic state to hold the |new_instance|
-BASE_EXPORT void CompleteLazyInstance(subtle::AtomicWord* state,
-                                      subtle::AtomicWord new_instance,
-                                      void (*destructor)(void*),
-                                      void* destructor_arg);
-
-}  // namespace internal
-
-namespace subtle {
-
-// If |state| is uninitialized (zero), constructs a value using
-// |creator_func(creator_arg)|, stores it into |state| and registers
-// |destructor(destructor_arg)| to be called when the current AtExitManager goes
-// out of scope. Then, returns the value stored in |state|. It is safe to have
-// concurrent calls to this function with the same |state|. |creator_func| may
-// return nullptr if it doesn't want to create an instance anymore (e.g. on
-// shutdown), it is from then on required to return nullptr to all callers (ref.
-// StaticMemorySingletonTraits). In that case, callers need to synchronize
-// before |creator_func| may return a non-null instance again (ref.
-// StaticMemorySingletonTraits::ResurectForTesting()).
-// Implementation note on |creator_func/creator_arg|. It makes for ugly adapters
-// but it avoids redundant template instantiations (e.g. saves 27KB in
-// chrome.dll) because linker is able to fold these for multiple Types but
-// couldn't with the more advanced CreatorFunc template type which in turn
-// improves code locality (and application startup) -- ref.
-// https://chromium-review.googlesource.com/c/chromium/src/+/530984/5/base/lazy_instance.h#140,
-// worsened by https://chromium-review.googlesource.com/c/chromium/src/+/868013
-// and caught then as https://crbug.com/804034.
-template <typename Type>
-Type* GetOrCreateLazyPointer(subtle::AtomicWord* state,
-                             Type* (*creator_func)(void*),
-                             void* creator_arg,
-                             void (*destructor)(void*),
-                             void* destructor_arg) {
-  DCHECK(state);
-  DCHECK(creator_func);
-
-  // If any bit in the created mask is true, the instance has already been
-  // fully constructed.
-  constexpr subtle::AtomicWord kLazyInstanceCreatedMask =
-      ~internal::kLazyInstanceStateCreating;
-
-  // We will hopefully have fast access when the instance is already created.
-  // Since a thread sees |state| == 0 or kLazyInstanceStateCreating at most
-  // once, the load is taken out of NeedsLazyInstance() as a fast-path. The load
-  // has acquire memory ordering as a thread which sees |state| > creating needs
-  // to acquire visibility over the associated data. Pairing Release_Store is in
-  // CompleteLazyInstance().
-  subtle::AtomicWord instance = subtle::Acquire_Load(state);
-  if (!(instance & kLazyInstanceCreatedMask)) {
-    if (internal::NeedsLazyInstance(state)) {
-      // This thread won the race and is now responsible for creating the
-      // instance and storing it back into |state|.
-      instance =
-          reinterpret_cast<subtle::AtomicWord>((*creator_func)(creator_arg));
-      internal::CompleteLazyInstance(state, instance, destructor,
-                                     destructor_arg);
-    } else {
-      // This thread lost the race but now has visibility over the constructed
-      // instance (NeedsLazyInstance() doesn't return until the constructing
-      // thread releases the instance via CompleteLazyInstance()).
-      instance = subtle::Acquire_Load(state);
-      DCHECK(instance & kLazyInstanceCreatedMask);
-    }
-  }
-  return reinterpret_cast<Type*>(instance);
-}
-
-}  // namespace subtle
-
-}  // namespace base
-
-#endif  // BASE_LAZY_INSTANCE_INTERNAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/location.cc b/native/zucchini/vendor/libchrome/base/location.cc
deleted file mode 100644
index 8bbf6ed..0000000
--- a/native/zucchini/vendor/libchrome/base/location.cc
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/location.h"
-
-#if defined(COMPILER_MSVC)
-#include <intrin.h>
-#endif
-
-#include "base/compiler_specific.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/stringprintf.h"
-#include "build/build_config.h"
-
-namespace base {
-
-Location::Location() = default;
-Location::Location(const Location& other) = default;
-
-Location::Location(const char* file_name, const void* program_counter)
-    : file_name_(file_name), program_counter_(program_counter) {}
-
-Location::Location(const char* function_name,
-                   const char* file_name,
-                   int line_number,
-                   const void* program_counter)
-    : function_name_(function_name),
-      file_name_(file_name),
-      line_number_(line_number),
-      program_counter_(program_counter) {
-#if !defined(OS_NACL)
-  // The program counter should not be null except in a default constructed
-  // (empty) Location object. This value is used for identity, so if it doesn't
-  // uniquely identify a location, things will break.
-  //
-  // The program counter isn't supported in NaCl so location objects won't work
-  // properly in that context.
-  DCHECK(program_counter);
-#endif
-}
-
-std::string Location::ToString() const {
-  if (has_source_info()) {
-    return std::string(function_name_) + "@" + file_name_ + ":" +
-           IntToString(line_number_);
-  }
-  return StringPrintf("pc:%p", program_counter_);
-}
-
-#if defined(COMPILER_MSVC)
-#define RETURN_ADDRESS() _ReturnAddress()
-#elif defined(COMPILER_GCC) && !defined(OS_NACL)
-#define RETURN_ADDRESS() \
-  __builtin_extract_return_addr(__builtin_return_address(0))
-#else
-#define RETURN_ADDRESS() nullptr
-#endif
-
-// static
-NOINLINE Location Location::CreateFromHere(const char* file_name) {
-  return Location(file_name, RETURN_ADDRESS());
-}
-
-// static
-NOINLINE Location Location::CreateFromHere(const char* function_name,
-                                           const char* file_name,
-                                           int line_number) {
-  return Location(function_name, file_name, line_number, RETURN_ADDRESS());
-}
-
-//------------------------------------------------------------------------------
-NOINLINE const void* GetProgramCounter() {
-  return RETURN_ADDRESS();
-}
-
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/location.h b/native/zucchini/vendor/libchrome/base/location.h
deleted file mode 100644
index 14fe2fa..0000000
--- a/native/zucchini/vendor/libchrome/base/location.h
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_LOCATION_H_
-#define BASE_LOCATION_H_
-
-#include <stddef.h>
-
-#include <cassert>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/debug/debugging_buildflags.h"
-#include "base/hash.h"
-
-namespace base {
-
-// Location provides basic info where of an object was constructed, or was
-// significantly brought to life.
-class BASE_EXPORT Location {
- public:
-  Location();
-  Location(const Location& other);
-
-  // Only initializes the file name and program counter, the source information
-  // will be null for the strings, and -1 for the line number.
-  // TODO(http://crbug.com/760702) remove file name from this constructor.
-  Location(const char* file_name, const void* program_counter);
-
-  // Constructor should be called with a long-lived char*, such as __FILE__.
-  // It assumes the provided value will persist as a global constant, and it
-  // will not make a copy of it.
-  Location(const char* function_name,
-           const char* file_name,
-           int line_number,
-           const void* program_counter);
-
-  // Comparator for hash map insertion. The program counter should uniquely
-  // identify a location.
-  bool operator==(const Location& other) const {
-    return program_counter_ == other.program_counter_;
-  }
-
-  // Returns true if there is source code location info. If this is false,
-  // the Location object only contains a program counter or is
-  // default-initialized (the program counter is also null).
-  bool has_source_info() const { return function_name_ && file_name_; }
-
-  // Will be nullptr for default initialized Location objects and when source
-  // names are disabled.
-  const char* function_name() const { return function_name_; }
-
-  // Will be nullptr for default initialized Location objects and when source
-  // names are disabled.
-  const char* file_name() const { return file_name_; }
-
-  // Will be -1 for default initialized Location objects and when source names
-  // are disabled.
-  int line_number() const { return line_number_; }
-
-  // The address of the code generating this Location object. Should always be
-  // valid except for default initialized Location objects, which will be
-  // nullptr.
-  const void* program_counter() const { return program_counter_; }
-
-  // Converts to the most user-readable form possible. If function and filename
-  // are not available, this will return "pc:<hex address>".
-  std::string ToString() const;
-
-  static Location CreateFromHere(const char* file_name);
-  static Location CreateFromHere(const char* function_name,
-                                 const char* file_name,
-                                 int line_number);
-
- private:
-  const char* function_name_ = nullptr;
-  const char* file_name_ = nullptr;
-  int line_number_ = -1;
-  const void* program_counter_ = nullptr;
-};
-
-BASE_EXPORT const void* GetProgramCounter();
-
-// The macros defined here will expand to the current function.
-#if BUILDFLAG(ENABLE_LOCATION_SOURCE)
-
-// Full source information should be included.
-#define FROM_HERE FROM_HERE_WITH_EXPLICIT_FUNCTION(__func__)
-#define FROM_HERE_WITH_EXPLICIT_FUNCTION(function_name) \
-  ::base::Location::CreateFromHere(function_name, __FILE__, __LINE__)
-
-#else
-
-// TODO(http://crbug.com/760702) remove the __FILE__ argument from these calls.
-#define FROM_HERE ::base::Location::CreateFromHere(__FILE__)
-#define FROM_HERE_WITH_EXPLICIT_FUNCTION(function_name) \
-  ::base::Location::CreateFromHere(function_name, __FILE__, -1)
-
-#endif
-
-}  // namespace base
-
-namespace std {
-
-// Specialization for using Location in hash tables.
-template <>
-struct hash<::base::Location> {
-  std::size_t operator()(const ::base::Location& loc) const {
-    const void* program_counter = loc.program_counter();
-    return base::Hash(&program_counter, sizeof(void*));
-  }
-};
-
-}  // namespace std
-
-#endif  // BASE_LOCATION_H_
diff --git a/native/zucchini/vendor/libchrome/base/logging.cc b/native/zucchini/vendor/libchrome/base/logging.cc
deleted file mode 100644
index 5781c63..0000000
--- a/native/zucchini/vendor/libchrome/base/logging.cc
+++ /dev/null
@@ -1,1065 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/logging.h"
-
-#include <limits.h>
-#include <stdint.h>
-
-#include "base/macros.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include <io.h>
-#include <windows.h>
-typedef HANDLE FileHandle;
-typedef HANDLE MutexHandle;
-// Windows warns on using write().  It prefers _write().
-#define write(fd, buf, count) _write(fd, buf, static_cast<unsigned int>(count))
-// Windows doesn't define STDERR_FILENO.  Define it here.
-#define STDERR_FILENO 2
-
-#elif defined(OS_MACOSX)
-// In MacOS 10.12 and iOS 10.0 and later ASL (Apple System Log) was deprecated
-// in favor of OS_LOG (Unified Logging).
-#include <AvailabilityMacros.h>
-#if defined(OS_IOS)
-#if !defined(__IPHONE_10_0) || __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_10_0
-#define USE_ASL
-#endif
-#else  // !defined(OS_IOS)
-#if !defined(MAC_OS_X_VERSION_10_12) || \
-    MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_12
-#define USE_ASL
-#endif
-#endif  // defined(OS_IOS)
-
-#if defined(USE_ASL)
-#include <asl.h>
-#else
-#include <os/log.h>
-#endif
-
-#include <CoreFoundation/CoreFoundation.h>
-#include <mach/mach.h>
-#include <mach/mach_time.h>
-#include <mach-o/dyld.h>
-
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#if defined(OS_NACL)
-#include <sys/time.h>  // timespec doesn't seem to be in <time.h>
-#endif
-#include <time.h>
-#endif
-
-#if defined(OS_FUCHSIA)
-#include <zircon/process.h>
-#include <zircon/syscalls.h>
-#endif
-
-#if defined(OS_ANDROID)
-#include <android/log.h>
-#endif
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <errno.h>
-#include <paths.h>
-#include <pthread.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#define MAX_PATH PATH_MAX
-typedef FILE* FileHandle;
-typedef pthread_mutex_t* MutexHandle;
-#endif
-
-#include <algorithm>
-#include <cstring>
-#include <ctime>
-#include <iomanip>
-#include <ostream>
-#include <string>
-#include <utility>
-
-#include "base/base_switches.h"
-#include "base/callback.h"
-#include "base/command_line.h"
-#include "base/containers/stack.h"
-#include "base/debug/activity_tracker.h"
-#include "base/debug/alias.h"
-#include "base/debug/debugger.h"
-#include "base/debug/stack_trace.h"
-#include "base/lazy_instance.h"
-#include "base/posix/eintr_wrapper.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/sys_string_conversions.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/synchronization/lock_impl.h"
-#include "base/threading/platform_thread.h"
-#include "base/vlog.h"
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include "base/posix/safe_strerror.h"
-#endif
-
-namespace logging {
-
-namespace {
-
-VlogInfo* g_vlog_info = nullptr;
-VlogInfo* g_vlog_info_prev = nullptr;
-
-const char* const log_severity_names[] = {"INFO", "WARNING", "ERROR", "FATAL"};
-static_assert(LOG_NUM_SEVERITIES == arraysize(log_severity_names),
-              "Incorrect number of log_severity_names");
-
-const char* log_severity_name(int severity) {
-  if (severity >= 0 && severity < LOG_NUM_SEVERITIES)
-    return log_severity_names[severity];
-  return "UNKNOWN";
-}
-
-int g_min_log_level = 0;
-
-LoggingDestination g_logging_destination = LOG_DEFAULT;
-
-// For LOG_ERROR and above, always print to stderr.
-const int kAlwaysPrintErrorLevel = LOG_ERROR;
-
-// Which log file to use? This is initialized by InitLogging or
-// will be lazily initialized to the default value when it is
-// first needed.
-#if defined(OS_WIN)
-typedef std::wstring PathString;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-typedef std::string PathString;
-#endif
-PathString* g_log_file_name = nullptr;
-
-// This file is lazily opened and the handle may be nullptr
-FileHandle g_log_file = nullptr;
-
-// What should be prepended to each message?
-bool g_log_process_id = false;
-bool g_log_thread_id = false;
-bool g_log_timestamp = true;
-bool g_log_tickcount = false;
-
-// Should we pop up fatal debug messages in a dialog?
-bool show_error_dialogs = false;
-
-// An assert handler override specified by the client to be called instead of
-// the debug message dialog and process termination. Assert handlers are stored
-// in stack to allow overriding and restoring.
-base::LazyInstance<base::stack<LogAssertHandlerFunction>>::Leaky
-    log_assert_handler_stack = LAZY_INSTANCE_INITIALIZER;
-
-// A log message handler that gets notified of every log message we process.
-LogMessageHandlerFunction log_message_handler = nullptr;
-
-// Helper functions to wrap platform differences.
-
-int32_t CurrentProcessId() {
-#if defined(OS_WIN)
-  return GetCurrentProcessId();
-#elif defined(OS_FUCHSIA)
-  zx_info_handle_basic_t basic = {};
-  zx_object_get_info(zx_process_self(), ZX_INFO_HANDLE_BASIC, &basic,
-                     sizeof(basic), nullptr, nullptr);
-  return basic.koid;
-#elif defined(OS_POSIX)
-  return getpid();
-#endif
-}
-
-uint64_t TickCount() {
-#if defined(OS_WIN)
-  return GetTickCount();
-#elif defined(OS_FUCHSIA)
-  return zx_clock_get(ZX_CLOCK_MONOTONIC) /
-         static_cast<zx_time_t>(base::Time::kNanosecondsPerMicrosecond);
-#elif defined(OS_MACOSX)
-  return mach_absolute_time();
-#elif defined(OS_NACL)
-  // NaCl sadly does not have _POSIX_TIMERS enabled in sys/features.h
-  // So we have to use clock() for now.
-  return clock();
-#elif defined(OS_POSIX)
-  struct timespec ts;
-  clock_gettime(CLOCK_MONOTONIC, &ts);
-
-  uint64_t absolute_micro = static_cast<int64_t>(ts.tv_sec) * 1000000 +
-                            static_cast<int64_t>(ts.tv_nsec) / 1000;
-
-  return absolute_micro;
-#endif
-}
-
-void DeleteFilePath(const PathString& log_name) {
-#if defined(OS_WIN)
-  DeleteFile(log_name.c_str());
-#elif defined(OS_NACL)
-  // Do nothing; unlink() isn't supported on NaCl.
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  unlink(log_name.c_str());
-#else
-#error Unsupported platform
-#endif
-}
-
-PathString GetDefaultLogFile() {
-#if defined(OS_WIN)
-  // On Windows we use the same path as the exe.
-  wchar_t module_name[MAX_PATH];
-  GetModuleFileName(nullptr, module_name, MAX_PATH);
-
-  PathString log_name = module_name;
-  PathString::size_type last_backslash = log_name.rfind('\\', log_name.size());
-  if (last_backslash != PathString::npos)
-    log_name.erase(last_backslash + 1);
-  log_name += L"debug.log";
-  return log_name;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  // On other platforms we just use the current directory.
-  return PathString("debug.log");
-#endif
-}
-
-// We don't need locks on Windows for atomically appending to files. The OS
-// provides this functionality.
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-// This class acts as a wrapper for locking the logging files.
-// LoggingLock::Init() should be called from the main thread before any logging
-// is done. Then whenever logging, be sure to have a local LoggingLock
-// instance on the stack. This will ensure that the lock is unlocked upon
-// exiting the frame.
-// LoggingLocks can not be nested.
-class LoggingLock {
- public:
-  LoggingLock() {
-    LockLogging();
-  }
-
-  ~LoggingLock() {
-    UnlockLogging();
-  }
-
-  static void Init(LogLockingState lock_log, const PathChar* new_log_file) {
-    if (initialized)
-      return;
-    lock_log_file = lock_log;
-
-    if (lock_log_file != LOCK_LOG_FILE)
-      log_lock = new base::internal::LockImpl();
-
-    initialized = true;
-  }
-
- private:
-  static void LockLogging() {
-    if (lock_log_file == LOCK_LOG_FILE) {
-      pthread_mutex_lock(&log_mutex);
-    } else {
-      // use the lock
-      log_lock->Lock();
-    }
-  }
-
-  static void UnlockLogging() {
-    if (lock_log_file == LOCK_LOG_FILE) {
-      pthread_mutex_unlock(&log_mutex);
-    } else {
-      log_lock->Unlock();
-    }
-  }
-
-  // The lock is used if log file locking is false. It helps us avoid problems
-  // with multiple threads writing to the log file at the same time.  Use
-  // LockImpl directly instead of using Lock, because Lock makes logging calls.
-  static base::internal::LockImpl* log_lock;
-
-  // When we don't use a lock, we are using a global mutex. We need to do this
-  // because LockFileEx is not thread safe.
-  static pthread_mutex_t log_mutex;
-
-  static bool initialized;
-  static LogLockingState lock_log_file;
-};
-
-// static
-bool LoggingLock::initialized = false;
-// static
-base::internal::LockImpl* LoggingLock::log_lock = nullptr;
-// static
-LogLockingState LoggingLock::lock_log_file = LOCK_LOG_FILE;
-
-pthread_mutex_t LoggingLock::log_mutex = PTHREAD_MUTEX_INITIALIZER;
-
-#endif  // OS_POSIX || OS_FUCHSIA
-
-// Called by logging functions to ensure that |g_log_file| is initialized
-// and can be used for writing. Returns false if the file could not be
-// initialized. |g_log_file| will be nullptr in this case.
-bool InitializeLogFileHandle() {
-  if (g_log_file)
-    return true;
-
-  if (!g_log_file_name) {
-    // Nobody has called InitLogging to specify a debug log file, so here we
-    // initialize the log file name to a default.
-    g_log_file_name = new PathString(GetDefaultLogFile());
-  }
-
-  if ((g_logging_destination & LOG_TO_FILE) != 0) {
-#if defined(OS_WIN)
-    // The FILE_APPEND_DATA access mask ensures that the file is atomically
-    // appended to across accesses from multiple threads.
-    // https://msdn.microsoft.com/en-us/library/windows/desktop/aa364399(v=vs.85).aspx
-    // https://msdn.microsoft.com/en-us/library/windows/desktop/aa363858(v=vs.85).aspx
-    g_log_file = CreateFile(g_log_file_name->c_str(), FILE_APPEND_DATA,
-                            FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
-                            OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
-    if (g_log_file == INVALID_HANDLE_VALUE || g_log_file == nullptr) {
-      // We are intentionally not using FilePath or FileUtil here to reduce the
-      // dependencies of the logging implementation. For e.g. FilePath and
-      // FileUtil depend on shell32 and user32.dll. This is not acceptable for
-      // some consumers of base logging like chrome_elf, etc.
-      // Please don't change the code below to use FilePath.
-      // try the current directory
-      wchar_t system_buffer[MAX_PATH];
-      system_buffer[0] = 0;
-      DWORD len = ::GetCurrentDirectory(arraysize(system_buffer),
-                                        system_buffer);
-      if (len == 0 || len > arraysize(system_buffer))
-        return false;
-
-      *g_log_file_name = system_buffer;
-      // Append a trailing backslash if needed.
-      if (g_log_file_name->back() != L'\\')
-        *g_log_file_name += L"\\";
-      *g_log_file_name += L"debug.log";
-
-      g_log_file = CreateFile(g_log_file_name->c_str(), FILE_APPEND_DATA,
-                              FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
-                              OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
-      if (g_log_file == INVALID_HANDLE_VALUE || g_log_file == nullptr) {
-        g_log_file = nullptr;
-        return false;
-      }
-    }
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-    g_log_file = fopen(g_log_file_name->c_str(), "a");
-    if (g_log_file == nullptr)
-      return false;
-#else
-#error Unsupported platform
-#endif
-  }
-
-  return true;
-}
-
-void CloseFile(FileHandle log) {
-#if defined(OS_WIN)
-  CloseHandle(log);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  fclose(log);
-#else
-#error Unsupported platform
-#endif
-}
-
-void CloseLogFileUnlocked() {
-  if (!g_log_file)
-    return;
-
-  CloseFile(g_log_file);
-  g_log_file = nullptr;
-}
-
-}  // namespace
-
-#if DCHECK_IS_CONFIGURABLE
-// In DCHECK-enabled Chrome builds, allow the meaning of LOG_DCHECK to be
-// determined at run-time. We default it to INFO, to avoid it triggering
-// crashes before the run-time has explicitly chosen the behaviour.
-BASE_EXPORT logging::LogSeverity LOG_DCHECK = LOG_INFO;
-#endif  // DCHECK_IS_CONFIGURABLE
-
-// This is never instantiated, it's just used for EAT_STREAM_PARAMETERS to have
-// an object of the correct type on the LHS of the unused part of the ternary
-// operator.
-std::ostream* g_swallow_stream;
-
-LoggingSettings::LoggingSettings()
-    : logging_dest(LOG_DEFAULT),
-      log_file(nullptr),
-      lock_log(LOCK_LOG_FILE),
-      delete_old(APPEND_TO_OLD_LOG_FILE) {}
-
-bool BaseInitLoggingImpl(const LoggingSettings& settings) {
-#if defined(OS_NACL)
-  // Can log only to the system debug log.
-  CHECK_EQ(settings.logging_dest & ~LOG_TO_SYSTEM_DEBUG_LOG, 0);
-#endif
-  if (base::CommandLine::InitializedForCurrentProcess()) {
-    base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
-    // Don't bother initializing |g_vlog_info| unless we use one of the
-    // vlog switches.
-    if (command_line->HasSwitch(switches::kV) ||
-        command_line->HasSwitch(switches::kVModule)) {
-      // NOTE: If |g_vlog_info| has already been initialized, it might be in use
-      // by another thread. Don't delete the old VLogInfo, just create a second
-      // one. We keep track of both to avoid memory leak warnings.
-      CHECK(!g_vlog_info_prev);
-      g_vlog_info_prev = g_vlog_info;
-
-      g_vlog_info =
-          new VlogInfo(command_line->GetSwitchValueASCII(switches::kV),
-                       command_line->GetSwitchValueASCII(switches::kVModule),
-                       &g_min_log_level);
-    }
-  }
-
-  g_logging_destination = settings.logging_dest;
-
-  // ignore file options unless logging to file is set.
-  if ((g_logging_destination & LOG_TO_FILE) == 0)
-    return true;
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-  LoggingLock::Init(settings.lock_log, settings.log_file);
-  LoggingLock logging_lock;
-#endif
-
-  // Calling InitLogging twice or after some log call has already opened the
-  // default log file will re-initialize to the new options.
-  CloseLogFileUnlocked();
-
-  if (!g_log_file_name)
-    g_log_file_name = new PathString();
-  *g_log_file_name = settings.log_file;
-  if (settings.delete_old == DELETE_OLD_LOG_FILE)
-    DeleteFilePath(*g_log_file_name);
-
-  return InitializeLogFileHandle();
-}
-
-void SetMinLogLevel(int level) {
-  g_min_log_level = std::min(LOG_FATAL, level);
-}
-
-int GetMinLogLevel() {
-  return g_min_log_level;
-}
-
-bool ShouldCreateLogMessage(int severity) {
-  if (severity < g_min_log_level)
-    return false;
-
-  // Return true here unless we know ~LogMessage won't do anything. Note that
-  // ~LogMessage writes to stderr if severity_ >= kAlwaysPrintErrorLevel, even
-  // when g_logging_destination is LOG_NONE.
-  return g_logging_destination != LOG_NONE || log_message_handler ||
-         severity >= kAlwaysPrintErrorLevel;
-}
-
-int GetVlogVerbosity() {
-  return std::max(-1, LOG_INFO - GetMinLogLevel());
-}
-
-int GetVlogLevelHelper(const char* file, size_t N) {
-  DCHECK_GT(N, 0U);
-  // Note: |g_vlog_info| may change on a different thread during startup
-  // (but will always be valid or nullptr).
-  VlogInfo* vlog_info = g_vlog_info;
-  return vlog_info ?
-      vlog_info->GetVlogLevel(base::StringPiece(file, N - 1)) :
-      GetVlogVerbosity();
-}
-
-void SetLogItems(bool enable_process_id, bool enable_thread_id,
-                 bool enable_timestamp, bool enable_tickcount) {
-  g_log_process_id = enable_process_id;
-  g_log_thread_id = enable_thread_id;
-  g_log_timestamp = enable_timestamp;
-  g_log_tickcount = enable_tickcount;
-}
-
-void SetShowErrorDialogs(bool enable_dialogs) {
-  show_error_dialogs = enable_dialogs;
-}
-
-ScopedLogAssertHandler::ScopedLogAssertHandler(
-    LogAssertHandlerFunction handler) {
-  log_assert_handler_stack.Get().push(std::move(handler));
-}
-
-ScopedLogAssertHandler::~ScopedLogAssertHandler() {
-  log_assert_handler_stack.Get().pop();
-}
-
-void SetLogMessageHandler(LogMessageHandlerFunction handler) {
-  log_message_handler = handler;
-}
-
-LogMessageHandlerFunction GetLogMessageHandler() {
-  return log_message_handler;
-}
-
-// Explicit instantiations for commonly used comparisons.
-template std::string* MakeCheckOpString<int, int>(
-    const int&, const int&, const char* names);
-template std::string* MakeCheckOpString<unsigned long, unsigned long>(
-    const unsigned long&, const unsigned long&, const char* names);
-template std::string* MakeCheckOpString<unsigned long, unsigned int>(
-    const unsigned long&, const unsigned int&, const char* names);
-template std::string* MakeCheckOpString<unsigned int, unsigned long>(
-    const unsigned int&, const unsigned long&, const char* names);
-template std::string* MakeCheckOpString<std::string, std::string>(
-    const std::string&, const std::string&, const char* name);
-
-void MakeCheckOpValueString(std::ostream* os, std::nullptr_t p) {
-  (*os) << "nullptr";
-}
-
-#if !defined(NDEBUG)
-// Displays a message box to the user with the error message in it.
-// Used for fatal messages, where we close the app simultaneously.
-// This is for developers only; we don't use this in circumstances
-// (like release builds) where users could see it, since users don't
-// understand these messages anyway.
-void DisplayDebugMessageInDialog(const std::string& str) {
-  if (str.empty())
-    return;
-
-  if (!show_error_dialogs)
-    return;
-
-#if defined(OS_WIN)
-  // We intentionally don't implement a dialog on other platforms.
-  // You can just look at stderr.
-  MessageBoxW(nullptr, base::UTF8ToUTF16(str).c_str(), L"Fatal error",
-              MB_OK | MB_ICONHAND | MB_TOPMOST);
-#endif  // defined(OS_WIN)
-}
-#endif  // !defined(NDEBUG)
-
-#if defined(OS_WIN)
-LogMessage::SaveLastError::SaveLastError() : last_error_(::GetLastError()) {
-}
-
-LogMessage::SaveLastError::~SaveLastError() {
-  ::SetLastError(last_error_);
-}
-#endif  // defined(OS_WIN)
-
-LogMessage::LogMessage(const char* file, int line, LogSeverity severity)
-    : severity_(severity), file_(file), line_(line) {
-  Init(file, line);
-}
-
-LogMessage::LogMessage(const char* file, int line, const char* condition)
-    : severity_(LOG_FATAL), file_(file), line_(line) {
-  Init(file, line);
-  stream_ << "Check failed: " << condition << ". ";
-}
-
-LogMessage::LogMessage(const char* file, int line, std::string* result)
-    : severity_(LOG_FATAL), file_(file), line_(line) {
-  Init(file, line);
-  stream_ << "Check failed: " << *result;
-  delete result;
-}
-
-LogMessage::LogMessage(const char* file, int line, LogSeverity severity,
-                       std::string* result)
-    : severity_(severity), file_(file), line_(line) {
-  Init(file, line);
-  stream_ << "Check failed: " << *result;
-  delete result;
-}
-
-LogMessage::~LogMessage() {
-  size_t stack_start = stream_.tellp();
-#if !defined(OFFICIAL_BUILD) && !defined(OS_NACL) && !defined(__UCLIBC__) && \
-    !defined(OS_AIX)
-  if (severity_ == LOG_FATAL && !base::debug::BeingDebugged()) {
-    // Include a stack trace on a fatal, unless a debugger is attached.
-    base::debug::StackTrace trace;
-    stream_ << std::endl;  // Newline to separate from log message.
-    trace.OutputToStream(&stream_);
-  }
-#endif
-  stream_ << std::endl;
-  std::string str_newline(stream_.str());
-
-  // Give any log message handler first dibs on the message.
-  if (log_message_handler &&
-      log_message_handler(severity_, file_, line_,
-                          message_start_, str_newline)) {
-    // The handler took care of it, no further processing.
-    return;
-  }
-
-  if ((g_logging_destination & LOG_TO_SYSTEM_DEBUG_LOG) != 0) {
-#if defined(OS_WIN)
-    OutputDebugStringA(str_newline.c_str());
-#elif defined(OS_MACOSX)
-    // In LOG_TO_SYSTEM_DEBUG_LOG mode, log messages are always written to
-    // stderr. If stderr is /dev/null, also log via ASL (Apple System Log) or
-    // its successor OS_LOG. If there's something weird about stderr, assume
-    // that log messages are going nowhere and log via ASL/OS_LOG too.
-    // Messages logged via ASL/OS_LOG show up in Console.app.
-    //
-    // Programs started by launchd, as UI applications normally are, have had
-    // stderr connected to /dev/null since OS X 10.8. Prior to that, stderr was
-    // a pipe to launchd, which logged what it received (see log_redirect_fd in
-    // 10.7.5 launchd-392.39/launchd/src/launchd_core_logic.c).
-    //
-    // Another alternative would be to determine whether stderr is a pipe to
-    // launchd and avoid logging via ASL only in that case. See 10.7.5
-    // CF-635.21/CFUtilities.c also_do_stderr(). This would result in logging to
-    // both stderr and ASL/OS_LOG even in tests, where it's undesirable to log
-    // to the system log at all.
-    //
-    // Note that the ASL client by default discards messages whose levels are
-    // below ASL_LEVEL_NOTICE. It's possible to change that with
-    // asl_set_filter(), but this is pointless because syslogd normally applies
-    // the same filter.
-    const bool log_to_system = []() {
-      struct stat stderr_stat;
-      if (fstat(fileno(stderr), &stderr_stat) == -1) {
-        return true;
-      }
-      if (!S_ISCHR(stderr_stat.st_mode)) {
-        return false;
-      }
-
-      struct stat dev_null_stat;
-      if (stat(_PATH_DEVNULL, &dev_null_stat) == -1) {
-        return true;
-      }
-
-      return !S_ISCHR(dev_null_stat.st_mode) ||
-             stderr_stat.st_rdev == dev_null_stat.st_rdev;
-    }();
-
-    if (log_to_system) {
-      // Log roughly the same way that CFLog() and NSLog() would. See 10.10.5
-      // CF-1153.18/CFUtilities.c __CFLogCString().
-      CFBundleRef main_bundle = CFBundleGetMainBundle();
-      CFStringRef main_bundle_id_cf =
-          main_bundle ? CFBundleGetIdentifier(main_bundle) : nullptr;
-      std::string main_bundle_id =
-          main_bundle_id_cf ? base::SysCFStringRefToUTF8(main_bundle_id_cf)
-                            : std::string("");
-#if defined(USE_ASL)
-      // The facility is set to the main bundle ID if available. Otherwise,
-      // "com.apple.console" is used.
-      const class ASLClient {
-       public:
-        explicit ASLClient(const std::string& facility)
-            : client_(asl_open(nullptr, facility.c_str(), ASL_OPT_NO_DELAY)) {}
-        ~ASLClient() { asl_close(client_); }
-
-        aslclient get() const { return client_; }
-
-       private:
-        aslclient client_;
-        DISALLOW_COPY_AND_ASSIGN(ASLClient);
-      } asl_client(main_bundle_id.empty() ? main_bundle_id
-                                          : "com.apple.console");
-
-      const class ASLMessage {
-       public:
-        ASLMessage() : message_(asl_new(ASL_TYPE_MSG)) {}
-        ~ASLMessage() { asl_free(message_); }
-
-        aslmsg get() const { return message_; }
-
-       private:
-        aslmsg message_;
-        DISALLOW_COPY_AND_ASSIGN(ASLMessage);
-      } asl_message;
-
-      // By default, messages are only readable by the admin group. Explicitly
-      // make them readable by the user generating the messages.
-      char euid_string[12];
-      snprintf(euid_string, arraysize(euid_string), "%d", geteuid());
-      asl_set(asl_message.get(), ASL_KEY_READ_UID, euid_string);
-
-      // Map Chrome log severities to ASL log levels.
-      const char* const asl_level_string = [](LogSeverity severity) {
-        // ASL_LEVEL_* are ints, but ASL needs equivalent strings. This
-        // non-obvious two-step macro trick achieves what's needed.
-        // https://gcc.gnu.org/onlinedocs/cpp/Stringification.html
-#define ASL_LEVEL_STR(level) ASL_LEVEL_STR_X(level)
-#define ASL_LEVEL_STR_X(level) #level
-        switch (severity) {
-          case LOG_INFO:
-            return ASL_LEVEL_STR(ASL_LEVEL_INFO);
-          case LOG_WARNING:
-            return ASL_LEVEL_STR(ASL_LEVEL_WARNING);
-          case LOG_ERROR:
-            return ASL_LEVEL_STR(ASL_LEVEL_ERR);
-          case LOG_FATAL:
-            return ASL_LEVEL_STR(ASL_LEVEL_CRIT);
-          default:
-            return severity < 0 ? ASL_LEVEL_STR(ASL_LEVEL_DEBUG)
-                                : ASL_LEVEL_STR(ASL_LEVEL_NOTICE);
-        }
-#undef ASL_LEVEL_STR
-#undef ASL_LEVEL_STR_X
-      }(severity_);
-      asl_set(asl_message.get(), ASL_KEY_LEVEL, asl_level_string);
-
-      asl_set(asl_message.get(), ASL_KEY_MSG, str_newline.c_str());
-
-      asl_send(asl_client.get(), asl_message.get());
-#else   // !defined(USE_ASL)
-      const class OSLog {
-       public:
-        explicit OSLog(const char* subsystem)
-            : os_log_(subsystem ? os_log_create(subsystem, "chromium_logging")
-                                : OS_LOG_DEFAULT) {}
-        ~OSLog() {
-          if (os_log_ != OS_LOG_DEFAULT) {
-            os_release(os_log_);
-          }
-        }
-        os_log_t get() const { return os_log_; }
-
-       private:
-        os_log_t os_log_;
-        DISALLOW_COPY_AND_ASSIGN(OSLog);
-      } log(main_bundle_id.empty() ? nullptr : main_bundle_id.c_str());
-      const os_log_type_t os_log_type = [](LogSeverity severity) {
-        switch (severity) {
-          case LOG_INFO:
-            return OS_LOG_TYPE_INFO;
-          case LOG_WARNING:
-            return OS_LOG_TYPE_DEFAULT;
-          case LOG_ERROR:
-            return OS_LOG_TYPE_ERROR;
-          case LOG_FATAL:
-            return OS_LOG_TYPE_FAULT;
-          default:
-            return severity < 0 ? OS_LOG_TYPE_DEBUG : OS_LOG_TYPE_DEFAULT;
-        }
-      }(severity_);
-      os_log_with_type(log.get(), os_log_type, "%{public}s",
-                       str_newline.c_str());
-#endif  // defined(USE_ASL)
-    }
-#elif defined(OS_ANDROID)
-    android_LogPriority priority =
-        (severity_ < 0) ? ANDROID_LOG_VERBOSE : ANDROID_LOG_UNKNOWN;
-    switch (severity_) {
-      case LOG_INFO:
-        priority = ANDROID_LOG_INFO;
-        break;
-      case LOG_WARNING:
-        priority = ANDROID_LOG_WARN;
-        break;
-      case LOG_ERROR:
-        priority = ANDROID_LOG_ERROR;
-        break;
-      case LOG_FATAL:
-        priority = ANDROID_LOG_FATAL;
-        break;
-    }
-#if 0 // This is for building Chromium browser on Android.
-    __android_log_write(priority, "chromium", str_newline.c_str());
-#else
-    __android_log_write(
-        priority,
-        base::CommandLine::InitializedForCurrentProcess() ?
-            base::CommandLine::ForCurrentProcess()->
-                GetProgram().BaseName().value().c_str() : nullptr,
-        str_newline.c_str());
-#endif  // 0
-#endif  // defined(OS_ANDROID)
-    ignore_result(fwrite(str_newline.data(), str_newline.size(), 1, stderr));
-    fflush(stderr);
-  } else if (severity_ >= kAlwaysPrintErrorLevel) {
-    // When we're only outputting to a log file, above a certain log level, we
-    // should still output to stderr so that we can better detect and diagnose
-    // problems with unit tests, especially on the buildbots.
-    ignore_result(fwrite(str_newline.data(), str_newline.size(), 1, stderr));
-    fflush(stderr);
-  }
-
-  // write to log file
-  if ((g_logging_destination & LOG_TO_FILE) != 0) {
-    // We can have multiple threads and/or processes, so try to prevent them
-    // from clobbering each other's writes.
-    // If the client app did not call InitLogging, and the lock has not
-    // been created do it now. We do this on demand, but if two threads try
-    // to do this at the same time, there will be a race condition to create
-    // the lock. This is why InitLogging should be called from the main
-    // thread at the beginning of execution.
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-    LoggingLock::Init(LOCK_LOG_FILE, nullptr);
-    LoggingLock logging_lock;
-#endif
-    if (InitializeLogFileHandle()) {
-#if defined(OS_WIN)
-      DWORD num_written;
-      WriteFile(g_log_file,
-                static_cast<const void*>(str_newline.c_str()),
-                static_cast<DWORD>(str_newline.length()),
-                &num_written,
-                nullptr);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-      ignore_result(fwrite(
-          str_newline.data(), str_newline.size(), 1, g_log_file));
-      fflush(g_log_file);
-#else
-#error Unsupported platform
-#endif
-    }
-  }
-
-  if (severity_ == LOG_FATAL) {
-    // Write the log message to the global activity tracker, if running.
-    base::debug::GlobalActivityTracker* tracker =
-        base::debug::GlobalActivityTracker::Get();
-    if (tracker)
-      tracker->RecordLogMessage(str_newline);
-
-    // Ensure the first characters of the string are on the stack so they
-    // are contained in minidumps for diagnostic purposes.
-    DEBUG_ALIAS_FOR_CSTR(str_stack, str_newline.c_str(), 1024);
-
-    if (log_assert_handler_stack.IsCreated() &&
-        !log_assert_handler_stack.Get().empty()) {
-      LogAssertHandlerFunction log_assert_handler =
-          log_assert_handler_stack.Get().top();
-
-      if (log_assert_handler) {
-        log_assert_handler.Run(
-            file_, line_,
-            base::StringPiece(str_newline.c_str() + message_start_,
-                              stack_start - message_start_),
-            base::StringPiece(str_newline.c_str() + stack_start));
-      }
-    } else {
-      // Don't use the string with the newline, get a fresh version to send to
-      // the debug message process. We also don't display assertions to the
-      // user in release mode. The enduser can't do anything with this
-      // information, and displaying message boxes when the application is
-      // hosed can cause additional problems.
-#ifndef NDEBUG
-      if (!base::debug::BeingDebugged()) {
-        // Displaying a dialog is unnecessary when debugging and can complicate
-        // debugging.
-        DisplayDebugMessageInDialog(stream_.str());
-      }
-#endif
-      // Crash the process to generate a dump.
-      base::debug::BreakDebugger();
-    }
-  }
-}
-
-// writes the common header info to the stream
-void LogMessage::Init(const char* file, int line) {
-  base::StringPiece filename(file);
-  size_t last_slash_pos = filename.find_last_of("\\/");
-  if (last_slash_pos != base::StringPiece::npos)
-    filename.remove_prefix(last_slash_pos + 1);
-
-  // TODO(darin): It might be nice if the columns were fixed width.
-
-  stream_ <<  '[';
-  if (g_log_process_id)
-    stream_ << CurrentProcessId() << ':';
-  if (g_log_thread_id)
-    stream_ << base::PlatformThread::CurrentId() << ':';
-  if (g_log_timestamp) {
-#if defined(OS_WIN)
-    SYSTEMTIME local_time;
-    GetLocalTime(&local_time);
-    stream_ << std::setfill('0')
-            << std::setw(2) << local_time.wMonth
-            << std::setw(2) << local_time.wDay
-            << '/'
-            << std::setw(2) << local_time.wHour
-            << std::setw(2) << local_time.wMinute
-            << std::setw(2) << local_time.wSecond
-            << '.'
-            << std::setw(3)
-            << local_time.wMilliseconds
-            << ':';
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-    timeval tv;
-    gettimeofday(&tv, nullptr);
-    time_t t = tv.tv_sec;
-    struct tm local_time;
-    localtime_r(&t, &local_time);
-    struct tm* tm_time = &local_time;
-    stream_ << std::setfill('0')
-            << std::setw(2) << 1 + tm_time->tm_mon
-            << std::setw(2) << tm_time->tm_mday
-            << '/'
-            << std::setw(2) << tm_time->tm_hour
-            << std::setw(2) << tm_time->tm_min
-            << std::setw(2) << tm_time->tm_sec
-            << '.'
-            << std::setw(6) << tv.tv_usec
-            << ':';
-#else
-#error Unsupported platform
-#endif
-  }
-  if (g_log_tickcount)
-    stream_ << TickCount() << ':';
-  if (severity_ >= 0)
-    stream_ << log_severity_name(severity_);
-  else
-    stream_ << "VERBOSE" << -severity_;
-
-  stream_ << ":" << filename << "(" << line << ")] ";
-
-  message_start_ = stream_.str().length();
-}
-
-#if defined(OS_WIN)
-// This has already been defined in the header, but defining it again as DWORD
-// ensures that the type used in the header is equivalent to DWORD. If not,
-// the redefinition is a compile error.
-typedef DWORD SystemErrorCode;
-#endif
-
-SystemErrorCode GetLastSystemErrorCode() {
-#if defined(OS_WIN)
-  return ::GetLastError();
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  return errno;
-#endif
-}
-
-BASE_EXPORT std::string SystemErrorCodeToString(SystemErrorCode error_code) {
-#if defined(OS_WIN)
-  const int kErrorMessageBufferSize = 256;
-  char msgbuf[kErrorMessageBufferSize];
-  DWORD flags = FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS;
-  DWORD len = FormatMessageA(flags, nullptr, error_code, 0, msgbuf,
-                             arraysize(msgbuf), nullptr);
-  if (len) {
-    // Messages returned by system end with line breaks.
-    return base::CollapseWhitespaceASCII(msgbuf, true) +
-           base::StringPrintf(" (0x%lX)", error_code);
-  }
-  return base::StringPrintf("Error (0x%lX) while retrieving error. (0x%lX)",
-                            GetLastError(), error_code);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  return base::safe_strerror(error_code) +
-         base::StringPrintf(" (%d)", error_code);
-#endif  // defined(OS_WIN)
-}
-
-
-#if defined(OS_WIN)
-Win32ErrorLogMessage::Win32ErrorLogMessage(const char* file,
-                                           int line,
-                                           LogSeverity severity,
-                                           SystemErrorCode err)
-    : err_(err),
-      log_message_(file, line, severity) {
-}
-
-Win32ErrorLogMessage::~Win32ErrorLogMessage() {
-  stream() << ": " << SystemErrorCodeToString(err_);
-  // We're about to crash (CHECK). Put |err_| on the stack (by placing it in a
-  // field) and use Alias in hopes that it makes it into crash dumps.
-  DWORD last_error = err_;
-  base::debug::Alias(&last_error);
-}
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-ErrnoLogMessage::ErrnoLogMessage(const char* file,
-                                 int line,
-                                 LogSeverity severity,
-                                 SystemErrorCode err)
-    : err_(err),
-      log_message_(file, line, severity) {
-}
-
-ErrnoLogMessage::~ErrnoLogMessage() {
-  stream() << ": " << SystemErrorCodeToString(err_);
-  // We're about to crash (CHECK). Put |err_| on the stack (by placing it in a
-  // field) and use Alias in hopes that it makes it into crash dumps.
-  int last_error = err_;
-  base::debug::Alias(&last_error);
-}
-#endif  // defined(OS_WIN)
-
-void CloseLogFile() {
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-  LoggingLock logging_lock;
-#endif
-  CloseLogFileUnlocked();
-}
-
-void RawLog(int level, const char* message) {
-  if (level >= g_min_log_level && message) {
-    size_t bytes_written = 0;
-    const size_t message_len = strlen(message);
-    int rv;
-    while (bytes_written < message_len) {
-      rv = HANDLE_EINTR(
-          write(STDERR_FILENO, message + bytes_written,
-                message_len - bytes_written));
-      if (rv < 0) {
-        // Give up, nothing we can do now.
-        break;
-      }
-      bytes_written += rv;
-    }
-
-    if (message_len > 0 && message[message_len - 1] != '\n') {
-      do {
-        rv = HANDLE_EINTR(write(STDERR_FILENO, "\n", 1));
-        if (rv < 0) {
-          // Give up, nothing we can do now.
-          break;
-        }
-      } while (rv != 1);
-    }
-  }
-
-  if (level == LOG_FATAL)
-    base::debug::BreakDebugger();
-}
-
-// This was defined at the beginning of this file.
-#undef write
-
-#if defined(OS_WIN)
-bool IsLoggingToFileEnabled() {
-  return g_logging_destination & LOG_TO_FILE;
-}
-
-std::wstring GetLogFileFullPath() {
-  if (g_log_file_name)
-    return *g_log_file_name;
-  return std::wstring();
-}
-#endif
-
-BASE_EXPORT void LogErrorNotReached(const char* file, int line) {
-  LogMessage(file, line, LOG_ERROR).stream()
-      << "NOTREACHED() hit.";
-}
-
-}  // namespace logging
-
-std::ostream& std::operator<<(std::ostream& out, const wchar_t* wstr) {
-  return out << (wstr ? base::WideToUTF8(wstr) : std::string());
-}
diff --git a/native/zucchini/vendor/libchrome/base/logging.h b/native/zucchini/vendor/libchrome/base/logging.h
deleted file mode 100644
index 08c1f0f..0000000
--- a/native/zucchini/vendor/libchrome/base/logging.h
+++ /dev/null
@@ -1,1179 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_LOGGING_H_
-#define BASE_LOGGING_H_
-
-#include <stddef.h>
-
-#include <cassert>
-#include <cstring>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-#include "base/base_export.h"
-#include "base/callback_forward.h"
-#include "base/compiler_specific.h"
-#include "base/debug/debugger.h"
-#include "base/macros.h"
-#include "base/strings/string_piece_forward.h"
-#include "base/template_util.h"
-#include "build/build_config.h"
-
-//
-// Optional message capabilities
-// -----------------------------
-// Assertion failed messages and fatal errors are displayed in a dialog box
-// before the application exits. However, running this UI creates a message
-// loop, which causes application messages to be processed and potentially
-// dispatched to existing application windows. Since the application is in a
-// bad state when this assertion dialog is displayed, these messages may not
-// get processed and hang the dialog, or the application might go crazy.
-//
-// Therefore, it can be beneficial to display the error dialog in a separate
-// process from the main application. When the logging system needs to display
-// a fatal error dialog box, it will look for a program called
-// "DebugMessage.exe" in the same directory as the application executable. It
-// will run this application with the message as the command line, and will
-// not include the name of the application as is traditional for easier
-// parsing.
-//
-// The code for DebugMessage.exe is only one line. In WinMain, do:
-//   MessageBox(NULL, GetCommandLineW(), L"Fatal Error", 0);
-//
-// If DebugMessage.exe is not found, the logging code will use a normal
-// MessageBox, potentially causing the problems discussed above.
-
-
-// Instructions
-// ------------
-//
-// Make a bunch of macros for logging.  The way to log things is to stream
-// things to LOG(<a particular severity level>).  E.g.,
-//
-//   LOG(INFO) << "Found " << num_cookies << " cookies";
-//
-// You can also do conditional logging:
-//
-//   LOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
-//
-// The CHECK(condition) macro is active in both debug and release builds and
-// effectively performs a LOG(FATAL) which terminates the process and
-// generates a crashdump unless a debugger is attached.
-//
-// There are also "debug mode" logging macros like the ones above:
-//
-//   DLOG(INFO) << "Found cookies";
-//
-//   DLOG_IF(INFO, num_cookies > 10) << "Got lots of cookies";
-//
-// All "debug mode" logging is compiled away to nothing for non-debug mode
-// compiles.  LOG_IF and development flags also work well together
-// because the code can be compiled away sometimes.
-//
-// We also have
-//
-//   LOG_ASSERT(assertion);
-//   DLOG_ASSERT(assertion);
-//
-// which is syntactic sugar for {,D}LOG_IF(FATAL, assert fails) << assertion;
-//
-// There are "verbose level" logging macros.  They look like
-//
-//   VLOG(1) << "I'm printed when you run the program with --v=1 or more";
-//   VLOG(2) << "I'm printed when you run the program with --v=2 or more";
-//
-// These always log at the INFO log level (when they log at all).
-// The verbose logging can also be turned on module-by-module.  For instance,
-//    --vmodule=profile=2,icon_loader=1,browser_*=3,*/chromeos/*=4 --v=0
-// will cause:
-//   a. VLOG(2) and lower messages to be printed from profile.{h,cc}
-//   b. VLOG(1) and lower messages to be printed from icon_loader.{h,cc}
-//   c. VLOG(3) and lower messages to be printed from files prefixed with
-//      "browser"
-//   d. VLOG(4) and lower messages to be printed from files under a
-//     "chromeos" directory.
-//   e. VLOG(0) and lower messages to be printed from elsewhere
-//
-// The wildcarding functionality shown by (c) supports both '*' (match
-// 0 or more characters) and '?' (match any single character)
-// wildcards.  Any pattern containing a forward or backward slash will
-// be tested against the whole pathname and not just the module.
-// E.g., "*/foo/bar/*=2" would change the logging level for all code
-// in source files under a "foo/bar" directory.
-//
-// There's also VLOG_IS_ON(n) "verbose level" condition macro. To be used as
-//
-//   if (VLOG_IS_ON(2)) {
-//     // do some logging preparation and logging
-//     // that can't be accomplished with just VLOG(2) << ...;
-//   }
-//
-// There is also a VLOG_IF "verbose level" condition macro for sample
-// cases, when some extra computation and preparation for logs is not
-// needed.
-//
-//   VLOG_IF(1, (size > 1024))
-//      << "I'm printed when size is more than 1024 and when you run the "
-//         "program with --v=1 or more";
-//
-// We also override the standard 'assert' to use 'DLOG_ASSERT'.
-//
-// Lastly, there is:
-//
-//   PLOG(ERROR) << "Couldn't do foo";
-//   DPLOG(ERROR) << "Couldn't do foo";
-//   PLOG_IF(ERROR, cond) << "Couldn't do foo";
-//   DPLOG_IF(ERROR, cond) << "Couldn't do foo";
-//   PCHECK(condition) << "Couldn't do foo";
-//   DPCHECK(condition) << "Couldn't do foo";
-//
-// which append the last system error to the message in string form (taken from
-// GetLastError() on Windows and errno on POSIX).
-//
-// The supported severity levels for macros that allow you to specify one
-// are (in increasing order of severity) INFO, WARNING, ERROR, and FATAL.
-//
-// Very important: logging a message at the FATAL severity level causes
-// the program to terminate (after the message is logged).
-//
-// There is the special severity of DFATAL, which logs FATAL in debug mode,
-// ERROR in normal mode.
-
-namespace logging {
-
-// TODO(avi): do we want to do a unification of character types here?
-#if defined(OS_WIN)
-typedef wchar_t PathChar;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-typedef char PathChar;
-#endif
-
-// Where to record logging output? A flat file and/or system debug log
-// via OutputDebugString.
-enum LoggingDestination {
-  LOG_NONE                = 0,
-  LOG_TO_FILE             = 1 << 0,
-  LOG_TO_SYSTEM_DEBUG_LOG = 1 << 1,
-
-  LOG_TO_ALL = LOG_TO_FILE | LOG_TO_SYSTEM_DEBUG_LOG,
-
-  // On Windows, use a file next to the exe; on POSIX platforms, where
-  // it may not even be possible to locate the executable on disk, use
-  // stderr.
-#if defined(OS_WIN)
-  LOG_DEFAULT = LOG_TO_FILE,
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  LOG_DEFAULT = LOG_TO_SYSTEM_DEBUG_LOG,
-#endif
-};
-
-// Indicates that the log file should be locked when being written to.
-// Unless there is only one single-threaded process that is logging to
-// the log file, the file should be locked during writes to make each
-// log output atomic. Other writers will block.
-//
-// All processes writing to the log file must have their locking set for it to
-// work properly. Defaults to LOCK_LOG_FILE.
-enum LogLockingState { LOCK_LOG_FILE, DONT_LOCK_LOG_FILE };
-
-// On startup, should we delete or append to an existing log file (if any)?
-// Defaults to APPEND_TO_OLD_LOG_FILE.
-enum OldFileDeletionState { DELETE_OLD_LOG_FILE, APPEND_TO_OLD_LOG_FILE };
-
-struct BASE_EXPORT LoggingSettings {
-  // The defaults values are:
-  //
-  //  logging_dest: LOG_DEFAULT
-  //  log_file:     NULL
-  //  lock_log:     LOCK_LOG_FILE
-  //  delete_old:   APPEND_TO_OLD_LOG_FILE
-  LoggingSettings();
-
-  LoggingDestination logging_dest;
-
-  // The three settings below have an effect only when LOG_TO_FILE is
-  // set in |logging_dest|.
-  const PathChar* log_file;
-  LogLockingState lock_log;
-  OldFileDeletionState delete_old;
-};
-
-// Define different names for the BaseInitLoggingImpl() function depending on
-// whether NDEBUG is defined or not so that we'll fail to link if someone tries
-// to compile logging.cc with NDEBUG but includes logging.h without defining it,
-// or vice versa.
-#if defined(NDEBUG)
-#define BaseInitLoggingImpl BaseInitLoggingImpl_built_with_NDEBUG
-#else
-#define BaseInitLoggingImpl BaseInitLoggingImpl_built_without_NDEBUG
-#endif
-
-// Implementation of the InitLogging() method declared below.  We use a
-// more-specific name so we can #define it above without affecting other code
-// that has named stuff "InitLogging".
-BASE_EXPORT bool BaseInitLoggingImpl(const LoggingSettings& settings);
-
-// Sets the log file name and other global logging state. Calling this function
-// is recommended, and is normally done at the beginning of application init.
-// If you don't call it, all the flags will be initialized to their default
-// values, and there is a race condition that may leak a critical section
-// object if two threads try to do the first log at the same time.
-// See the definition of the enums above for descriptions and default values.
-//
-// The default log file is initialized to "debug.log" in the application
-// directory. You probably don't want this, especially since the program
-// directory may not be writable on an enduser's system.
-//
-// This function may be called a second time to re-direct logging (e.g after
-// loging in to a user partition), however it should never be called more than
-// twice.
-inline bool InitLogging(const LoggingSettings& settings) {
-  return BaseInitLoggingImpl(settings);
-}
-
-// Sets the log level. Anything at or above this level will be written to the
-// log file/displayed to the user (if applicable). Anything below this level
-// will be silently ignored. The log level defaults to 0 (everything is logged
-// up to level INFO) if this function is not called.
-// Note that log messages for VLOG(x) are logged at level -x, so setting
-// the min log level to negative values enables verbose logging.
-BASE_EXPORT void SetMinLogLevel(int level);
-
-// Gets the current log level.
-BASE_EXPORT int GetMinLogLevel();
-
-// Used by LOG_IS_ON to lazy-evaluate stream arguments.
-BASE_EXPORT bool ShouldCreateLogMessage(int severity);
-
-// Gets the VLOG default verbosity level.
-BASE_EXPORT int GetVlogVerbosity();
-
-// Note that |N| is the size *with* the null terminator.
-BASE_EXPORT int GetVlogLevelHelper(const char* file_start, size_t N);
-
-// Gets the current vlog level for the given file (usually taken from __FILE__).
-template <size_t N>
-int GetVlogLevel(const char (&file)[N]) {
-  return GetVlogLevelHelper(file, N);
-}
-
-// Sets the common items you want to be prepended to each log message.
-// process and thread IDs default to off, the timestamp defaults to on.
-// If this function is not called, logging defaults to writing the timestamp
-// only.
-BASE_EXPORT void SetLogItems(bool enable_process_id, bool enable_thread_id,
-                             bool enable_timestamp, bool enable_tickcount);
-
-// Sets whether or not you'd like to see fatal debug messages popped up in
-// a dialog box or not.
-// Dialogs are not shown by default.
-BASE_EXPORT void SetShowErrorDialogs(bool enable_dialogs);
-
-// Sets the Log Assert Handler that will be used to notify of check failures.
-// Resets Log Assert Handler on object destruction.
-// The default handler shows a dialog box and then terminate the process,
-// however clients can use this function to override with their own handling
-// (e.g. a silent one for Unit Tests)
-using LogAssertHandlerFunction =
-    base::Callback<void(const char* file,
-                        int line,
-                        const base::StringPiece message,
-                        const base::StringPiece stack_trace)>;
-
-class BASE_EXPORT ScopedLogAssertHandler {
- public:
-  explicit ScopedLogAssertHandler(LogAssertHandlerFunction handler);
-  ~ScopedLogAssertHandler();
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(ScopedLogAssertHandler);
-};
-
-// Sets the Log Message Handler that gets passed every log message before
-// it's sent to other log destinations (if any).
-// Returns true to signal that it handled the message and the message
-// should not be sent to other log destinations.
-typedef bool (*LogMessageHandlerFunction)(int severity,
-    const char* file, int line, size_t message_start, const std::string& str);
-BASE_EXPORT void SetLogMessageHandler(LogMessageHandlerFunction handler);
-BASE_EXPORT LogMessageHandlerFunction GetLogMessageHandler();
-
-// The ANALYZER_ASSUME_TRUE(bool arg) macro adds compiler-specific hints
-// to Clang which control what code paths are statically analyzed,
-// and is meant to be used in conjunction with assert & assert-like functions.
-// The expression is passed straight through if analysis isn't enabled.
-//
-// ANALYZER_SKIP_THIS_PATH() suppresses static analysis for the current
-// codepath and any other branching codepaths that might follow.
-#if defined(__clang_analyzer__)
-
-inline constexpr bool AnalyzerNoReturn() __attribute__((analyzer_noreturn)) {
-  return false;
-}
-
-inline constexpr bool AnalyzerAssumeTrue(bool arg) {
-  // AnalyzerNoReturn() is invoked and analysis is terminated if |arg| is
-  // false.
-  return arg || AnalyzerNoReturn();
-}
-
-#define ANALYZER_ASSUME_TRUE(arg) logging::AnalyzerAssumeTrue(!!(arg))
-#define ANALYZER_SKIP_THIS_PATH() \
-  static_cast<void>(::logging::AnalyzerNoReturn())
-#define ANALYZER_ALLOW_UNUSED(var) static_cast<void>(var);
-
-#else  // !defined(__clang_analyzer__)
-
-#define ANALYZER_ASSUME_TRUE(arg) (arg)
-#define ANALYZER_SKIP_THIS_PATH()
-#define ANALYZER_ALLOW_UNUSED(var) static_cast<void>(var);
-
-#endif  // defined(__clang_analyzer__)
-
-typedef int LogSeverity;
-const LogSeverity LOG_VERBOSE = -1;  // This is level 1 verbosity
-// Note: the log severities are used to index into the array of names,
-// see log_severity_names.
-const LogSeverity LOG_INFO = 0;
-const LogSeverity LOG_WARNING = 1;
-const LogSeverity LOG_ERROR = 2;
-const LogSeverity LOG_FATAL = 3;
-const LogSeverity LOG_NUM_SEVERITIES = 4;
-
-// LOG_DFATAL is LOG_FATAL in debug mode, ERROR in normal mode
-#if defined(NDEBUG)
-const LogSeverity LOG_DFATAL = LOG_ERROR;
-#else
-const LogSeverity LOG_DFATAL = LOG_FATAL;
-#endif
-
-// A few definitions of macros that don't generate much code. These are used
-// by LOG() and LOG_IF, etc. Since these are used all over our code, it's
-// better to have compact code for these operations.
-#define COMPACT_GOOGLE_LOG_EX_INFO(ClassName, ...) \
-  ::logging::ClassName(__FILE__, __LINE__, ::logging::LOG_INFO, ##__VA_ARGS__)
-#define COMPACT_GOOGLE_LOG_EX_WARNING(ClassName, ...)              \
-  ::logging::ClassName(__FILE__, __LINE__, ::logging::LOG_WARNING, \
-                       ##__VA_ARGS__)
-#define COMPACT_GOOGLE_LOG_EX_ERROR(ClassName, ...) \
-  ::logging::ClassName(__FILE__, __LINE__, ::logging::LOG_ERROR, ##__VA_ARGS__)
-#define COMPACT_GOOGLE_LOG_EX_FATAL(ClassName, ...) \
-  ::logging::ClassName(__FILE__, __LINE__, ::logging::LOG_FATAL, ##__VA_ARGS__)
-#define COMPACT_GOOGLE_LOG_EX_DFATAL(ClassName, ...) \
-  ::logging::ClassName(__FILE__, __LINE__, ::logging::LOG_DFATAL, ##__VA_ARGS__)
-#define COMPACT_GOOGLE_LOG_EX_DCHECK(ClassName, ...) \
-  ::logging::ClassName(__FILE__, __LINE__, ::logging::LOG_DCHECK, ##__VA_ARGS__)
-
-#define COMPACT_GOOGLE_LOG_INFO COMPACT_GOOGLE_LOG_EX_INFO(LogMessage)
-#define COMPACT_GOOGLE_LOG_WARNING COMPACT_GOOGLE_LOG_EX_WARNING(LogMessage)
-#define COMPACT_GOOGLE_LOG_ERROR COMPACT_GOOGLE_LOG_EX_ERROR(LogMessage)
-#define COMPACT_GOOGLE_LOG_FATAL COMPACT_GOOGLE_LOG_EX_FATAL(LogMessage)
-#define COMPACT_GOOGLE_LOG_DFATAL COMPACT_GOOGLE_LOG_EX_DFATAL(LogMessage)
-#define COMPACT_GOOGLE_LOG_DCHECK COMPACT_GOOGLE_LOG_EX_DCHECK(LogMessage)
-
-#if defined(OS_WIN)
-// wingdi.h defines ERROR to be 0. When we call LOG(ERROR), it gets
-// substituted with 0, and it expands to COMPACT_GOOGLE_LOG_0. To allow us
-// to keep using this syntax, we define this macro to do the same thing
-// as COMPACT_GOOGLE_LOG_ERROR, and also define ERROR the same way that
-// the Windows SDK does for consistency.
-#define ERROR 0
-#define COMPACT_GOOGLE_LOG_EX_0(ClassName, ...) \
-  COMPACT_GOOGLE_LOG_EX_ERROR(ClassName , ##__VA_ARGS__)
-#define COMPACT_GOOGLE_LOG_0 COMPACT_GOOGLE_LOG_ERROR
-// Needed for LOG_IS_ON(ERROR).
-const LogSeverity LOG_0 = LOG_ERROR;
-#endif
-
-// As special cases, we can assume that LOG_IS_ON(FATAL) always holds. Also,
-// LOG_IS_ON(DFATAL) always holds in debug mode. In particular, CHECK()s will
-// always fire if they fail.
-#define LOG_IS_ON(severity) \
-  (::logging::ShouldCreateLogMessage(::logging::LOG_##severity))
-
-// We can't do any caching tricks with VLOG_IS_ON() like the
-// google-glog version since it requires GCC extensions.  This means
-// that using the v-logging functions in conjunction with --vmodule
-// may be slow.
-#define VLOG_IS_ON(verboselevel) \
-  ((verboselevel) <= ::logging::GetVlogLevel(__FILE__))
-
-// Helper macro which avoids evaluating the arguments to a stream if
-// the condition doesn't hold. Condition is evaluated once and only once.
-#define LAZY_STREAM(stream, condition)                                  \
-  !(condition) ? (void) 0 : ::logging::LogMessageVoidify() & (stream)
-
-// We use the preprocessor's merging operator, "##", so that, e.g.,
-// LOG(INFO) becomes the token COMPACT_GOOGLE_LOG_INFO.  There's some funny
-// subtle difference between ostream member streaming functions (e.g.,
-// ostream::operator<<(int) and ostream non-member streaming functions
-// (e.g., ::operator<<(ostream&, string&): it turns out that it's
-// impossible to stream something like a string directly to an unnamed
-// ostream. We employ a neat hack by calling the stream() member
-// function of LogMessage which seems to avoid the problem.
-#define LOG_STREAM(severity) COMPACT_GOOGLE_LOG_ ## severity.stream()
-
-#define LOG(severity) LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity))
-#define LOG_IF(severity, condition) \
-  LAZY_STREAM(LOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
-
-// The VLOG macros log with negative verbosities.
-#define VLOG_STREAM(verbose_level) \
-  ::logging::LogMessage(__FILE__, __LINE__, -verbose_level).stream()
-
-#define VLOG(verbose_level) \
-  LAZY_STREAM(VLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))
-
-#define VLOG_IF(verbose_level, condition) \
-  LAZY_STREAM(VLOG_STREAM(verbose_level), \
-      VLOG_IS_ON(verbose_level) && (condition))
-
-#if defined (OS_WIN)
-#define VPLOG_STREAM(verbose_level) \
-  ::logging::Win32ErrorLogMessage(__FILE__, __LINE__, -verbose_level, \
-    ::logging::GetLastSystemErrorCode()).stream()
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#define VPLOG_STREAM(verbose_level) \
-  ::logging::ErrnoLogMessage(__FILE__, __LINE__, -verbose_level, \
-    ::logging::GetLastSystemErrorCode()).stream()
-#endif
-
-#define VPLOG(verbose_level) \
-  LAZY_STREAM(VPLOG_STREAM(verbose_level), VLOG_IS_ON(verbose_level))
-
-#define VPLOG_IF(verbose_level, condition) \
-  LAZY_STREAM(VPLOG_STREAM(verbose_level), \
-    VLOG_IS_ON(verbose_level) && (condition))
-
-// TODO(akalin): Add more VLOG variants, e.g. VPLOG.
-
-#define LOG_ASSERT(condition)                       \
-  LOG_IF(FATAL, !(ANALYZER_ASSUME_TRUE(condition))) \
-      << "Assert failed: " #condition ". "
-
-#if defined(OS_WIN)
-#define PLOG_STREAM(severity) \
-  COMPACT_GOOGLE_LOG_EX_ ## severity(Win32ErrorLogMessage, \
-      ::logging::GetLastSystemErrorCode()).stream()
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#define PLOG_STREAM(severity) \
-  COMPACT_GOOGLE_LOG_EX_ ## severity(ErrnoLogMessage, \
-      ::logging::GetLastSystemErrorCode()).stream()
-#endif
-
-#define PLOG(severity)                                          \
-  LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity))
-
-#define PLOG_IF(severity, condition) \
-  LAZY_STREAM(PLOG_STREAM(severity), LOG_IS_ON(severity) && (condition))
-
-BASE_EXPORT extern std::ostream* g_swallow_stream;
-
-// Note that g_swallow_stream is used instead of an arbitrary LOG() stream to
-// avoid the creation of an object with a non-trivial destructor (LogMessage).
-// On MSVC x86 (checked on 2015 Update 3), this causes a few additional
-// pointless instructions to be emitted even at full optimization level, even
-// though the : arm of the ternary operator is clearly never executed. Using a
-// simpler object to be &'d with Voidify() avoids these extra instructions.
-// Using a simpler POD object with a templated operator<< also works to avoid
-// these instructions. However, this causes warnings on statically defined
-// implementations of operator<<(std::ostream, ...) in some .cc files, because
-// they become defined-but-unreferenced functions. A reinterpret_cast of 0 to an
-// ostream* also is not suitable, because some compilers warn of undefined
-// behavior.
-#define EAT_STREAM_PARAMETERS \
-  true ? (void)0              \
-       : ::logging::LogMessageVoidify() & (*::logging::g_swallow_stream)
-
-// Captures the result of a CHECK_EQ (for example) and facilitates testing as a
-// boolean.
-class CheckOpResult {
- public:
-  // |message| must be non-null if and only if the check failed.
-  CheckOpResult(std::string* message) : message_(message) {}
-  // Returns true if the check succeeded.
-  operator bool() const { return !message_; }
-  // Returns the message.
-  std::string* message() { return message_; }
-
- private:
-  std::string* message_;
-};
-
-// Crashes in the fastest possible way with no attempt at logging.
-// There are different constraints to satisfy here, see http://crbug.com/664209
-// for more context:
-// - The trap instructions, and hence the PC value at crash time, have to be
-//   distinct and not get folded into the same opcode by the compiler.
-//   On Linux/Android this is tricky because GCC still folds identical
-//   asm volatile blocks. The workaround is generating distinct opcodes for
-//   each CHECK using the __COUNTER__ macro.
-// - The debug info for the trap instruction has to be attributed to the source
-//   line that has the CHECK(), to make crash reports actionable. This rules
-//   out the ability of using a inline function, at least as long as clang
-//   doesn't support attribute(artificial).
-// - Failed CHECKs should produce a signal that is distinguishable from an
-//   invalid memory access, to improve the actionability of crash reports.
-// - The compiler should treat the CHECK as no-return instructions, so that the
-//   trap code can be efficiently packed in the prologue of the function and
-//   doesn't interfere with the main execution flow.
-// - When debugging, developers shouldn't be able to accidentally step over a
-//   CHECK. This is achieved by putting opcodes that will cause a non
-//   continuable exception after the actual trap instruction.
-// - Don't cause too much binary bloat.
-#if defined(COMPILER_GCC)
-
-#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_NACL)
-// int 3 will generate a SIGTRAP.
-#define TRAP_SEQUENCE() \
-  asm volatile(         \
-      "int3; ud2; push %0;" ::"i"(static_cast<unsigned char>(__COUNTER__)))
-
-#elif defined(ARCH_CPU_ARMEL) && !defined(OS_NACL)
-// bkpt will generate a SIGBUS when running on armv7 and a SIGTRAP when running
-// as a 32 bit userspace app on arm64. There doesn't seem to be any way to
-// cause a SIGTRAP from userspace without using a syscall (which would be a
-// problem for sandboxing).
-#define TRAP_SEQUENCE() \
-  asm volatile("bkpt #0; udf %0;" ::"i"(__COUNTER__ % 256))
-
-#elif defined(ARCH_CPU_ARM64) && !defined(OS_NACL)
-// This will always generate a SIGTRAP on arm64.
-#define TRAP_SEQUENCE() \
-  asm volatile("brk #0; hlt %0;" ::"i"(__COUNTER__ % 65536))
-
-#else
-// Crash report accuracy will not be guaranteed on other architectures, but at
-// least this will crash as expected.
-#define TRAP_SEQUENCE() __builtin_trap()
-#endif  // ARCH_CPU_*
-
-// CHECK() and the trap sequence can be invoked from a constexpr function.
-// This could make compilation fail on GCC, as it forbids directly using inline
-// asm inside a constexpr function. However, it allows calling a lambda
-// expression including the same asm.
-// The side effect is that the top of the stacktrace will not point to the
-// calling function, but to this anonymous lambda. This is still useful as the
-// full name of the lambda will typically include the name of the function that
-// calls CHECK() and the debugger will still break at the right line of code.
-#if !defined(__clang__)
-#define WRAPPED_TRAP_SEQUENCE() \
-  do {                          \
-    [] { TRAP_SEQUENCE(); }();  \
-  } while (false)
-#else
-#define WRAPPED_TRAP_SEQUENCE() TRAP_SEQUENCE()
-#endif
-
-#define IMMEDIATE_CRASH()    \
-  ({                         \
-    WRAPPED_TRAP_SEQUENCE(); \
-    __builtin_unreachable(); \
-  })
-
-#elif defined(COMPILER_MSVC)
-
-// Clang is cleverer about coalescing int3s, so we need to add a unique-ish
-// instruction following the __debugbreak() to have it emit distinct locations
-// for CHECKs rather than collapsing them all together. It would be nice to use
-// a short intrinsic to do this (and perhaps have only one implementation for
-// both clang and MSVC), however clang-cl currently does not support intrinsics.
-// On the flip side, MSVC x64 doesn't support inline asm. So, we have to have
-// two implementations. Normally clang-cl's version will be 5 bytes (1 for
-// `int3`, 2 for `ud2`, 2 for `push byte imm`, however, TODO(scottmg):
-// https://crbug.com/694670 clang-cl doesn't currently support %'ing
-// __COUNTER__, so eventually it will emit the dword form of push.
-// TODO(scottmg): Reinvestigate a short sequence that will work on both
-// compilers once clang supports more intrinsics. See https://crbug.com/693713.
-#if defined(__clang__)
-#define IMMEDIATE_CRASH()                           \
-  ({                                                \
-    {__asm int 3 __asm ud2 __asm push __COUNTER__}; \
-    __builtin_unreachable();                        \
-  })
-#else
-#define IMMEDIATE_CRASH() __debugbreak()
-#endif  // __clang__
-
-#else
-#error Port
-#endif
-
-// CHECK dies with a fatal error if condition is not true.  It is *not*
-// controlled by NDEBUG, so the check will be executed regardless of
-// compilation mode.
-//
-// We make sure CHECK et al. always evaluates their arguments, as
-// doing CHECK(FunctionWithSideEffect()) is a common idiom.
-
-#if defined(OFFICIAL_BUILD) && defined(NDEBUG)
-
-// Make all CHECK functions discard their log strings to reduce code bloat, and
-// improve performance, for official release builds.
-//
-// This is not calling BreakDebugger since this is called frequently, and
-// calling an out-of-line function instead of a noreturn inline macro prevents
-// compiler optimizations.
-#define CHECK(condition) \
-  UNLIKELY(!(condition)) ? IMMEDIATE_CRASH() : EAT_STREAM_PARAMETERS
-
-// PCHECK includes the system error code, which is useful for determining
-// why the condition failed. In official builds, preserve only the error code
-// message so that it is available in crash reports. The stringified
-// condition and any additional stream parameters are dropped.
-#define PCHECK(condition)                                  \
-  LAZY_STREAM(PLOG_STREAM(FATAL), UNLIKELY(!(condition))); \
-  EAT_STREAM_PARAMETERS
-
-#define CHECK_OP(name, op, val1, val2) CHECK((val1) op (val2))
-
-#else  // !(OFFICIAL_BUILD && NDEBUG)
-
-#if defined(_PREFAST_) && defined(OS_WIN)
-// Use __analysis_assume to tell the VC++ static analysis engine that
-// assert conditions are true, to suppress warnings.  The LAZY_STREAM
-// parameter doesn't reference 'condition' in /analyze builds because
-// this evaluation confuses /analyze. The !! before condition is because
-// __analysis_assume gets confused on some conditions:
-// http://randomascii.wordpress.com/2011/09/13/analyze-for-visual-studio-the-ugly-part-5/
-
-#define CHECK(condition)                    \
-  __analysis_assume(!!(condition)),         \
-      LAZY_STREAM(LOG_STREAM(FATAL), false) \
-          << "Check failed: " #condition ". "
-
-#define PCHECK(condition)                    \
-  __analysis_assume(!!(condition)),          \
-      LAZY_STREAM(PLOG_STREAM(FATAL), false) \
-          << "Check failed: " #condition ". "
-
-#else  // _PREFAST_
-
-// Do as much work as possible out of line to reduce inline code size.
-#define CHECK(condition)                                                      \
-  LAZY_STREAM(::logging::LogMessage(__FILE__, __LINE__, #condition).stream(), \
-              !ANALYZER_ASSUME_TRUE(condition))
-
-#define PCHECK(condition)                                           \
-  LAZY_STREAM(PLOG_STREAM(FATAL), !ANALYZER_ASSUME_TRUE(condition)) \
-      << "Check failed: " #condition ". "
-
-#endif  // _PREFAST_
-
-// Helper macro for binary operators.
-// Don't use this macro directly in your code, use CHECK_EQ et al below.
-// The 'switch' is used to prevent the 'else' from being ambiguous when the
-// macro is used in an 'if' clause such as:
-// if (a == 1)
-//   CHECK_EQ(2, a);
-#define CHECK_OP(name, op, val1, val2)                                         \
-  switch (0) case 0: default:                                                  \
-  if (::logging::CheckOpResult true_if_passed =                                \
-      ::logging::Check##name##Impl((val1), (val2),                             \
-                                   #val1 " " #op " " #val2))                   \
-   ;                                                                           \
-  else                                                                         \
-    ::logging::LogMessage(__FILE__, __LINE__, true_if_passed.message()).stream()
-
-#endif  // !(OFFICIAL_BUILD && NDEBUG)
-
-// This formats a value for a failing CHECK_XX statement.  Ordinarily,
-// it uses the definition for operator<<, with a few special cases below.
-template <typename T>
-inline typename std::enable_if<
-    base::internal::SupportsOstreamOperator<const T&>::value &&
-        !std::is_function<typename std::remove_pointer<T>::type>::value,
-    void>::type
-MakeCheckOpValueString(std::ostream* os, const T& v) {
-  (*os) << v;
-}
-
-// Provide an overload for functions and function pointers. Function pointers
-// don't implicitly convert to void* but do implicitly convert to bool, so
-// without this function pointers are always printed as 1 or 0. (MSVC isn't
-// standards-conforming here and converts function pointers to regular
-// pointers, so this is a no-op for MSVC.)
-template <typename T>
-inline typename std::enable_if<
-    std::is_function<typename std::remove_pointer<T>::type>::value,
-    void>::type
-MakeCheckOpValueString(std::ostream* os, const T& v) {
-  (*os) << reinterpret_cast<const void*>(v);
-}
-
-// We need overloads for enums that don't support operator<<.
-// (i.e. scoped enums where no operator<< overload was declared).
-template <typename T>
-inline typename std::enable_if<
-    !base::internal::SupportsOstreamOperator<const T&>::value &&
-        std::is_enum<T>::value,
-    void>::type
-MakeCheckOpValueString(std::ostream* os, const T& v) {
-  (*os) << static_cast<typename std::underlying_type<T>::type>(v);
-}
-
-// We need an explicit overload for std::nullptr_t.
-BASE_EXPORT void MakeCheckOpValueString(std::ostream* os, std::nullptr_t p);
-
-// Build the error message string.  This is separate from the "Impl"
-// function template because it is not performance critical and so can
-// be out of line, while the "Impl" code should be inline.  Caller
-// takes ownership of the returned string.
-template<class t1, class t2>
-std::string* MakeCheckOpString(const t1& v1, const t2& v2, const char* names) {
-  std::ostringstream ss;
-  ss << names << " (";
-  MakeCheckOpValueString(&ss, v1);
-  ss << " vs. ";
-  MakeCheckOpValueString(&ss, v2);
-  ss << ")";
-  std::string* msg = new std::string(ss.str());
-  return msg;
-}
-
-// Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
-// in logging.cc.
-extern template BASE_EXPORT std::string* MakeCheckOpString<int, int>(
-    const int&, const int&, const char* names);
-extern template BASE_EXPORT
-std::string* MakeCheckOpString<unsigned long, unsigned long>(
-    const unsigned long&, const unsigned long&, const char* names);
-extern template BASE_EXPORT
-std::string* MakeCheckOpString<unsigned long, unsigned int>(
-    const unsigned long&, const unsigned int&, const char* names);
-extern template BASE_EXPORT
-std::string* MakeCheckOpString<unsigned int, unsigned long>(
-    const unsigned int&, const unsigned long&, const char* names);
-extern template BASE_EXPORT
-std::string* MakeCheckOpString<std::string, std::string>(
-    const std::string&, const std::string&, const char* name);
-
-// Helper functions for CHECK_OP macro.
-// The (int, int) specialization works around the issue that the compiler
-// will not instantiate the template version of the function on values of
-// unnamed enum type - see comment below.
-//
-// The checked condition is wrapped with ANALYZER_ASSUME_TRUE, which under
-// static analysis builds, blocks analysis of the current path if the
-// condition is false.
-#define DEFINE_CHECK_OP_IMPL(name, op)                                       \
-  template <class t1, class t2>                                              \
-  inline std::string* Check##name##Impl(const t1& v1, const t2& v2,          \
-                                        const char* names) {                 \
-    if (ANALYZER_ASSUME_TRUE(v1 op v2))                                      \
-      return NULL;                                                           \
-    else                                                                     \
-      return ::logging::MakeCheckOpString(v1, v2, names);                    \
-  }                                                                          \
-  inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
-    if (ANALYZER_ASSUME_TRUE(v1 op v2))                                      \
-      return NULL;                                                           \
-    else                                                                     \
-      return ::logging::MakeCheckOpString(v1, v2, names);                    \
-  }
-DEFINE_CHECK_OP_IMPL(EQ, ==)
-DEFINE_CHECK_OP_IMPL(NE, !=)
-DEFINE_CHECK_OP_IMPL(LE, <=)
-DEFINE_CHECK_OP_IMPL(LT, < )
-DEFINE_CHECK_OP_IMPL(GE, >=)
-DEFINE_CHECK_OP_IMPL(GT, > )
-#undef DEFINE_CHECK_OP_IMPL
-
-#define CHECK_EQ(val1, val2) CHECK_OP(EQ, ==, val1, val2)
-#define CHECK_NE(val1, val2) CHECK_OP(NE, !=, val1, val2)
-#define CHECK_LE(val1, val2) CHECK_OP(LE, <=, val1, val2)
-#define CHECK_LT(val1, val2) CHECK_OP(LT, < , val1, val2)
-#define CHECK_GE(val1, val2) CHECK_OP(GE, >=, val1, val2)
-#define CHECK_GT(val1, val2) CHECK_OP(GT, > , val1, val2)
-
-#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
-#define DCHECK_IS_ON() 0
-#else
-#define DCHECK_IS_ON() 1
-#endif
-
-// Definitions for DLOG et al.
-
-#if DCHECK_IS_ON()
-
-#define DLOG_IS_ON(severity) LOG_IS_ON(severity)
-#define DLOG_IF(severity, condition) LOG_IF(severity, condition)
-#define DLOG_ASSERT(condition) LOG_ASSERT(condition)
-#define DPLOG_IF(severity, condition) PLOG_IF(severity, condition)
-#define DVLOG_IF(verboselevel, condition) VLOG_IF(verboselevel, condition)
-#define DVPLOG_IF(verboselevel, condition) VPLOG_IF(verboselevel, condition)
-
-#else  // DCHECK_IS_ON()
-
-// If !DCHECK_IS_ON(), we want to avoid emitting any references to |condition|
-// (which may reference a variable defined only if DCHECK_IS_ON()).
-// Contrast this with DCHECK et al., which has different behavior.
-
-#define DLOG_IS_ON(severity) false
-#define DLOG_IF(severity, condition) EAT_STREAM_PARAMETERS
-#define DLOG_ASSERT(condition) EAT_STREAM_PARAMETERS
-#define DPLOG_IF(severity, condition) EAT_STREAM_PARAMETERS
-#define DVLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS
-#define DVPLOG_IF(verboselevel, condition) EAT_STREAM_PARAMETERS
-
-#endif  // DCHECK_IS_ON()
-
-#define DLOG(severity)                                          \
-  LAZY_STREAM(LOG_STREAM(severity), DLOG_IS_ON(severity))
-
-#define DPLOG(severity)                                         \
-  LAZY_STREAM(PLOG_STREAM(severity), DLOG_IS_ON(severity))
-
-#define DVLOG(verboselevel) DVLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
-
-#define DVPLOG(verboselevel) DVPLOG_IF(verboselevel, VLOG_IS_ON(verboselevel))
-
-// Definitions for DCHECK et al.
-
-#if DCHECK_IS_ON()
-
-#if DCHECK_IS_CONFIGURABLE
-BASE_EXPORT extern LogSeverity LOG_DCHECK;
-#else
-const LogSeverity LOG_DCHECK = LOG_FATAL;
-#endif
-
-#else  // DCHECK_IS_ON()
-
-// There may be users of LOG_DCHECK that are enabled independently
-// of DCHECK_IS_ON(), so default to FATAL logging for those.
-const LogSeverity LOG_DCHECK = LOG_FATAL;
-
-#endif  // DCHECK_IS_ON()
-
-// DCHECK et al. make sure to reference |condition| regardless of
-// whether DCHECKs are enabled; this is so that we don't get unused
-// variable warnings if the only use of a variable is in a DCHECK.
-// This behavior is different from DLOG_IF et al.
-//
-// Note that the definition of the DCHECK macros depends on whether or not
-// DCHECK_IS_ON() is true. When DCHECK_IS_ON() is false, the macros use
-// EAT_STREAM_PARAMETERS to avoid expressions that would create temporaries.
-
-#if defined(_PREFAST_) && defined(OS_WIN)
-// See comments on the previous use of __analysis_assume.
-
-#define DCHECK(condition)                    \
-  __analysis_assume(!!(condition)),          \
-      LAZY_STREAM(LOG_STREAM(DCHECK), false) \
-          << "Check failed: " #condition ". "
-
-#define DPCHECK(condition)                    \
-  __analysis_assume(!!(condition)),           \
-      LAZY_STREAM(PLOG_STREAM(DCHECK), false) \
-          << "Check failed: " #condition ". "
-
-#else  // !(defined(_PREFAST_) && defined(OS_WIN))
-
-#if DCHECK_IS_ON()
-
-#define DCHECK(condition)                                           \
-  LAZY_STREAM(LOG_STREAM(DCHECK), !ANALYZER_ASSUME_TRUE(condition)) \
-      << "Check failed: " #condition ". "
-#define DPCHECK(condition)                                           \
-  LAZY_STREAM(PLOG_STREAM(DCHECK), !ANALYZER_ASSUME_TRUE(condition)) \
-      << "Check failed: " #condition ". "
-
-#else  // DCHECK_IS_ON()
-
-#define DCHECK(condition) EAT_STREAM_PARAMETERS << !(condition)
-#define DPCHECK(condition) EAT_STREAM_PARAMETERS << !(condition)
-
-#endif  // DCHECK_IS_ON()
-
-#endif  // defined(_PREFAST_) && defined(OS_WIN)
-
-// Helper macro for binary operators.
-// Don't use this macro directly in your code, use DCHECK_EQ et al below.
-// The 'switch' is used to prevent the 'else' from being ambiguous when the
-// macro is used in an 'if' clause such as:
-// if (a == 1)
-//   DCHECK_EQ(2, a);
-#if DCHECK_IS_ON()
-
-#define DCHECK_OP(name, op, val1, val2)                                \
-  switch (0) case 0: default:                                          \
-  if (::logging::CheckOpResult true_if_passed =                        \
-      ::logging::Check##name##Impl((val1), (val2),                     \
-                                   #val1 " " #op " " #val2))           \
-   ;                                                                   \
-  else                                                                 \
-    ::logging::LogMessage(__FILE__, __LINE__, ::logging::LOG_DCHECK,   \
-                          true_if_passed.message()).stream()
-
-#else  // DCHECK_IS_ON()
-
-// When DCHECKs aren't enabled, DCHECK_OP still needs to reference operator<<
-// overloads for |val1| and |val2| to avoid potential compiler warnings about
-// unused functions. For the same reason, it also compares |val1| and |val2|
-// using |op|.
-//
-// Note that the contract of DCHECK_EQ, etc is that arguments are only evaluated
-// once. Even though |val1| and |val2| appear twice in this version of the macro
-// expansion, this is OK, since the expression is never actually evaluated.
-#define DCHECK_OP(name, op, val1, val2)                             \
-  EAT_STREAM_PARAMETERS << (::logging::MakeCheckOpValueString(      \
-                                ::logging::g_swallow_stream, val1), \
-                            ::logging::MakeCheckOpValueString(      \
-                                ::logging::g_swallow_stream, val2), \
-                            (val1)op(val2))
-
-#endif  // DCHECK_IS_ON()
-
-// Equality/Inequality checks - compare two values, and log a
-// LOG_DCHECK message including the two values when the result is not
-// as expected.  The values must have operator<<(ostream, ...)
-// defined.
-//
-// You may append to the error message like so:
-//   DCHECK_NE(1, 2) << "The world must be ending!";
-//
-// We are very careful to ensure that each argument is evaluated exactly
-// once, and that anything which is legal to pass as a function argument is
-// legal here.  In particular, the arguments may be temporary expressions
-// which will end up being destroyed at the end of the apparent statement,
-// for example:
-//   DCHECK_EQ(string("abc")[1], 'b');
-//
-// WARNING: These don't compile correctly if one of the arguments is a pointer
-// and the other is NULL.  In new code, prefer nullptr instead.  To
-// work around this for C++98, simply static_cast NULL to the type of the
-// desired pointer.
-
-#define DCHECK_EQ(val1, val2) DCHECK_OP(EQ, ==, val1, val2)
-#define DCHECK_NE(val1, val2) DCHECK_OP(NE, !=, val1, val2)
-#define DCHECK_LE(val1, val2) DCHECK_OP(LE, <=, val1, val2)
-#define DCHECK_LT(val1, val2) DCHECK_OP(LT, < , val1, val2)
-#define DCHECK_GE(val1, val2) DCHECK_OP(GE, >=, val1, val2)
-#define DCHECK_GT(val1, val2) DCHECK_OP(GT, > , val1, val2)
-
-#if !DCHECK_IS_ON() && defined(OS_CHROMEOS)
-// Implement logging of NOTREACHED() as a dedicated function to get function
-// call overhead down to a minimum.
-void LogErrorNotReached(const char* file, int line);
-#define NOTREACHED()                                       \
-  true ? ::logging::LogErrorNotReached(__FILE__, __LINE__) \
-       : EAT_STREAM_PARAMETERS
-#else
-#define NOTREACHED() DCHECK(false)
-#endif
-
-// Redefine the standard assert to use our nice log files
-#undef assert
-#define assert(x) DLOG_ASSERT(x)
-
-// This class more or less represents a particular log message.  You
-// create an instance of LogMessage and then stream stuff to it.
-// When you finish streaming to it, ~LogMessage is called and the
-// full message gets streamed to the appropriate destination.
-//
-// You shouldn't actually use LogMessage's constructor to log things,
-// though.  You should use the LOG() macro (and variants thereof)
-// above.
-class BASE_EXPORT LogMessage {
- public:
-  // Used for LOG(severity).
-  LogMessage(const char* file, int line, LogSeverity severity);
-
-  // Used for CHECK().  Implied severity = LOG_FATAL.
-  LogMessage(const char* file, int line, const char* condition);
-
-  // Used for CHECK_EQ(), etc. Takes ownership of the given string.
-  // Implied severity = LOG_FATAL.
-  LogMessage(const char* file, int line, std::string* result);
-
-  // Used for DCHECK_EQ(), etc. Takes ownership of the given string.
-  LogMessage(const char* file, int line, LogSeverity severity,
-             std::string* result);
-
-  ~LogMessage();
-
-  std::ostream& stream() { return stream_; }
-
-  LogSeverity severity() { return severity_; }
-  std::string str() { return stream_.str(); }
-
- private:
-  void Init(const char* file, int line);
-
-  LogSeverity severity_;
-  std::ostringstream stream_;
-  size_t message_start_;  // Offset of the start of the message (past prefix
-                          // info).
-  // The file and line information passed in to the constructor.
-  const char* file_;
-  const int line_;
-
-#if defined(OS_WIN)
-  // Stores the current value of GetLastError in the constructor and restores
-  // it in the destructor by calling SetLastError.
-  // This is useful since the LogMessage class uses a lot of Win32 calls
-  // that will lose the value of GLE and the code that called the log function
-  // will have lost the thread error value when the log call returns.
-  class SaveLastError {
-   public:
-    SaveLastError();
-    ~SaveLastError();
-
-    unsigned long get_error() const { return last_error_; }
-
-   protected:
-    unsigned long last_error_;
-  };
-
-  SaveLastError last_error_;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(LogMessage);
-};
-
-// This class is used to explicitly ignore values in the conditional
-// logging macros.  This avoids compiler warnings like "value computed
-// is not used" and "statement has no effect".
-class LogMessageVoidify {
- public:
-  LogMessageVoidify() = default;
-  // This has to be an operator with a precedence lower than << but
-  // higher than ?:
-  void operator&(std::ostream&) { }
-};
-
-#if defined(OS_WIN)
-typedef unsigned long SystemErrorCode;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-typedef int SystemErrorCode;
-#endif
-
-// Alias for ::GetLastError() on Windows and errno on POSIX. Avoids having to
-// pull in windows.h just for GetLastError() and DWORD.
-BASE_EXPORT SystemErrorCode GetLastSystemErrorCode();
-BASE_EXPORT std::string SystemErrorCodeToString(SystemErrorCode error_code);
-
-#if defined(OS_WIN)
-// Appends a formatted system message of the GetLastError() type.
-class BASE_EXPORT Win32ErrorLogMessage {
- public:
-  Win32ErrorLogMessage(const char* file,
-                       int line,
-                       LogSeverity severity,
-                       SystemErrorCode err);
-
-  // Appends the error message before destructing the encapsulated class.
-  ~Win32ErrorLogMessage();
-
-  std::ostream& stream() { return log_message_.stream(); }
-
- private:
-  SystemErrorCode err_;
-  LogMessage log_message_;
-
-  DISALLOW_COPY_AND_ASSIGN(Win32ErrorLogMessage);
-};
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-// Appends a formatted system message of the errno type
-class BASE_EXPORT ErrnoLogMessage {
- public:
-  ErrnoLogMessage(const char* file,
-                  int line,
-                  LogSeverity severity,
-                  SystemErrorCode err);
-
-  // Appends the error message before destructing the encapsulated class.
-  ~ErrnoLogMessage();
-
-  std::ostream& stream() { return log_message_.stream(); }
-
- private:
-  SystemErrorCode err_;
-  LogMessage log_message_;
-
-  DISALLOW_COPY_AND_ASSIGN(ErrnoLogMessage);
-};
-#endif  // OS_WIN
-
-// Closes the log file explicitly if open.
-// NOTE: Since the log file is opened as necessary by the action of logging
-//       statements, there's no guarantee that it will stay closed
-//       after this call.
-BASE_EXPORT void CloseLogFile();
-
-// Async signal safe logging mechanism.
-BASE_EXPORT void RawLog(int level, const char* message);
-
-#define RAW_LOG(level, message) \
-  ::logging::RawLog(::logging::LOG_##level, message)
-
-#define RAW_CHECK(condition)                               \
-  do {                                                     \
-    if (!(condition))                                      \
-      ::logging::RawLog(::logging::LOG_FATAL,              \
-                        "Check failed: " #condition "\n"); \
-  } while (0)
-
-#if defined(OS_WIN)
-// Returns true if logging to file is enabled.
-BASE_EXPORT bool IsLoggingToFileEnabled();
-
-// Returns the default log file path.
-BASE_EXPORT std::wstring GetLogFileFullPath();
-#endif
-
-}  // namespace logging
-
-// Note that "The behavior of a C++ program is undefined if it adds declarations
-// or definitions to namespace std or to a namespace within namespace std unless
-// otherwise specified." --C++11[namespace.std]
-//
-// We've checked that this particular definition has the intended behavior on
-// our implementations, but it's prone to breaking in the future, and please
-// don't imitate this in your own definitions without checking with some
-// standard library experts.
-namespace std {
-// These functions are provided as a convenience for logging, which is where we
-// use streams (it is against Google style to use streams in other places). It
-// is designed to allow you to emit non-ASCII Unicode strings to the log file,
-// which is normally ASCII. It is relatively slow, so try not to use it for
-// common cases. Non-ASCII characters will be converted to UTF-8 by these
-// operators.
-BASE_EXPORT std::ostream& operator<<(std::ostream& out, const wchar_t* wstr);
-inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) {
-  return out << wstr.c_str();
-}
-}  // namespace std
-
-// The NOTIMPLEMENTED() macro annotates codepaths which have not been
-// implemented yet. If output spam is a serious concern,
-// NOTIMPLEMENTED_LOG_ONCE can be used.
-
-#if defined(COMPILER_GCC)
-// On Linux, with GCC, we can use __PRETTY_FUNCTION__ to get the demangled name
-// of the current function in the NOTIMPLEMENTED message.
-#define NOTIMPLEMENTED_MSG "Not implemented reached in " << __PRETTY_FUNCTION__
-#else
-#define NOTIMPLEMENTED_MSG "NOT IMPLEMENTED"
-#endif
-
-#if defined(OS_ANDROID) && defined(OFFICIAL_BUILD)
-#define NOTIMPLEMENTED() EAT_STREAM_PARAMETERS
-#define NOTIMPLEMENTED_LOG_ONCE() EAT_STREAM_PARAMETERS
-#else
-#define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG
-#define NOTIMPLEMENTED_LOG_ONCE()                      \
-  do {                                                 \
-    static bool logged_once = false;                   \
-    LOG_IF(ERROR, !logged_once) << NOTIMPLEMENTED_MSG; \
-    logged_once = true;                                \
-  } while (0);                                         \
-  EAT_STREAM_PARAMETERS
-#endif
-
-#endif  // BASE_LOGGING_H_
diff --git a/native/zucchini/vendor/libchrome/base/macros.h b/native/zucchini/vendor/libchrome/base/macros.h
deleted file mode 100644
index 8685117..0000000
--- a/native/zucchini/vendor/libchrome/base/macros.h
+++ /dev/null
@@ -1,114 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This file contains macros and macro-like constructs (e.g., templates) that
-// are commonly used throughout Chromium source. (It may also contain things
-// that are closely related to things that are commonly used that belong in this
-// file.)
-
-#ifndef BASE_MACROS_H_
-#define BASE_MACROS_H_
-
-#include <stddef.h>  // For size_t.
-
-#if defined(ANDROID)
-// Prefer Android's libbase definitions to our own.
-#include <android-base/macros.h>
-#endif  // defined(ANDROID)
-
-// We define following macros conditionally as they may be defined by another libraries.
-
-// Distinguish mips32.
-#if defined(__mips__) && (_MIPS_SIM == _ABIO32) && !defined(__mips32__)
-#define __mips32__
-#endif
-
-// Distinguish mips64.
-#if defined(__mips__) && (_MIPS_SIM == _ABI64) && !defined(__mips64__)
-#define __mips64__
-#endif
-
-// Put this in the declarations for a class to be uncopyable.
-#if !defined(DISALLOW_COPY)
-#define DISALLOW_COPY(TypeName) \
-  TypeName(const TypeName&) = delete
-#endif
-
-// Put this in the declarations for a class to be unassignable.
-#if !defined(DISALLOW_ASSIGN)
-#define DISALLOW_ASSIGN(TypeName) TypeName& operator=(const TypeName&) = delete
-#endif
-
-// Put this in the declarations for a class to be uncopyable and unassignable.
-#if !defined(DISALLOW_COPY_AND_ASSIGN)
-#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
-  DISALLOW_COPY(TypeName);                 \
-  DISALLOW_ASSIGN(TypeName)
-#endif
-
-// A macro to disallow all the implicit constructors, namely the
-// default constructor, copy constructor and operator= functions.
-// This is especially useful for classes containing only static methods.
-#if !defined(DISALLOW_IMPLICIT_CONSTRUCTORS)
-#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
-  TypeName() = delete;                           \
-  DISALLOW_COPY_AND_ASSIGN(TypeName)
-#endif
-
-// The arraysize(arr) macro returns the # of elements in an array arr.  The
-// expression is a compile-time constant, and therefore can be used in defining
-// new arrays, for example.  If you use arraysize on a pointer by mistake, you
-// will get a compile-time error.  For the technical details, refer to
-// http://blogs.msdn.com/b/the1/archive/2004/05/07/128242.aspx.
-
-// This template function declaration is used in defining arraysize.
-// Note that the function doesn't need an implementation, as we only
-// use its type.
-//
-// DEPRECATED, please use base::size(array) instead.
-// TODO(https://crbug.com/837308): Replace existing arraysize usages.
-#if !defined(arraysize)
-template <typename T, size_t N> char (&ArraySizeHelper(T (&array)[N]))[N];
-#define arraysize(array) (sizeof(ArraySizeHelper(array)))
-#endif
-
-// Used to explicitly mark the return value of a function as unused. If you are
-// really sure you don't want to do anything with the return value of a function
-// that has been marked WARN_UNUSED_RESULT, wrap it with this. Example:
-//
-//   std::unique_ptr<MyType> my_var = ...;
-//   if (TakeOwnership(my_var.get()) == SUCCESS)
-//     ignore_result(my_var.release());
-//
-template<typename T>
-inline void ignore_result(const T&) {
-}
-
-namespace base {
-
-// Use these to declare and define a static local variable (static T;) so that
-// it is leaked so that its destructors are not called at exit.  This is
-// thread-safe.
-//
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DEPRECATED !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-// Please don't use this macro. Use a function-local static of type
-// base::NoDestructor<T> instead:
-//
-// Factory& Factory::GetInstance() {
-//   static base::NoDestructor<Factory> instance;
-//   return *instance;
-// }
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-#if !defined(CR_DEFINE_STATIC_LOCAL)
-#define CR_DEFINE_STATIC_LOCAL(type, name, arguments) \
-  static type& name = *new type arguments
-#endif
-
-// Workaround for MSVC, which expands __VA_ARGS__ as one macro argument. To
-// work around this bug, wrap the entire expression in this macro...
-#define CR_EXPAND_ARG(arg) arg
-
-}  // base
-
-#endif  // BASE_MACROS_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/free_deleter.h b/native/zucchini/vendor/libchrome/base/memory/free_deleter.h
deleted file mode 100644
index 5604118..0000000
--- a/native/zucchini/vendor/libchrome/base/memory/free_deleter.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MEMORY_FREE_DELETER_H_
-#define BASE_MEMORY_FREE_DELETER_H_
-
-#include <stdlib.h>
-
-namespace base {
-
-// Function object which invokes 'free' on its parameter, which must be
-// a pointer. Can be used to store malloc-allocated pointers in std::unique_ptr:
-//
-// std::unique_ptr<int, base::FreeDeleter> foo_ptr(
-//     static_cast<int*>(malloc(sizeof(int))));
-struct FreeDeleter {
-  inline void operator()(void* ptr) const {
-    free(ptr);
-  }
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_FREE_DELETER_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/ptr_util.h b/native/zucchini/vendor/libchrome/base/memory/ptr_util.h
deleted file mode 100644
index 42f4f49..0000000
--- a/native/zucchini/vendor/libchrome/base/memory/ptr_util.h
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MEMORY_PTR_UTIL_H_
-#define BASE_MEMORY_PTR_UTIL_H_
-
-#include <memory>
-#include <utility>
-
-namespace base {
-
-// Helper to transfer ownership of a raw pointer to a std::unique_ptr<T>.
-// Note that std::unique_ptr<T> has very different semantics from
-// std::unique_ptr<T[]>: do not use this helper for array allocations.
-template <typename T>
-std::unique_ptr<T> WrapUnique(T* ptr) {
-  return std::unique_ptr<T>(ptr);
-}
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_PTR_UTIL_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/raw_scoped_refptr_mismatch_checker.h b/native/zucchini/vendor/libchrome/base/memory/raw_scoped_refptr_mismatch_checker.h
deleted file mode 100644
index ab8b2ab..0000000
--- a/native/zucchini/vendor/libchrome/base/memory/raw_scoped_refptr_mismatch_checker.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MEMORY_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
-#define BASE_MEMORY_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
-
-#include <type_traits>
-
-#include "base/template_util.h"
-
-// It is dangerous to post a task with a T* argument where T is a subtype of
-// RefCounted(Base|ThreadSafeBase), since by the time the parameter is used, the
-// object may already have been deleted since it was not held with a
-// scoped_refptr. Example: http://crbug.com/27191
-// The following set of traits are designed to generate a compile error
-// whenever this antipattern is attempted.
-
-namespace base {
-
-// This is a base internal implementation file used by task.h and callback.h.
-// Not for public consumption, so we wrap it in namespace internal.
-namespace internal {
-
-template <typename T, typename = void>
-struct IsRefCountedType : std::false_type {};
-
-template <typename T>
-struct IsRefCountedType<T,
-                        void_t<decltype(std::declval<T*>()->AddRef()),
-                               decltype(std::declval<T*>()->Release())>>
-    : std::true_type {};
-
-template <typename T>
-struct NeedsScopedRefptrButGetsRawPtr {
-  static_assert(!std::is_reference<T>::value,
-                "NeedsScopedRefptrButGetsRawPtr requires non-reference type.");
-
-  enum {
-    // Human readable translation: you needed to be a scoped_refptr if you are a
-    // raw pointer type and are convertible to a RefCounted(Base|ThreadSafeBase)
-    // type.
-    value = std::is_pointer<T>::value &&
-            IsRefCountedType<std::remove_pointer_t<T>>::value
-  };
-};
-
-}  // namespace internal
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_RAW_SCOPED_REFPTR_MISMATCH_CHECKER_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/ref_counted.h b/native/zucchini/vendor/libchrome/base/memory/ref_counted.h
deleted file mode 100644
index 249f70e..0000000
--- a/native/zucchini/vendor/libchrome/base/memory/ref_counted.h
+++ /dev/null
@@ -1,425 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MEMORY_REF_COUNTED_H_
-#define BASE_MEMORY_REF_COUNTED_H_
-
-#include <stddef.h>
-
-#include <utility>
-
-#include "base/atomic_ref_count.h"
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/scoped_refptr.h"
-#include "base/sequence_checker.h"
-#include "base/threading/thread_collision_warner.h"
-#include "build/build_config.h"
-
-namespace base {
-namespace subtle {
-
-class BASE_EXPORT RefCountedBase {
- public:
-  bool HasOneRef() const { return ref_count_ == 1; }
-
- protected:
-  explicit RefCountedBase(StartRefCountFromZeroTag) {
-#if DCHECK_IS_ON()
-    sequence_checker_.DetachFromSequence();
-#endif
-  }
-
-  explicit RefCountedBase(StartRefCountFromOneTag) : ref_count_(1) {
-#if DCHECK_IS_ON()
-    needs_adopt_ref_ = true;
-    sequence_checker_.DetachFromSequence();
-#endif
-  }
-
-  ~RefCountedBase() {
-#if DCHECK_IS_ON()
-    DCHECK(in_dtor_) << "RefCounted object deleted without calling Release()";
-#endif
-  }
-
-  void AddRef() const {
-    // TODO(maruel): Add back once it doesn't assert 500 times/sec.
-    // Current thread books the critical section "AddRelease"
-    // without release it.
-    // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_);
-#if DCHECK_IS_ON()
-    DCHECK(!in_dtor_);
-    DCHECK(!needs_adopt_ref_)
-        << "This RefCounted object is created with non-zero reference count."
-        << " The first reference to such a object has to be made by AdoptRef or"
-        << " MakeRefCounted.";
-    if (ref_count_ >= 1) {
-      DCHECK(CalledOnValidSequence());
-    }
-#endif
-
-    AddRefImpl();
-  }
-
-  // Returns true if the object should self-delete.
-  bool Release() const {
-    --ref_count_;
-
-    // TODO(maruel): Add back once it doesn't assert 500 times/sec.
-    // Current thread books the critical section "AddRelease"
-    // without release it.
-    // DFAKE_SCOPED_LOCK_THREAD_LOCKED(add_release_);
-
-#if DCHECK_IS_ON()
-    DCHECK(!in_dtor_);
-    if (ref_count_ == 0)
-      in_dtor_ = true;
-
-    if (ref_count_ >= 1)
-      DCHECK(CalledOnValidSequence());
-    if (ref_count_ == 1)
-      sequence_checker_.DetachFromSequence();
-#endif
-
-    return ref_count_ == 0;
-  }
-
-  // Returns true if it is safe to read or write the object, from a thread
-  // safety standpoint. Should be DCHECK'd from the methods of RefCounted
-  // classes if there is a danger of objects being shared across threads.
-  //
-  // This produces fewer false positives than adding a separate SequenceChecker
-  // into the subclass, because it automatically detaches from the sequence when
-  // the reference count is 1 (and never fails if there is only one reference).
-  //
-  // This means unlike a separate SequenceChecker, it will permit a singly
-  // referenced object to be passed between threads (not holding a reference on
-  // the sending thread), but will trap if the sending thread holds onto a
-  // reference, or if the object is accessed from multiple threads
-  // simultaneously.
-  bool IsOnValidSequence() const {
-#if DCHECK_IS_ON()
-    return ref_count_ <= 1 || CalledOnValidSequence();
-#else
-    return true;
-#endif
-  }
-
- private:
-  template <typename U>
-  friend scoped_refptr<U> base::AdoptRef(U*);
-
-  void Adopted() const {
-#if DCHECK_IS_ON()
-    DCHECK(needs_adopt_ref_);
-    needs_adopt_ref_ = false;
-#endif
-  }
-
-#if defined(ARCH_CPU_64_BIT)
-  void AddRefImpl() const;
-#else
-  void AddRefImpl() const { ++ref_count_; }
-#endif
-
-#if DCHECK_IS_ON()
-  bool CalledOnValidSequence() const;
-#endif
-
-  mutable uint32_t ref_count_ = 0;
-
-#if DCHECK_IS_ON()
-  mutable bool needs_adopt_ref_ = false;
-  mutable bool in_dtor_ = false;
-  mutable SequenceChecker sequence_checker_;
-#endif
-
-  DFAKE_MUTEX(add_release_);
-
-  DISALLOW_COPY_AND_ASSIGN(RefCountedBase);
-};
-
-class BASE_EXPORT RefCountedThreadSafeBase {
- public:
-  bool HasOneRef() const;
-
- protected:
-  explicit constexpr RefCountedThreadSafeBase(StartRefCountFromZeroTag) {}
-  explicit constexpr RefCountedThreadSafeBase(StartRefCountFromOneTag)
-      : ref_count_(1) {
-#if DCHECK_IS_ON()
-    needs_adopt_ref_ = true;
-#endif
-  }
-
-#if DCHECK_IS_ON()
-  ~RefCountedThreadSafeBase();
-#else
-  ~RefCountedThreadSafeBase() = default;
-#endif
-
-// Release and AddRef are suitable for inlining on X86 because they generate
-// very small code sequences. On other platforms (ARM), it causes a size
-// regression and is probably not worth it.
-#if defined(ARCH_CPU_X86_FAMILY)
-  // Returns true if the object should self-delete.
-  bool Release() const { return ReleaseImpl(); }
-  void AddRef() const { AddRefImpl(); }
-#else
-  // Returns true if the object should self-delete.
-  bool Release() const;
-  void AddRef() const;
-#endif
-
- private:
-  template <typename U>
-  friend scoped_refptr<U> base::AdoptRef(U*);
-
-  void Adopted() const {
-#if DCHECK_IS_ON()
-    DCHECK(needs_adopt_ref_);
-    needs_adopt_ref_ = false;
-#endif
-  }
-
-  ALWAYS_INLINE void AddRefImpl() const {
-#if DCHECK_IS_ON()
-    DCHECK(!in_dtor_);
-    DCHECK(!needs_adopt_ref_)
-        << "This RefCounted object is created with non-zero reference count."
-        << " The first reference to such a object has to be made by AdoptRef or"
-        << " MakeRefCounted.";
-#endif
-    ref_count_.Increment();
-  }
-
-  ALWAYS_INLINE bool ReleaseImpl() const {
-#if DCHECK_IS_ON()
-    DCHECK(!in_dtor_);
-    DCHECK(!ref_count_.IsZero());
-#endif
-    if (!ref_count_.Decrement()) {
-#if DCHECK_IS_ON()
-      in_dtor_ = true;
-#endif
-      return true;
-    }
-    return false;
-  }
-
-  mutable AtomicRefCount ref_count_{0};
-#if DCHECK_IS_ON()
-  mutable bool needs_adopt_ref_ = false;
-  mutable bool in_dtor_ = false;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafeBase);
-};
-
-}  // namespace subtle
-
-// ScopedAllowCrossThreadRefCountAccess disables the check documented on
-// RefCounted below for rare pre-existing use cases where thread-safety was
-// guaranteed through other means (e.g. explicit sequencing of calls across
-// execution sequences when bouncing between threads in order). New callers
-// should refrain from using this (callsites handling thread-safety through
-// locks should use RefCountedThreadSafe per the overhead of its atomics being
-// negligible compared to locks anyways and callsites doing explicit sequencing
-// should properly std::move() the ref to avoid hitting this check).
-// TODO(tzik): Cleanup existing use cases and remove
-// ScopedAllowCrossThreadRefCountAccess.
-class BASE_EXPORT ScopedAllowCrossThreadRefCountAccess final {
- public:
-#if DCHECK_IS_ON()
-  ScopedAllowCrossThreadRefCountAccess();
-  ~ScopedAllowCrossThreadRefCountAccess();
-#else
-  ScopedAllowCrossThreadRefCountAccess() {}
-  ~ScopedAllowCrossThreadRefCountAccess() {}
-#endif
-};
-
-//
-// A base class for reference counted classes.  Otherwise, known as a cheap
-// knock-off of WebKit's RefCounted<T> class.  To use this, just extend your
-// class from it like so:
-//
-//   class MyFoo : public base::RefCounted<MyFoo> {
-//    ...
-//    private:
-//     friend class base::RefCounted<MyFoo>;
-//     ~MyFoo();
-//   };
-//
-// You should always make your destructor non-public, to avoid any code deleting
-// the object accidently while there are references to it.
-//
-//
-// The ref count manipulation to RefCounted is NOT thread safe and has DCHECKs
-// to trap unsafe cross thread usage. A subclass instance of RefCounted can be
-// passed to another execution sequence only when its ref count is 1. If the ref
-// count is more than 1, the RefCounted class verifies the ref updates are made
-// on the same execution sequence as the previous ones. The subclass can also
-// manually call IsOnValidSequence to trap other non-thread-safe accesses; see
-// the documentation for that method.
-//
-//
-// The reference count starts from zero by default, and we intended to migrate
-// to start-from-one ref count. Put REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE() to
-// the ref counted class to opt-in.
-//
-// If an object has start-from-one ref count, the first scoped_refptr need to be
-// created by base::AdoptRef() or base::MakeRefCounted(). We can use
-// base::MakeRefCounted() to create create both type of ref counted object.
-//
-// The motivations to use start-from-one ref count are:
-//  - Start-from-one ref count doesn't need the ref count increment for the
-//    first reference.
-//  - It can detect an invalid object acquisition for a being-deleted object
-//    that has zero ref count. That tends to happen on custom deleter that
-//    delays the deletion.
-//    TODO(tzik): Implement invalid acquisition detection.
-//  - Behavior parity to Blink's WTF::RefCounted, whose count starts from one.
-//    And start-from-one ref count is a step to merge WTF::RefCounted into
-//    base::RefCounted.
-//
-#define REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE()             \
-  static constexpr ::base::subtle::StartRefCountFromOneTag \
-      kRefCountPreference = ::base::subtle::kStartRefCountFromOneTag
-
-template <class T, typename Traits>
-class RefCounted;
-
-template <typename T>
-struct DefaultRefCountedTraits {
-  static void Destruct(const T* x) {
-    RefCounted<T, DefaultRefCountedTraits>::DeleteInternal(x);
-  }
-};
-
-template <class T, typename Traits = DefaultRefCountedTraits<T>>
-class RefCounted : public subtle::RefCountedBase {
- public:
-  static constexpr subtle::StartRefCountFromZeroTag kRefCountPreference =
-      subtle::kStartRefCountFromZeroTag;
-
-  RefCounted() : subtle::RefCountedBase(T::kRefCountPreference) {}
-
-  void AddRef() const {
-    subtle::RefCountedBase::AddRef();
-  }
-
-  void Release() const {
-    if (subtle::RefCountedBase::Release()) {
-      // Prune the code paths which the static analyzer may take to simulate
-      // object destruction. Use-after-free errors aren't possible given the
-      // lifetime guarantees of the refcounting system.
-      ANALYZER_SKIP_THIS_PATH();
-
-      Traits::Destruct(static_cast<const T*>(this));
-    }
-  }
-
- protected:
-  ~RefCounted() = default;
-
- private:
-  friend struct DefaultRefCountedTraits<T>;
-  template <typename U>
-  static void DeleteInternal(const U* x) {
-    delete x;
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(RefCounted);
-};
-
-// Forward declaration.
-template <class T, typename Traits> class RefCountedThreadSafe;
-
-// Default traits for RefCountedThreadSafe<T>.  Deletes the object when its ref
-// count reaches 0.  Overload to delete it on a different thread etc.
-template<typename T>
-struct DefaultRefCountedThreadSafeTraits {
-  static void Destruct(const T* x) {
-    // Delete through RefCountedThreadSafe to make child classes only need to be
-    // friend with RefCountedThreadSafe instead of this struct, which is an
-    // implementation detail.
-    RefCountedThreadSafe<T,
-                         DefaultRefCountedThreadSafeTraits>::DeleteInternal(x);
-  }
-};
-
-//
-// A thread-safe variant of RefCounted<T>
-//
-//   class MyFoo : public base::RefCountedThreadSafe<MyFoo> {
-//    ...
-//   };
-//
-// If you're using the default trait, then you should add compile time
-// asserts that no one else is deleting your object.  i.e.
-//    private:
-//     friend class base::RefCountedThreadSafe<MyFoo>;
-//     ~MyFoo();
-//
-// We can use REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE() with RefCountedThreadSafe
-// too. See the comment above the RefCounted definition for details.
-template <class T, typename Traits = DefaultRefCountedThreadSafeTraits<T> >
-class RefCountedThreadSafe : public subtle::RefCountedThreadSafeBase {
- public:
-  static constexpr subtle::StartRefCountFromZeroTag kRefCountPreference =
-      subtle::kStartRefCountFromZeroTag;
-
-  explicit RefCountedThreadSafe()
-      : subtle::RefCountedThreadSafeBase(T::kRefCountPreference) {}
-
-  void AddRef() const {
-    subtle::RefCountedThreadSafeBase::AddRef();
-  }
-
-  void Release() const {
-    if (subtle::RefCountedThreadSafeBase::Release()) {
-      ANALYZER_SKIP_THIS_PATH();
-      Traits::Destruct(static_cast<const T*>(this));
-    }
-  }
-
- protected:
-  ~RefCountedThreadSafe() = default;
-
- private:
-  friend struct DefaultRefCountedThreadSafeTraits<T>;
-  template <typename U>
-  static void DeleteInternal(const U* x) {
-    delete x;
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(RefCountedThreadSafe);
-};
-
-//
-// A thread-safe wrapper for some piece of data so we can place other
-// things in scoped_refptrs<>.
-//
-template<typename T>
-class RefCountedData
-    : public base::RefCountedThreadSafe< base::RefCountedData<T> > {
- public:
-  RefCountedData() : data() {}
-  RefCountedData(const T& in_value) : data(in_value) {}
-  RefCountedData(T&& in_value) : data(std::move(in_value)) {}
-
-  T data;
-
- private:
-  friend class base::RefCountedThreadSafe<base::RefCountedData<T> >;
-  ~RefCountedData() = default;
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_REF_COUNTED_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/scoped_refptr.h b/native/zucchini/vendor/libchrome/base/memory/scoped_refptr.h
deleted file mode 100644
index 389d0cb..0000000
--- a/native/zucchini/vendor/libchrome/base/memory/scoped_refptr.h
+++ /dev/null
@@ -1,337 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MEMORY_SCOPED_REFPTR_H_
-#define BASE_MEMORY_SCOPED_REFPTR_H_
-
-#include <stddef.h>
-
-#include <iosfwd>
-#include <type_traits>
-#include <utility>
-
-#include "base/compiler_specific.h"
-#include "base/logging.h"
-#include "base/macros.h"
-
-template <class T>
-class scoped_refptr;
-
-namespace base {
-
-template <class, typename>
-class RefCounted;
-template <class, typename>
-class RefCountedThreadSafe;
-
-template <typename T>
-scoped_refptr<T> AdoptRef(T* t);
-
-namespace subtle {
-
-enum AdoptRefTag { kAdoptRefTag };
-enum StartRefCountFromZeroTag { kStartRefCountFromZeroTag };
-enum StartRefCountFromOneTag { kStartRefCountFromOneTag };
-
-template <typename T, typename U, typename V>
-constexpr bool IsRefCountPreferenceOverridden(const T*,
-                                              const RefCounted<U, V>*) {
-  return !std::is_same<std::decay_t<decltype(T::kRefCountPreference)>,
-                       std::decay_t<decltype(U::kRefCountPreference)>>::value;
-}
-
-template <typename T, typename U, typename V>
-constexpr bool IsRefCountPreferenceOverridden(
-    const T*,
-    const RefCountedThreadSafe<U, V>*) {
-  return !std::is_same<std::decay_t<decltype(T::kRefCountPreference)>,
-                       std::decay_t<decltype(U::kRefCountPreference)>>::value;
-}
-
-constexpr bool IsRefCountPreferenceOverridden(...) {
-  return false;
-}
-
-}  // namespace subtle
-
-// Creates a scoped_refptr from a raw pointer without incrementing the reference
-// count. Use this only for a newly created object whose reference count starts
-// from 1 instead of 0.
-template <typename T>
-scoped_refptr<T> AdoptRef(T* obj) {
-  using Tag = std::decay_t<decltype(T::kRefCountPreference)>;
-  static_assert(std::is_same<subtle::StartRefCountFromOneTag, Tag>::value,
-                "Use AdoptRef only for the reference count starts from one.");
-
-  DCHECK(obj);
-  DCHECK(obj->HasOneRef());
-  obj->Adopted();
-  return scoped_refptr<T>(obj, subtle::kAdoptRefTag);
-}
-
-namespace subtle {
-
-template <typename T>
-scoped_refptr<T> AdoptRefIfNeeded(T* obj, StartRefCountFromZeroTag) {
-  return scoped_refptr<T>(obj);
-}
-
-template <typename T>
-scoped_refptr<T> AdoptRefIfNeeded(T* obj, StartRefCountFromOneTag) {
-  return AdoptRef(obj);
-}
-
-}  // namespace subtle
-
-// Constructs an instance of T, which is a ref counted type, and wraps the
-// object into a scoped_refptr<T>.
-template <typename T, typename... Args>
-scoped_refptr<T> MakeRefCounted(Args&&... args) {
-  T* obj = new T(std::forward<Args>(args)...);
-  return subtle::AdoptRefIfNeeded(obj, T::kRefCountPreference);
-}
-
-// Takes an instance of T, which is a ref counted type, and wraps the object
-// into a scoped_refptr<T>.
-template <typename T>
-scoped_refptr<T> WrapRefCounted(T* t) {
-  return scoped_refptr<T>(t);
-}
-
-}  // namespace base
-
-//
-// A smart pointer class for reference counted objects.  Use this class instead
-// of calling AddRef and Release manually on a reference counted object to
-// avoid common memory leaks caused by forgetting to Release an object
-// reference.  Sample usage:
-//
-//   class MyFoo : public RefCounted<MyFoo> {
-//    ...
-//    private:
-//     friend class RefCounted<MyFoo>;  // Allow destruction by RefCounted<>.
-//     ~MyFoo();                        // Destructor must be private/protected.
-//   };
-//
-//   void some_function() {
-//     scoped_refptr<MyFoo> foo = MakeRefCounted<MyFoo>();
-//     foo->Method(param);
-//     // |foo| is released when this function returns
-//   }
-//
-//   void some_other_function() {
-//     scoped_refptr<MyFoo> foo = MakeRefCounted<MyFoo>();
-//     ...
-//     foo.reset();  // explicitly releases |foo|
-//     ...
-//     if (foo)
-//       foo->Method(param);
-//   }
-//
-// The above examples show how scoped_refptr<T> acts like a pointer to T.
-// Given two scoped_refptr<T> classes, it is also possible to exchange
-// references between the two objects, like so:
-//
-//   {
-//     scoped_refptr<MyFoo> a = MakeRefCounted<MyFoo>();
-//     scoped_refptr<MyFoo> b;
-//
-//     b.swap(a);
-//     // now, |b| references the MyFoo object, and |a| references nullptr.
-//   }
-//
-// To make both |a| and |b| in the above example reference the same MyFoo
-// object, simply use the assignment operator:
-//
-//   {
-//     scoped_refptr<MyFoo> a = MakeRefCounted<MyFoo>();
-//     scoped_refptr<MyFoo> b;
-//
-//     b = a;
-//     // now, |a| and |b| each own a reference to the same MyFoo object.
-//   }
-//
-// Also see Chromium's ownership and calling conventions:
-// https://chromium.googlesource.com/chromium/src/+/lkgr/styleguide/c++/c++.md#object-ownership-and-calling-conventions
-// Specifically:
-//   If the function (at least sometimes) takes a ref on a refcounted object,
-//   declare the param as scoped_refptr<T>. The caller can decide whether it
-//   wishes to transfer ownership (by calling std::move(t) when passing t) or
-//   retain its ref (by simply passing t directly).
-//   In other words, use scoped_refptr like you would a std::unique_ptr except
-//   in the odd case where it's required to hold on to a ref while handing one
-//   to another component (if a component merely needs to use t on the stack
-//   without keeping a ref: pass t as a raw T*).
-template <class T>
-class scoped_refptr {
- public:
-  typedef T element_type;
-
-  constexpr scoped_refptr() = default;
-
-  // Constructs from raw pointer. constexpr if |p| is null.
-  constexpr scoped_refptr(T* p) : ptr_(p) {
-    if (ptr_)
-      AddRef(ptr_);
-  }
-
-  // Copy constructor. This is required in addition to the copy conversion
-  // constructor below.
-  scoped_refptr(const scoped_refptr& r) : scoped_refptr(r.ptr_) {}
-
-  // Copy conversion constructor.
-  template <typename U,
-            typename = typename std::enable_if<
-                std::is_convertible<U*, T*>::value>::type>
-  scoped_refptr(const scoped_refptr<U>& r) : scoped_refptr(r.ptr_) {}
-
-  // Move constructor. This is required in addition to the move conversion
-  // constructor below.
-  scoped_refptr(scoped_refptr&& r) noexcept : ptr_(r.ptr_) { r.ptr_ = nullptr; }
-
-  // Move conversion constructor.
-  template <typename U,
-            typename = typename std::enable_if<
-                std::is_convertible<U*, T*>::value>::type>
-  scoped_refptr(scoped_refptr<U>&& r) noexcept : ptr_(r.ptr_) {
-    r.ptr_ = nullptr;
-  }
-
-  ~scoped_refptr() {
-    static_assert(!base::subtle::IsRefCountPreferenceOverridden(
-                      static_cast<T*>(nullptr), static_cast<T*>(nullptr)),
-                  "It's unsafe to override the ref count preference."
-                  " Please remove REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE"
-                  " from subclasses.");
-    if (ptr_)
-      Release(ptr_);
-  }
-
-  T* get() const { return ptr_; }
-
-  T& operator*() const {
-    DCHECK(ptr_);
-    return *ptr_;
-  }
-
-  T* operator->() const {
-    DCHECK(ptr_);
-    return ptr_;
-  }
-
-  scoped_refptr& operator=(T* p) { return *this = scoped_refptr(p); }
-
-  // Unified assignment operator.
-  scoped_refptr& operator=(scoped_refptr r) noexcept {
-    swap(r);
-    return *this;
-  }
-
-  // Sets managed object to null and releases reference to the previous managed
-  // object, if it existed.
-  void reset() { scoped_refptr().swap(*this); }
-
-  void swap(scoped_refptr& r) noexcept { std::swap(ptr_, r.ptr_); }
-
-  explicit operator bool() const { return ptr_ != nullptr; }
-
-  template <typename U>
-  bool operator==(const scoped_refptr<U>& rhs) const {
-    return ptr_ == rhs.get();
-  }
-
-  template <typename U>
-  bool operator!=(const scoped_refptr<U>& rhs) const {
-    return !operator==(rhs);
-  }
-
-  template <typename U>
-  bool operator<(const scoped_refptr<U>& rhs) const {
-    return ptr_ < rhs.get();
-  }
-
- protected:
-  T* ptr_ = nullptr;
-
- private:
-  template <typename U>
-  friend scoped_refptr<U> base::AdoptRef(U*);
-
-  scoped_refptr(T* p, base::subtle::AdoptRefTag) : ptr_(p) {}
-
-  // Friend required for move constructors that set r.ptr_ to null.
-  template <typename U>
-  friend class scoped_refptr;
-
-  // Non-inline helpers to allow:
-  //     class Opaque;
-  //     extern template class scoped_refptr<Opaque>;
-  // Otherwise the compiler will complain that Opaque is an incomplete type.
-  static void AddRef(T* ptr);
-  static void Release(T* ptr);
-};
-
-// static
-template <typename T>
-void scoped_refptr<T>::AddRef(T* ptr) {
-  ptr->AddRef();
-}
-
-// static
-template <typename T>
-void scoped_refptr<T>::Release(T* ptr) {
-  ptr->Release();
-}
-
-template <typename T, typename U>
-bool operator==(const scoped_refptr<T>& lhs, const U* rhs) {
-  return lhs.get() == rhs;
-}
-
-template <typename T, typename U>
-bool operator==(const T* lhs, const scoped_refptr<U>& rhs) {
-  return lhs == rhs.get();
-}
-
-template <typename T>
-bool operator==(const scoped_refptr<T>& lhs, std::nullptr_t null) {
-  return !static_cast<bool>(lhs);
-}
-
-template <typename T>
-bool operator==(std::nullptr_t null, const scoped_refptr<T>& rhs) {
-  return !static_cast<bool>(rhs);
-}
-
-template <typename T, typename U>
-bool operator!=(const scoped_refptr<T>& lhs, const U* rhs) {
-  return !operator==(lhs, rhs);
-}
-
-template <typename T, typename U>
-bool operator!=(const T* lhs, const scoped_refptr<U>& rhs) {
-  return !operator==(lhs, rhs);
-}
-
-template <typename T>
-bool operator!=(const scoped_refptr<T>& lhs, std::nullptr_t null) {
-  return !operator==(lhs, null);
-}
-
-template <typename T>
-bool operator!=(std::nullptr_t null, const scoped_refptr<T>& rhs) {
-  return !operator==(null, rhs);
-}
-
-template <typename T>
-std::ostream& operator<<(std::ostream& out, const scoped_refptr<T>& p) {
-  return out << p.get();
-}
-
-template <typename T>
-void swap(scoped_refptr<T>& lhs, scoped_refptr<T>& rhs) noexcept {
-  lhs.swap(rhs);
-}
-
-#endif  // BASE_MEMORY_SCOPED_REFPTR_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/shared_memory.h b/native/zucchini/vendor/libchrome/base/memory/shared_memory.h
deleted file mode 100644
index c573ef7..0000000
--- a/native/zucchini/vendor/libchrome/base/memory/shared_memory.h
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MEMORY_SHARED_MEMORY_H_
-#define BASE_MEMORY_SHARED_MEMORY_H_
-
-#include <stddef.h>
-
-#include <string>
-
-#include "base/base_export.h"
-#include "base/hash.h"
-#include "base/macros.h"
-#include "base/memory/shared_memory_handle.h"
-#include "base/process/process_handle.h"
-#include "base/strings/string16.h"
-#include "build/build_config.h"
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <stdio.h>
-#include <sys/types.h>
-#include <semaphore.h>
-#include "base/file_descriptor_posix.h"
-#include "base/files/file_util.h"
-#include "base/files/scoped_file.h"
-#endif
-
-#if defined(OS_WIN)
-#include "base/win/scoped_handle.h"
-#endif
-
-namespace base {
-
-class FilePath;
-
-// Options for creating a shared memory object.
-struct BASE_EXPORT SharedMemoryCreateOptions {
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  // The type of OS primitive that should back the SharedMemory object.
-  SharedMemoryHandle::Type type = SharedMemoryHandle::MACH;
-#elif !defined(OS_FUCHSIA)
-  // DEPRECATED (crbug.com/345734):
-  // If NULL, the object is anonymous.  This pointer is owned by the caller
-  // and must live through the call to Create().
-  const std::string* name_deprecated = nullptr;
-
-  // DEPRECATED (crbug.com/345734):
-  // If true, and the shared memory already exists, Create() will open the
-  // existing shared memory and ignore the size parameter.  If false,
-  // shared memory must not exist.  This flag is meaningless unless
-  // name_deprecated is non-NULL.
-  bool open_existing_deprecated = false;
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
-
-  // Size of the shared memory object to be created.
-  // When opening an existing object, this has no effect.
-  size_t size = 0;
-
-  // If true, mappings might need to be made executable later.
-  bool executable = false;
-
-  // If true, the file can be shared read-only to a process.
-  bool share_read_only = false;
-};
-
-// Platform abstraction for shared memory.
-// SharedMemory consumes a SharedMemoryHandle [potentially one that it created]
-// to map a shared memory OS resource into the virtual address space of the
-// current process.
-class BASE_EXPORT SharedMemory {
- public:
-  SharedMemory();
-
-#if defined(OS_WIN)
-  // Similar to the default constructor, except that this allows for
-  // calling LockDeprecated() to acquire the named mutex before either Create or
-  // Open are called on Windows.
-  explicit SharedMemory(const string16& name);
-#endif
-
-  // Create a new SharedMemory object from an existing, open
-  // shared memory file.
-  //
-  // WARNING: This does not reduce the OS-level permissions on the handle; it
-  // only affects how the SharedMemory will be mmapped. Use
-  // GetReadOnlyHandle to drop permissions. TODO(jln,jyasskin): DCHECK
-  // that |read_only| matches the permissions of the handle.
-  SharedMemory(const SharedMemoryHandle& handle, bool read_only);
-
-  // Closes any open files.
-  ~SharedMemory();
-
-  // Return true iff the given handle is valid (i.e. not the distingished
-  // invalid value; NULL for a HANDLE and -1 for a file descriptor)
-  static bool IsHandleValid(const SharedMemoryHandle& handle);
-
-  // Closes a shared memory handle.
-  static void CloseHandle(const SharedMemoryHandle& handle);
-
-  // Returns the maximum number of handles that can be open at once per process.
-  static size_t GetHandleLimit();
-
-  // Duplicates The underlying OS primitive. Returns an invalid handle on
-  // failure. The caller is responsible for destroying the duplicated OS
-  // primitive.
-  static SharedMemoryHandle DuplicateHandle(const SharedMemoryHandle& handle);
-
-#if defined(OS_POSIX)
-  // This method requires that the SharedMemoryHandle is backed by a POSIX fd.
-  static int GetFdFromSharedMemoryHandle(const SharedMemoryHandle& handle);
-#endif
-
-  // Creates a shared memory object as described by the options struct.
-  // Returns true on success and false on failure.
-  bool Create(const SharedMemoryCreateOptions& options);
-
-  // Creates and maps an anonymous shared memory segment of size size.
-  // Returns true on success and false on failure.
-  bool CreateAndMapAnonymous(size_t size);
-
-  // Creates an anonymous shared memory segment of size size.
-  // Returns true on success and false on failure.
-  bool CreateAnonymous(size_t size) {
-    SharedMemoryCreateOptions options;
-    options.size = size;
-    return Create(options);
-  }
-
-#if (!defined(OS_MACOSX) || defined(OS_IOS)) && !defined(OS_FUCHSIA)
-  // DEPRECATED (crbug.com/345734):
-  // Creates or opens a shared memory segment based on a name.
-  // If open_existing is true, and the shared memory already exists,
-  // opens the existing shared memory and ignores the size parameter.
-  // If open_existing is false, shared memory must not exist.
-  // size is the size of the block to be created.
-  // Returns true on success, false on failure.
-  bool CreateNamedDeprecated(
-      const std::string& name, bool open_existing, size_t size) {
-    SharedMemoryCreateOptions options;
-    options.name_deprecated = &name;
-    options.open_existing_deprecated = open_existing;
-    options.size = size;
-    return Create(options);
-  }
-
-  // Deletes resources associated with a shared memory segment based on name.
-  // Not all platforms require this call.
-  bool Delete(const std::string& name);
-
-  // Opens a shared memory segment based on a name.
-  // If read_only is true, opens for read-only access.
-  // Returns true on success, false on failure.
-  bool Open(const std::string& name, bool read_only);
-#endif  // !defined(OS_MACOSX) || defined(OS_IOS)
-
-  // Maps the shared memory into the caller's address space.
-  // Returns true on success, false otherwise.  The memory address
-  // is accessed via the memory() accessor.  The mapped address is guaranteed to
-  // have an alignment of at least MAP_MINIMUM_ALIGNMENT. This method will fail
-  // if this object is currently mapped.
-  bool Map(size_t bytes) {
-    return MapAt(0, bytes);
-  }
-
-  // Same as above, but with |offset| to specify from begining of the shared
-  // memory block to map.
-  // |offset| must be alignent to value of |SysInfo::VMAllocationGranularity()|.
-  bool MapAt(off_t offset, size_t bytes);
-  enum { MAP_MINIMUM_ALIGNMENT = 32 };
-
-  // Unmaps the shared memory from the caller's address space.
-  // Returns true if successful; returns false on error or if the
-  // memory is not mapped.
-  bool Unmap();
-
-  // The size requested when the map is first created.
-  size_t requested_size() const { return requested_size_; }
-
-  // The actual size of the mapped memory (may be larger than requested).
-  size_t mapped_size() const { return mapped_size_; }
-
-  // Gets a pointer to the opened memory space if it has been
-  // Mapped via Map().  Returns NULL if it is not mapped.
-  void* memory() const { return memory_; }
-
-  // Returns the underlying OS handle for this segment.
-  // Use of this handle for anything other than an opaque
-  // identifier is not portable.
-  SharedMemoryHandle handle() const;
-
-  // Returns the underlying OS handle for this segment. The caller takes
-  // ownership of the handle and memory is unmapped. This is equivalent to
-  // duplicating the handle and then calling Unmap() and Close() on this object,
-  // without the overhead of duplicating the handle.
-  SharedMemoryHandle TakeHandle();
-
-  // Closes the open shared memory segment. The memory will remain mapped if
-  // it was previously mapped.
-  // It is safe to call Close repeatedly.
-  void Close();
-
-  // Returns a read-only handle to this shared memory region. The caller takes
-  // ownership of the handle. For POSIX handles, CHECK-fails if the region
-  // wasn't Created or Opened with share_read_only=true, which is required to
-  // make the handle read-only. When the handle is passed to the IPC subsystem,
-  // that takes ownership of the handle. As such, it's not valid to pass the
-  // sample handle to the IPC subsystem twice. Returns an invalid handle on
-  // failure.
-  SharedMemoryHandle GetReadOnlyHandle() const;
-
-  // Returns an ID for the mapped region. This is ID of the SharedMemoryHandle
-  // that was mapped. The ID is valid even after the SharedMemoryHandle is
-  // Closed, as long as the region is not unmapped.
-  const UnguessableToken& mapped_id() const { return mapped_id_; }
-
- private:
-#if defined(OS_POSIX) && !defined(OS_NACL) && !defined(OS_ANDROID) && \
-    (!defined(OS_MACOSX) || defined(OS_IOS))
-  bool FilePathForMemoryName(const std::string& mem_name, FilePath* path);
-#endif
-
-#if defined(OS_WIN)
-  // If true indicates this came from an external source so needs extra checks
-  // before being mapped.
-  bool external_section_ = false;
-  string16 name_;
-#elif !defined(OS_ANDROID) && !defined(OS_FUCHSIA)
-  // If valid, points to the same memory region as shm_, but with readonly
-  // permissions.
-  SharedMemoryHandle readonly_shm_;
-#endif
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  // The mechanism by which the memory is mapped. Only valid if |memory_| is not
-  // |nullptr|.
-  SharedMemoryHandle::Type mapped_memory_mechanism_ = SharedMemoryHandle::MACH;
-#endif
-
-  // The OS primitive that backs the shared memory region.
-  SharedMemoryHandle shm_;
-
-  size_t mapped_size_ = 0;
-  void* memory_ = nullptr;
-  bool read_only_ = false;
-  size_t requested_size_ = 0;
-  base::UnguessableToken mapped_id_;
-
-  DISALLOW_COPY_AND_ASSIGN(SharedMemory);
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_SHARED_MEMORY_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/shared_memory_handle.h b/native/zucchini/vendor/libchrome/base/memory/shared_memory_handle.h
deleted file mode 100644
index dd3d47a..0000000
--- a/native/zucchini/vendor/libchrome/base/memory/shared_memory_handle.h
+++ /dev/null
@@ -1,238 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_MEMORY_SHARED_MEMORY_HANDLE_H_
-#define BASE_MEMORY_SHARED_MEMORY_HANDLE_H_
-
-#include <stddef.h>
-
-#include "base/unguessable_token.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include "base/process/process_handle.h"
-#include "base/win/windows_types.h"
-#elif defined(OS_MACOSX) && !defined(OS_IOS)
-#include <mach/mach.h>
-#include "base/base_export.h"
-#include "base/file_descriptor_posix.h"
-#include "base/macros.h"
-#include "base/process/process_handle.h"
-#elif defined(OS_POSIX)
-#include <sys/types.h>
-#include "base/file_descriptor_posix.h"
-#elif defined(OS_FUCHSIA)
-#include <zircon/types.h>
-#endif
-
-namespace base {
-
-// SharedMemoryHandle is the smallest possible IPC-transportable "reference" to
-// a shared memory OS resource. A "reference" can be consumed exactly once [by
-// base::SharedMemory] to map the shared memory OS resource into the virtual
-// address space of the current process.
-// TODO(erikchen): This class should have strong ownership semantics to prevent
-// leaks of the underlying OS resource. https://crbug.com/640840.
-class BASE_EXPORT SharedMemoryHandle {
- public:
-  // The default constructor returns an invalid SharedMemoryHandle.
-  SharedMemoryHandle();
-
-  // Standard copy constructor. The new instance shares the underlying OS
-  // primitives.
-  SharedMemoryHandle(const SharedMemoryHandle& handle);
-
-  // Standard assignment operator. The updated instance shares the underlying
-  // OS primitives.
-  SharedMemoryHandle& operator=(const SharedMemoryHandle& handle);
-
-  // Closes the underlying OS resource.
-  // The fact that this method needs to be "const" is an artifact of the
-  // original interface for base::SharedMemory::CloseHandle.
-  // TODO(erikchen): This doesn't clear the underlying reference, which seems
-  // like a bug, but is how this class has always worked. Fix this:
-  // https://crbug.com/716072.
-  void Close() const;
-
-  // Whether ownership of the underlying OS resource is implicitly passed to
-  // the IPC subsystem during serialization.
-  void SetOwnershipPassesToIPC(bool ownership_passes);
-  bool OwnershipPassesToIPC() const;
-
-  // Whether the underlying OS resource is valid.
-  bool IsValid() const;
-
-  // Duplicates the underlying OS resource. Using the return value as a
-  // parameter to an IPC message will cause the IPC subsystem to consume the OS
-  // resource.
-  SharedMemoryHandle Duplicate() const;
-
-  // Uniques identifies the shared memory region that the underlying OS resource
-  // points to. Multiple SharedMemoryHandles that point to the same shared
-  // memory region will have the same GUID. Preserved across IPC.
-  base::UnguessableToken GetGUID() const;
-
-  // Returns the size of the memory region that SharedMemoryHandle points to.
-  size_t GetSize() const;
-
-#if defined(OS_WIN)
-  // Takes implicit ownership of |h|.
-  // |guid| uniquely identifies the shared memory region pointed to by the
-  // underlying OS resource. If the HANDLE is associated with another
-  // SharedMemoryHandle, the caller must pass the |guid| of that
-  // SharedMemoryHandle. Otherwise, the caller should generate a new
-  // UnguessableToken.
-  // Passing the wrong |size| has no immediate consequence, but may cause errors
-  // when trying to map the SharedMemoryHandle at a later point in time.
-  SharedMemoryHandle(HANDLE h, size_t size, const base::UnguessableToken& guid);
-  HANDLE GetHandle() const;
-#elif defined(OS_FUCHSIA)
-  // Takes implicit ownership of |h|.
-  // |guid| uniquely identifies the shared memory region pointed to by the
-  // underlying OS resource. If the zx_handle_t is associated with another
-  // SharedMemoryHandle, the caller must pass the |guid| of that
-  // SharedMemoryHandle. Otherwise, the caller should generate a new
-  // UnguessableToken.
-  // Passing the wrong |size| has no immediate consequence, but may cause errors
-  // when trying to map the SharedMemoryHandle at a later point in time.
-  SharedMemoryHandle(zx_handle_t h,
-                     size_t size,
-                     const base::UnguessableToken& guid);
-  zx_handle_t GetHandle() const;
-#elif defined(OS_MACOSX) && !defined(OS_IOS)
-  enum Type {
-    // The SharedMemoryHandle is backed by a POSIX fd.
-    POSIX,
-    // The SharedMemoryHandle is backed by the Mach primitive "memory object".
-    MACH,
-  };
-
-  // Makes a Mach-based SharedMemoryHandle of the given size. On error,
-  // subsequent calls to IsValid() return false.
-  // Passing the wrong |size| has no immediate consequence, but may cause errors
-  // when trying to map the SharedMemoryHandle at a later point in time.
-  SharedMemoryHandle(mach_vm_size_t size, const base::UnguessableToken& guid);
-
-  // Makes a Mach-based SharedMemoryHandle from |memory_object|, a named entry
-  // in the current task. The memory region has size |size|.
-  // Passing the wrong |size| has no immediate consequence, but may cause errors
-  // when trying to map the SharedMemoryHandle at a later point in time.
-  SharedMemoryHandle(mach_port_t memory_object,
-                     mach_vm_size_t size,
-                     const base::UnguessableToken& guid);
-
-  // Exposed so that the SharedMemoryHandle can be transported between
-  // processes.
-  mach_port_t GetMemoryObject() const;
-
-  // The SharedMemoryHandle must be valid.
-  // Returns whether the SharedMemoryHandle was successfully mapped into memory.
-  // On success, |memory| is an output variable that contains the start of the
-  // mapped memory.
-  bool MapAt(off_t offset, size_t bytes, void** memory, bool read_only);
-#elif defined(OS_POSIX)
-  // Creates a SharedMemoryHandle from an |fd| supplied from an external
-  // service.
-  // Passing the wrong |size| has no immediate consequence, but may cause errors
-  // when trying to map the SharedMemoryHandle at a later point in time.
-  static SharedMemoryHandle ImportHandle(int fd, size_t size);
-
-  // Returns the underlying OS resource.
-  int GetHandle() const;
-
-  // Invalidates [but doesn't close] the underlying OS resource. This will leak
-  // unless the caller is careful.
-  int Release();
-#endif
-
-#if defined(OS_ANDROID)
-  // Marks the current file descriptor as read-only, for the purpose of
-  // mapping. This is independent of the region's read-only status.
-  void SetReadOnly() { read_only_ = true; }
-
-  // Returns true iff the descriptor is to be used for read-only
-  // mappings.
-  bool IsReadOnly() const { return read_only_; }
-
-  // Returns true iff the corresponding region is read-only.
-  bool IsRegionReadOnly() const;
-
-  // Try to set the region read-only. This will fail any future attempt
-  // at read-write mapping.
-  bool SetRegionReadOnly() const;
-#endif
-
-#if defined(OS_POSIX)
-  // Constructs a SharedMemoryHandle backed by a FileDescriptor. The newly
-  // created instance has the same ownership semantics as base::FileDescriptor.
-  // This typically means that the SharedMemoryHandle takes ownership of the
-  // |fd| if |auto_close| is true. Unfortunately, it's common for existing code
-  // to make shallow copies of SharedMemoryHandle, and the one that is finally
-  // passed into a base::SharedMemory is the one that "consumes" the fd.
-  //
-  // |guid| uniquely identifies the shared memory region pointed to by the
-  // underlying OS resource. If |file_descriptor| is associated with another
-  // SharedMemoryHandle, the caller must pass the |guid| of that
-  // SharedMemoryHandle. Otherwise, the caller should generate a new
-  // UnguessableToken.
-  // Passing the wrong |size| has no immediate consequence, but may cause errors
-  // when trying to map the SharedMemoryHandle at a later point in time.
-  SharedMemoryHandle(const base::FileDescriptor& file_descriptor,
-                     size_t size,
-                     const base::UnguessableToken& guid);
-#endif
-
- private:
-#if defined(OS_WIN)
-  HANDLE handle_ = nullptr;
-
-  // Whether passing this object as a parameter to an IPC message passes
-  // ownership of |handle_| to the IPC stack. This is meant to mimic the
-  // behavior of the |auto_close| parameter of FileDescriptor. This member only
-  // affects attachment-brokered SharedMemoryHandles.
-  // Defaults to |false|.
-  bool ownership_passes_to_ipc_ = false;
-#elif defined(OS_FUCHSIA)
-  zx_handle_t handle_ = ZX_HANDLE_INVALID;
-  bool ownership_passes_to_ipc_ = false;
-#elif defined(OS_MACOSX) && !defined(OS_IOS)
-  friend class SharedMemory;
-  friend bool CheckReadOnlySharedMemoryHandleForTesting(
-      SharedMemoryHandle handle);
-
-  Type type_ = MACH;
-
-  // Each instance of a SharedMemoryHandle is backed either by a POSIX fd or a
-  // mach port. |type_| determines the backing member.
-  union {
-    FileDescriptor file_descriptor_;
-
-    struct {
-      mach_port_t memory_object_ = MACH_PORT_NULL;
-
-      // Whether passing this object as a parameter to an IPC message passes
-      // ownership of |memory_object_| to the IPC stack. This is meant to mimic
-      // the behavior of the |auto_close| parameter of FileDescriptor.
-      // Defaults to |false|.
-      bool ownership_passes_to_ipc_ = false;
-    };
-  };
-#elif defined(OS_ANDROID)
-  friend class SharedMemory;
-
-  FileDescriptor file_descriptor_;
-  bool read_only_ = false;
-#elif defined(OS_POSIX)
-  FileDescriptor file_descriptor_;
-#endif
-
-  base::UnguessableToken guid_;
-
-  // The size of the region referenced by the SharedMemoryHandle.
-  size_t size_ = 0;
-};
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_SHARED_MEMORY_HANDLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/singleton.h b/native/zucchini/vendor/libchrome/base/memory/singleton.h
deleted file mode 100644
index 880ef0a..0000000
--- a/native/zucchini/vendor/libchrome/base/memory/singleton.h
+++ /dev/null
@@ -1,262 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-// PLEASE READ: Do you really need a singleton? If possible, use a
-// function-local static of type base::NoDestructor<T> instead:
-//
-// Factory& Factory::GetInstance() {
-//   static base::NoDestructor<Factory> instance;
-//   return *instance;
-// }
-// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-//
-// Singletons make it hard to determine the lifetime of an object, which can
-// lead to buggy code and spurious crashes.
-//
-// Instead of adding another singleton into the mix, try to identify either:
-//   a) An existing singleton that can manage your object's lifetime
-//   b) Locations where you can deterministically create the object and pass
-//      into other objects
-//
-// If you absolutely need a singleton, please keep them as trivial as possible
-// and ideally a leaf dependency. Singletons get problematic when they attempt
-// to do too much in their destructor or have circular dependencies.
-
-#ifndef BASE_MEMORY_SINGLETON_H_
-#define BASE_MEMORY_SINGLETON_H_
-
-#include "base/at_exit.h"
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/lazy_instance_helpers.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/threading/thread_restrictions.h"
-
-namespace base {
-
-// Default traits for Singleton<Type>. Calls operator new and operator delete on
-// the object. Registers automatic deletion at process exit.
-// Overload if you need arguments or another memory allocation function.
-template<typename Type>
-struct DefaultSingletonTraits {
-  // Allocates the object.
-  static Type* New() {
-    // The parenthesis is very important here; it forces POD type
-    // initialization.
-    return new Type();
-  }
-
-  // Destroys the object.
-  static void Delete(Type* x) {
-    delete x;
-  }
-
-  // Set to true to automatically register deletion of the object on process
-  // exit. See below for the required call that makes this happen.
-  static const bool kRegisterAtExit = true;
-
-#if DCHECK_IS_ON()
-  // Set to false to disallow access on a non-joinable thread.  This is
-  // different from kRegisterAtExit because StaticMemorySingletonTraits allows
-  // access on non-joinable threads, and gracefully handles this.
-  static const bool kAllowedToAccessOnNonjoinableThread = false;
-#endif
-};
-
-
-// Alternate traits for use with the Singleton<Type>.  Identical to
-// DefaultSingletonTraits except that the Singleton will not be cleaned up
-// at exit.
-template<typename Type>
-struct LeakySingletonTraits : public DefaultSingletonTraits<Type> {
-  static const bool kRegisterAtExit = false;
-#if DCHECK_IS_ON()
-  static const bool kAllowedToAccessOnNonjoinableThread = true;
-#endif
-};
-
-// Alternate traits for use with the Singleton<Type>.  Allocates memory
-// for the singleton instance from a static buffer.  The singleton will
-// be cleaned up at exit, but can't be revived after destruction unless
-// the ResurrectForTesting() method is called.
-//
-// This is useful for a certain category of things, notably logging and
-// tracing, where the singleton instance is of a type carefully constructed to
-// be safe to access post-destruction.
-// In logging and tracing you'll typically get stray calls at odd times, like
-// during static destruction, thread teardown and the like, and there's a
-// termination race on the heap-based singleton - e.g. if one thread calls
-// get(), but then another thread initiates AtExit processing, the first thread
-// may call into an object residing in unallocated memory. If the instance is
-// allocated from the data segment, then this is survivable.
-//
-// The destructor is to deallocate system resources, in this case to unregister
-// a callback the system will invoke when logging levels change. Note that
-// this is also used in e.g. Chrome Frame, where you have to allow for the
-// possibility of loading briefly into someone else's process space, and
-// so leaking is not an option, as that would sabotage the state of your host
-// process once you've unloaded.
-template <typename Type>
-struct StaticMemorySingletonTraits {
-  // WARNING: User has to support a New() which returns null.
-  static Type* New() {
-    // Only constructs once and returns pointer; otherwise returns null.
-    if (subtle::NoBarrier_AtomicExchange(&dead_, 1))
-      return nullptr;
-
-    return new (buffer_) Type();
-  }
-
-  static void Delete(Type* p) {
-    if (p)
-      p->Type::~Type();
-  }
-
-  static const bool kRegisterAtExit = true;
-
-#if DCHECK_IS_ON()
-  static const bool kAllowedToAccessOnNonjoinableThread = true;
-#endif
-
-  static void ResurrectForTesting() { subtle::NoBarrier_Store(&dead_, 0); }
-
- private:
-  alignas(Type) static char buffer_[sizeof(Type)];
-  // Signal the object was already deleted, so it is not revived.
-  static subtle::Atomic32 dead_;
-};
-
-template <typename Type>
-alignas(Type) char StaticMemorySingletonTraits<Type>::buffer_[sizeof(Type)];
-template <typename Type>
-subtle::Atomic32 StaticMemorySingletonTraits<Type>::dead_ = 0;
-
-// The Singleton<Type, Traits, DifferentiatingType> class manages a single
-// instance of Type which will be created on first use and will be destroyed at
-// normal process exit). The Trait::Delete function will not be called on
-// abnormal process exit.
-//
-// DifferentiatingType is used as a key to differentiate two different
-// singletons having the same memory allocation functions but serving a
-// different purpose. This is mainly used for Locks serving different purposes.
-//
-// Example usage:
-//
-// In your header:
-//   namespace base {
-//   template <typename T>
-//   struct DefaultSingletonTraits;
-//   }
-//   class FooClass {
-//    public:
-//     static FooClass* GetInstance();  <-- See comment below on this.
-//     void Bar() { ... }
-//    private:
-//     FooClass() { ... }
-//     friend struct base::DefaultSingletonTraits<FooClass>;
-//
-//     DISALLOW_COPY_AND_ASSIGN(FooClass);
-//   };
-//
-// In your source file:
-//  #include "base/memory/singleton.h"
-//  FooClass* FooClass::GetInstance() {
-//    return base::Singleton<FooClass>::get();
-//  }
-//
-// Or for leaky singletons:
-//  #include "base/memory/singleton.h"
-//  FooClass* FooClass::GetInstance() {
-//    return base::Singleton<
-//        FooClass, base::LeakySingletonTraits<FooClass>>::get();
-//  }
-//
-// And to call methods on FooClass:
-//   FooClass::GetInstance()->Bar();
-//
-// NOTE: The method accessing Singleton<T>::get() has to be named as GetInstance
-// and it is important that FooClass::GetInstance() is not inlined in the
-// header. This makes sure that when source files from multiple targets include
-// this header they don't end up with different copies of the inlined code
-// creating multiple copies of the singleton.
-//
-// Singleton<> has no non-static members and doesn't need to actually be
-// instantiated.
-//
-// This class is itself thread-safe. The underlying Type must of course be
-// thread-safe if you want to use it concurrently. Two parameters may be tuned
-// depending on the user's requirements.
-//
-// Glossary:
-//   RAE = kRegisterAtExit
-//
-// On every platform, if Traits::RAE is true, the singleton will be destroyed at
-// process exit. More precisely it uses AtExitManager which requires an
-// object of this type to be instantiated. AtExitManager mimics the semantics
-// of atexit() such as LIFO order but under Windows is safer to call. For more
-// information see at_exit.h.
-//
-// If Traits::RAE is false, the singleton will not be freed at process exit,
-// thus the singleton will be leaked if it is ever accessed. Traits::RAE
-// shouldn't be false unless absolutely necessary. Remember that the heap where
-// the object is allocated may be destroyed by the CRT anyway.
-//
-// Caveats:
-// (a) Every call to get(), operator->() and operator*() incurs some overhead
-//     (16ns on my P4/2.8GHz) to check whether the object has already been
-//     initialized.  You may wish to cache the result of get(); it will not
-//     change.
-//
-// (b) Your factory function must never throw an exception. This class is not
-//     exception-safe.
-//
-
-template <typename Type,
-          typename Traits = DefaultSingletonTraits<Type>,
-          typename DifferentiatingType = Type>
-class Singleton {
- private:
-  // Classes using the Singleton<T> pattern should declare a GetInstance()
-  // method and call Singleton::get() from within that.
-  friend Type* Type::GetInstance();
-
-  // This class is safe to be constructed and copy-constructed since it has no
-  // member.
-
-  // Return a pointer to the one true instance of the class.
-  static Type* get() {
-#if DCHECK_IS_ON()
-    if (!Traits::kAllowedToAccessOnNonjoinableThread)
-      ThreadRestrictions::AssertSingletonAllowed();
-#endif
-
-    return subtle::GetOrCreateLazyPointer(
-        &instance_, &CreatorFunc, nullptr,
-        Traits::kRegisterAtExit ? OnExit : nullptr, nullptr);
-  }
-
-  // Internal method used as an adaptor for GetOrCreateLazyPointer(). Do not use
-  // outside of that use case.
-  static Type* CreatorFunc(void* /* creator_arg*/) { return Traits::New(); }
-
-  // Adapter function for use with AtExit().  This should be called single
-  // threaded, so don't use atomic operations.
-  // Calling OnExit while singleton is in use by other threads is a mistake.
-  static void OnExit(void* /*unused*/) {
-    // AtExit should only ever be register after the singleton instance was
-    // created.  We should only ever get here with a valid instance_ pointer.
-    Traits::Delete(reinterpret_cast<Type*>(subtle::NoBarrier_Load(&instance_)));
-    instance_ = 0;
-  }
-  static subtle::AtomicWord instance_;
-};
-
-template <typename Type, typename Traits, typename DifferentiatingType>
-subtle::AtomicWord Singleton<Type, Traits, DifferentiatingType>::instance_ = 0;
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_SINGLETON_H_
diff --git a/native/zucchini/vendor/libchrome/base/memory/weak_ptr.h b/native/zucchini/vendor/libchrome/base/memory/weak_ptr.h
deleted file mode 100644
index 34e7d2e..0000000
--- a/native/zucchini/vendor/libchrome/base/memory/weak_ptr.h
+++ /dev/null
@@ -1,377 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Weak pointers are pointers to an object that do not affect its lifetime,
-// and which may be invalidated (i.e. reset to nullptr) by the object, or its
-// owner, at any time, most commonly when the object is about to be deleted.
-
-// Weak pointers are useful when an object needs to be accessed safely by one
-// or more objects other than its owner, and those callers can cope with the
-// object vanishing and e.g. tasks posted to it being silently dropped.
-// Reference-counting such an object would complicate the ownership graph and
-// make it harder to reason about the object's lifetime.
-
-// EXAMPLE:
-//
-//  class Controller {
-//   public:
-//    Controller() : weak_factory_(this) {}
-//    void SpawnWorker() { Worker::StartNew(weak_factory_.GetWeakPtr()); }
-//    void WorkComplete(const Result& result) { ... }
-//   private:
-//    // Member variables should appear before the WeakPtrFactory, to ensure
-//    // that any WeakPtrs to Controller are invalidated before its members
-//    // variable's destructors are executed, rendering them invalid.
-//    WeakPtrFactory<Controller> weak_factory_;
-//  };
-//
-//  class Worker {
-//   public:
-//    static void StartNew(const WeakPtr<Controller>& controller) {
-//      Worker* worker = new Worker(controller);
-//      // Kick off asynchronous processing...
-//    }
-//   private:
-//    Worker(const WeakPtr<Controller>& controller)
-//        : controller_(controller) {}
-//    void DidCompleteAsynchronousProcessing(const Result& result) {
-//      if (controller_)
-//        controller_->WorkComplete(result);
-//    }
-//    WeakPtr<Controller> controller_;
-//  };
-//
-// With this implementation a caller may use SpawnWorker() to dispatch multiple
-// Workers and subsequently delete the Controller, without waiting for all
-// Workers to have completed.
-
-// ------------------------- IMPORTANT: Thread-safety -------------------------
-
-// Weak pointers may be passed safely between threads, but must always be
-// dereferenced and invalidated on the same SequencedTaskRunner otherwise
-// checking the pointer would be racey.
-//
-// To ensure correct use, the first time a WeakPtr issued by a WeakPtrFactory
-// is dereferenced, the factory and its WeakPtrs become bound to the calling
-// thread or current SequencedWorkerPool token, and cannot be dereferenced or
-// invalidated on any other task runner. Bound WeakPtrs can still be handed
-// off to other task runners, e.g. to use to post tasks back to object on the
-// bound sequence.
-//
-// If all WeakPtr objects are destroyed or invalidated then the factory is
-// unbound from the SequencedTaskRunner/Thread. The WeakPtrFactory may then be
-// destroyed, or new WeakPtr objects may be used, from a different sequence.
-//
-// Thus, at least one WeakPtr object must exist and have been dereferenced on
-// the correct thread to enforce that other WeakPtr objects will enforce they
-// are used on the desired thread.
-
-#ifndef BASE_MEMORY_WEAK_PTR_H_
-#define BASE_MEMORY_WEAK_PTR_H_
-
-#include <cstddef>
-#include <type_traits>
-
-#include "base/base_export.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/sequence_checker.h"
-
-namespace base {
-
-template <typename T> class SupportsWeakPtr;
-template <typename T> class WeakPtr;
-
-namespace internal {
-// These classes are part of the WeakPtr implementation.
-// DO NOT USE THESE CLASSES DIRECTLY YOURSELF.
-
-class BASE_EXPORT WeakReference {
- public:
-  // Although Flag is bound to a specific SequencedTaskRunner, it may be
-  // deleted from another via base::WeakPtr::~WeakPtr().
-  class BASE_EXPORT Flag : public RefCountedThreadSafe<Flag> {
-   public:
-    Flag();
-
-    void Invalidate();
-    bool IsValid() const;
-
-   private:
-    friend class base::RefCountedThreadSafe<Flag>;
-
-    ~Flag();
-
-    SequenceChecker sequence_checker_;
-    bool is_valid_;
-  };
-
-  WeakReference();
-  explicit WeakReference(const scoped_refptr<Flag>& flag);
-  ~WeakReference();
-
-  WeakReference(WeakReference&& other);
-  WeakReference(const WeakReference& other);
-  WeakReference& operator=(WeakReference&& other) = default;
-  WeakReference& operator=(const WeakReference& other) = default;
-
-  bool is_valid() const;
-
- private:
-  scoped_refptr<const Flag> flag_;
-};
-
-class BASE_EXPORT WeakReferenceOwner {
- public:
-  WeakReferenceOwner();
-  ~WeakReferenceOwner();
-
-  WeakReference GetRef() const;
-
-  bool HasRefs() const { return flag_ && !flag_->HasOneRef(); }
-
-  void Invalidate();
-
- private:
-  mutable scoped_refptr<WeakReference::Flag> flag_;
-};
-
-// This class simplifies the implementation of WeakPtr's type conversion
-// constructor by avoiding the need for a public accessor for ref_.  A
-// WeakPtr<T> cannot access the private members of WeakPtr<U>, so this
-// base class gives us a way to access ref_ in a protected fashion.
-class BASE_EXPORT WeakPtrBase {
- public:
-  WeakPtrBase();
-  ~WeakPtrBase();
-
-  WeakPtrBase(const WeakPtrBase& other) = default;
-  WeakPtrBase(WeakPtrBase&& other) = default;
-  WeakPtrBase& operator=(const WeakPtrBase& other) = default;
-  WeakPtrBase& operator=(WeakPtrBase&& other) = default;
-
-  void reset() {
-    ref_ = internal::WeakReference();
-    ptr_ = 0;
-  }
-
- protected:
-  WeakPtrBase(const WeakReference& ref, uintptr_t ptr);
-
-  WeakReference ref_;
-
-  // This pointer is only valid when ref_.is_valid() is true.  Otherwise, its
-  // value is undefined (as opposed to nullptr).
-  uintptr_t ptr_;
-};
-
-// This class provides a common implementation of common functions that would
-// otherwise get instantiated separately for each distinct instantiation of
-// SupportsWeakPtr<>.
-class SupportsWeakPtrBase {
- public:
-  // A safe static downcast of a WeakPtr<Base> to WeakPtr<Derived>. This
-  // conversion will only compile if there is exists a Base which inherits
-  // from SupportsWeakPtr<Base>. See base::AsWeakPtr() below for a helper
-  // function that makes calling this easier.
-  //
-  // Precondition: t != nullptr
-  template<typename Derived>
-  static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {
-    static_assert(
-        std::is_base_of<internal::SupportsWeakPtrBase, Derived>::value,
-        "AsWeakPtr argument must inherit from SupportsWeakPtr");
-    return AsWeakPtrImpl<Derived>(t);
-  }
-
- private:
-  // This template function uses type inference to find a Base of Derived
-  // which is an instance of SupportsWeakPtr<Base>. We can then safely
-  // static_cast the Base* to a Derived*.
-  template <typename Derived, typename Base>
-  static WeakPtr<Derived> AsWeakPtrImpl(SupportsWeakPtr<Base>* t) {
-    WeakPtr<Base> ptr = t->AsWeakPtr();
-    return WeakPtr<Derived>(
-        ptr.ref_, static_cast<Derived*>(reinterpret_cast<Base*>(ptr.ptr_)));
-  }
-};
-
-}  // namespace internal
-
-template <typename T> class WeakPtrFactory;
-
-// The WeakPtr class holds a weak reference to |T*|.
-//
-// This class is designed to be used like a normal pointer.  You should always
-// null-test an object of this class before using it or invoking a method that
-// may result in the underlying object being destroyed.
-//
-// EXAMPLE:
-//
-//   class Foo { ... };
-//   WeakPtr<Foo> foo;
-//   if (foo)
-//     foo->method();
-//
-template <typename T>
-class WeakPtr : public internal::WeakPtrBase {
- public:
-  WeakPtr() = default;
-
-  WeakPtr(std::nullptr_t) {}
-
-  // Allow conversion from U to T provided U "is a" T. Note that this
-  // is separate from the (implicit) copy and move constructors.
-  template <typename U>
-  WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other) {
-    // Need to cast from U* to T* to do pointer adjustment in case of multiple
-    // inheritance. This also enforces the "U is a T" rule.
-    T* t = reinterpret_cast<U*>(other.ptr_);
-    ptr_ = reinterpret_cast<uintptr_t>(t);
-  }
-  template <typename U>
-  WeakPtr(WeakPtr<U>&& other) : WeakPtrBase(std::move(other)) {
-    // Need to cast from U* to T* to do pointer adjustment in case of multiple
-    // inheritance. This also enforces the "U is a T" rule.
-    T* t = reinterpret_cast<U*>(other.ptr_);
-    ptr_ = reinterpret_cast<uintptr_t>(t);
-  }
-
-  T* get() const {
-    return ref_.is_valid() ? reinterpret_cast<T*>(ptr_) : nullptr;
-  }
-
-  T& operator*() const {
-    DCHECK(get() != nullptr);
-    return *get();
-  }
-  T* operator->() const {
-    DCHECK(get() != nullptr);
-    return get();
-  }
-
-  // Allow conditionals to test validity, e.g. if (weak_ptr) {...};
-  explicit operator bool() const { return get() != nullptr; }
-
- private:
-  friend class internal::SupportsWeakPtrBase;
-  template <typename U> friend class WeakPtr;
-  friend class SupportsWeakPtr<T>;
-  friend class WeakPtrFactory<T>;
-
-  WeakPtr(const internal::WeakReference& ref, T* ptr)
-      : WeakPtrBase(ref, reinterpret_cast<uintptr_t>(ptr)) {}
-};
-
-// Allow callers to compare WeakPtrs against nullptr to test validity.
-template <class T>
-bool operator!=(const WeakPtr<T>& weak_ptr, std::nullptr_t) {
-  return !(weak_ptr == nullptr);
-}
-template <class T>
-bool operator!=(std::nullptr_t, const WeakPtr<T>& weak_ptr) {
-  return weak_ptr != nullptr;
-}
-template <class T>
-bool operator==(const WeakPtr<T>& weak_ptr, std::nullptr_t) {
-  return weak_ptr.get() == nullptr;
-}
-template <class T>
-bool operator==(std::nullptr_t, const WeakPtr<T>& weak_ptr) {
-  return weak_ptr == nullptr;
-}
-
-namespace internal {
-class BASE_EXPORT WeakPtrFactoryBase {
- protected:
-  WeakPtrFactoryBase(uintptr_t ptr);
-  ~WeakPtrFactoryBase();
-  internal::WeakReferenceOwner weak_reference_owner_;
-  uintptr_t ptr_;
-};
-}  // namespace internal
-
-// A class may be composed of a WeakPtrFactory and thereby
-// control how it exposes weak pointers to itself.  This is helpful if you only
-// need weak pointers within the implementation of a class.  This class is also
-// useful when working with primitive types.  For example, you could have a
-// WeakPtrFactory<bool> that is used to pass around a weak reference to a bool.
-template <class T>
-class WeakPtrFactory : public internal::WeakPtrFactoryBase {
- public:
-  explicit WeakPtrFactory(T* ptr)
-      : WeakPtrFactoryBase(reinterpret_cast<uintptr_t>(ptr)) {}
-
-  ~WeakPtrFactory() = default;
-
-  WeakPtr<T> GetWeakPtr() {
-    return WeakPtr<T>(weak_reference_owner_.GetRef(),
-                      reinterpret_cast<T*>(ptr_));
-  }
-
-  // Call this method to invalidate all existing weak pointers.
-  void InvalidateWeakPtrs() {
-    DCHECK(ptr_);
-    weak_reference_owner_.Invalidate();
-  }
-
-  // Call this method to determine if any weak pointers exist.
-  bool HasWeakPtrs() const {
-    DCHECK(ptr_);
-    return weak_reference_owner_.HasRefs();
-  }
-
- private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory);
-};
-
-// A class may extend from SupportsWeakPtr to let others take weak pointers to
-// it. This avoids the class itself implementing boilerplate to dispense weak
-// pointers.  However, since SupportsWeakPtr's destructor won't invalidate
-// weak pointers to the class until after the derived class' members have been
-// destroyed, its use can lead to subtle use-after-destroy issues.
-template <class T>
-class SupportsWeakPtr : public internal::SupportsWeakPtrBase {
- public:
-  SupportsWeakPtr() = default;
-
-  WeakPtr<T> AsWeakPtr() {
-    return WeakPtr<T>(weak_reference_owner_.GetRef(), static_cast<T*>(this));
-  }
-
- protected:
-  ~SupportsWeakPtr() = default;
-
- private:
-  internal::WeakReferenceOwner weak_reference_owner_;
-  DISALLOW_COPY_AND_ASSIGN(SupportsWeakPtr);
-};
-
-// Helper function that uses type deduction to safely return a WeakPtr<Derived>
-// when Derived doesn't directly extend SupportsWeakPtr<Derived>, instead it
-// extends a Base that extends SupportsWeakPtr<Base>.
-//
-// EXAMPLE:
-//   class Base : public base::SupportsWeakPtr<Producer> {};
-//   class Derived : public Base {};
-//
-//   Derived derived;
-//   base::WeakPtr<Derived> ptr = base::AsWeakPtr(&derived);
-//
-// Note that the following doesn't work (invalid type conversion) since
-// Derived::AsWeakPtr() is WeakPtr<Base> SupportsWeakPtr<Base>::AsWeakPtr(),
-// and there's no way to safely cast WeakPtr<Base> to WeakPtr<Derived> at
-// the caller.
-//
-//   base::WeakPtr<Derived> ptr = derived.AsWeakPtr();  // Fails.
-
-template <typename Derived>
-WeakPtr<Derived> AsWeakPtr(Derived* t) {
-  return internal::SupportsWeakPtrBase::StaticAsWeakPtr<Derived>(t);
-}
-
-}  // namespace base
-
-#endif  // BASE_MEMORY_WEAK_PTR_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/bucket_ranges.h b/native/zucchini/vendor/libchrome/base/metrics/bucket_ranges.h
deleted file mode 100644
index 1b6d069..0000000
--- a/native/zucchini/vendor/libchrome/base/metrics/bucket_ranges.h
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-// BucketRanges stores the vector of ranges that delimit what samples are
-// tallied in the corresponding buckets of a histogram. Histograms that have
-// same ranges for all their corresponding buckets should share the same
-// BucketRanges object.
-//
-// E.g. A 5 buckets LinearHistogram with 1 as minimal value and 4 as maximal
-// value will need a BucketRanges with 6 ranges:
-// 0, 1, 2, 3, 4, INT_MAX
-//
-// TODO(kaiwang): Currently we keep all negative values in 0~1 bucket. Consider
-// changing 0 to INT_MIN.
-
-#ifndef BASE_METRICS_BUCKET_RANGES_H_
-#define BASE_METRICS_BUCKET_RANGES_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <vector>
-
-#include <limits.h>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/metrics/histogram_base.h"
-
-namespace base {
-
-class BASE_EXPORT BucketRanges {
- public:
-  typedef std::vector<HistogramBase::Sample> Ranges;
-
-  explicit BucketRanges(size_t num_ranges);
-  ~BucketRanges();
-
-  size_t size() const { return ranges_.size(); }
-  HistogramBase::Sample range(size_t i) const { return ranges_[i]; }
-  void set_range(size_t i, HistogramBase::Sample value) {
-    DCHECK_LT(i, ranges_.size());
-    DCHECK_GE(value, 0);
-    ranges_[i] = value;
-  }
-  uint32_t checksum() const { return checksum_; }
-  void set_checksum(uint32_t checksum) { checksum_ = checksum; }
-
-  // A bucket is defined by a consecutive pair of entries in |ranges|, so there
-  // is one fewer bucket than there are ranges.  For example, if |ranges| is
-  // [0, 1, 3, 7, INT_MAX], then the buckets in this histogram are
-  // [0, 1), [1, 3), [3, 7), and [7, INT_MAX).
-  size_t bucket_count() const { return ranges_.size() - 1; }
-
-  // Checksum methods to verify whether the ranges are corrupted (e.g. bad
-  // memory access).
-  uint32_t CalculateChecksum() const;
-  bool HasValidChecksum() const;
-  void ResetChecksum();
-
-  // Return true iff |other| object has same ranges_ as |this| object's ranges_.
-  bool Equals(const BucketRanges* other) const;
-
-  // Set and get a reference into persistent memory where this bucket data
-  // can be found (and re-used). These calls are internally atomic with no
-  // safety against overwriting an existing value since though it is wasteful
-  // to have multiple identical persistent records, it is still safe.
-  void set_persistent_reference(uint32_t ref) const {
-    subtle::Release_Store(&persistent_reference_, ref);
-  }
-  uint32_t persistent_reference() const {
-    return subtle::Acquire_Load(&persistent_reference_);
-  }
-
- private:
-  // A monotonically increasing list of values which determine which bucket to
-  // put a sample into.  For each index, show the smallest sample that can be
-  // added to the corresponding bucket.
-  Ranges ranges_;
-
-  // Checksum for the conntents of ranges_.  Used to detect random over-writes
-  // of our data, and to quickly see if some other BucketRanges instance is
-  // possibly Equal() to this instance.
-  // TODO(kaiwang): Consider change this to uint64_t. Because we see a lot of
-  // noise on UMA dashboard.
-  uint32_t checksum_;
-
-  // A reference into a global PersistentMemoryAllocator where the ranges
-  // information is stored. This allows for the record to be created once and
-  // re-used simply by having all histograms with the same ranges use the
-  // same reference.
-  mutable subtle::Atomic32 persistent_reference_ = 0;
-
-  DISALLOW_COPY_AND_ASSIGN(BucketRanges);
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// Expose only for test.
-BASE_EXPORT extern const uint32_t kCrcTable[256];
-
-}  // namespace base
-
-#endif  // BASE_METRICS_BUCKET_RANGES_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/field_trial.h b/native/zucchini/vendor/libchrome/base/metrics/field_trial.h
deleted file mode 100644
index ac4ea1c..0000000
--- a/native/zucchini/vendor/libchrome/base/metrics/field_trial.h
+++ /dev/null
@@ -1,802 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// FieldTrial is a class for handling details of statistical experiments
-// performed by actual users in the field (i.e., in a shipped or beta product).
-// All code is called exclusively on the UI thread currently.
-//
-// The simplest example is an experiment to see whether one of two options
-// produces "better" results across our user population.  In that scenario, UMA
-// data is uploaded to aggregate the test results, and this FieldTrial class
-// manages the state of each such experiment (state == which option was
-// pseudo-randomly selected).
-//
-// States are typically generated randomly, either based on a one time
-// randomization (which will yield the same results, in terms of selecting
-// the client for a field trial or not, for every run of the program on a
-// given machine), or by a session randomization (generated each time the
-// application starts up, but held constant during the duration of the
-// process).
-
-//------------------------------------------------------------------------------
-// Example:  Suppose we have an experiment involving memory, such as determining
-// the impact of some pruning algorithm.
-// We assume that we already have a histogram of memory usage, such as:
-
-//   UMA_HISTOGRAM_COUNTS("Memory.RendererTotal", count);
-
-// Somewhere in main thread initialization code, we'd probably define an
-// instance of a FieldTrial, with code such as:
-
-// // FieldTrials are reference counted, and persist automagically until
-// // process teardown, courtesy of their automatic registration in
-// // FieldTrialList.
-// // Note: This field trial will run in Chrome instances compiled through
-// //       8 July, 2015, and after that all instances will be in "StandardMem".
-// scoped_refptr<base::FieldTrial> trial(
-//     base::FieldTrialList::FactoryGetFieldTrial(
-//         "MemoryExperiment", 1000, "StandardMem", 2015, 7, 8,
-//         base::FieldTrial::ONE_TIME_RANDOMIZED, NULL));
-//
-// const int high_mem_group =
-//     trial->AppendGroup("HighMem", 20);  // 2% in HighMem group.
-// const int low_mem_group =
-//     trial->AppendGroup("LowMem", 20);   // 2% in LowMem group.
-// // Take action depending of which group we randomly land in.
-// if (trial->group() == high_mem_group)
-//   SetPruningAlgorithm(kType1);  // Sample setting of browser state.
-// else if (trial->group() == low_mem_group)
-//   SetPruningAlgorithm(kType2);  // Sample alternate setting.
-
-//------------------------------------------------------------------------------
-
-#ifndef BASE_METRICS_FIELD_TRIAL_H_
-#define BASE_METRICS_FIELD_TRIAL_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <vector>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/command_line.h"
-#include "base/feature_list.h"
-#include "base/files/file.h"
-#include "base/gtest_prod_util.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/shared_memory.h"
-#include "base/memory/shared_memory_handle.h"
-#include "base/metrics/persistent_memory_allocator.h"
-#include "base/observer_list_threadsafe.h"
-#include "base/pickle.h"
-#include "base/process/launch.h"
-#include "base/strings/string_piece.h"
-#include "base/synchronization/lock.h"
-#include "base/time/time.h"
-#include "build/build_config.h"
-
-namespace base {
-
-class FieldTrialList;
-
-class BASE_EXPORT FieldTrial : public RefCounted<FieldTrial> {
- public:
-  typedef int Probability;  // Probability type for being selected in a trial.
-
-  // TODO(665129): Make private again after crash has been resolved.
-  typedef SharedPersistentMemoryAllocator::Reference FieldTrialRef;
-
-  // Specifies the persistence of the field trial group choice.
-  enum RandomizationType {
-    // One time randomized trials will persist the group choice between
-    // restarts, which is recommended for most trials, especially those that
-    // change user visible behavior.
-    ONE_TIME_RANDOMIZED,
-    // Session randomized trials will roll the dice to select a group on every
-    // process restart.
-    SESSION_RANDOMIZED,
-  };
-
-  // EntropyProvider is an interface for providing entropy for one-time
-  // randomized (persistent) field trials.
-  class BASE_EXPORT EntropyProvider {
-   public:
-    virtual ~EntropyProvider();
-
-    // Returns a double in the range of [0, 1) to be used for the dice roll for
-    // the specified field trial. If |randomization_seed| is not 0, it will be
-    // used in preference to |trial_name| for generating the entropy by entropy
-    // providers that support it. A given instance should always return the same
-    // value given the same input |trial_name| and |randomization_seed| values.
-    virtual double GetEntropyForTrial(const std::string& trial_name,
-                                      uint32_t randomization_seed) const = 0;
-  };
-
-  // A pair representing a Field Trial and its selected group.
-  struct ActiveGroup {
-    std::string trial_name;
-    std::string group_name;
-  };
-
-  // A triplet representing a FieldTrial, its selected group and whether it's
-  // active. String members are pointers to the underlying strings owned by the
-  // FieldTrial object. Does not use StringPiece to avoid conversions back to
-  // std::string.
-  struct BASE_EXPORT State {
-    const std::string* trial_name = nullptr;
-    const std::string* group_name = nullptr;
-    bool activated = false;
-
-    State();
-    State(const State& other);
-    ~State();
-  };
-
-  // We create one FieldTrialEntry per field trial in shared memory, via
-  // AddToAllocatorWhileLocked. The FieldTrialEntry is followed by a
-  // base::Pickle object that we unpickle and read from.
-  struct BASE_EXPORT FieldTrialEntry {
-    // SHA1(FieldTrialEntry): Increment this if structure changes!
-    static constexpr uint32_t kPersistentTypeId = 0xABA17E13 + 2;
-
-    // Expected size for 32/64-bit check.
-    static constexpr size_t kExpectedInstanceSize = 8;
-
-    // Whether or not this field trial is activated. This is really just a
-    // boolean but using a 32 bit value for portability reasons. It should be
-    // accessed via NoBarrier_Load()/NoBarrier_Store() to prevent the compiler
-    // from doing unexpected optimizations because it thinks that only one
-    // thread is accessing the memory location.
-    subtle::Atomic32 activated;
-
-    // Size of the pickled structure, NOT the total size of this entry.
-    uint32_t pickle_size;
-
-    // Calling this is only valid when the entry is initialized. That is, it
-    // resides in shared memory and has a pickle containing the trial name and
-    // group name following it.
-    bool GetTrialAndGroupName(StringPiece* trial_name,
-                              StringPiece* group_name) const;
-
-    // Calling this is only valid when the entry is initialized as well. Reads
-    // the parameters following the trial and group name and stores them as
-    // key-value mappings in |params|.
-    bool GetParams(std::map<std::string, std::string>* params) const;
-
-   private:
-    // Returns an iterator over the data containing names and params.
-    PickleIterator GetPickleIterator() const;
-
-    // Takes the iterator and writes out the first two items into |trial_name|
-    // and |group_name|.
-    bool ReadStringPair(PickleIterator* iter,
-                        StringPiece* trial_name,
-                        StringPiece* group_name) const;
-  };
-
-  typedef std::vector<ActiveGroup> ActiveGroups;
-
-  // A return value to indicate that a given instance has not yet had a group
-  // assignment (and hence is not yet participating in the trial).
-  static const int kNotFinalized;
-
-  // Disables this trial, meaning it always determines the default group
-  // has been selected. May be called immediately after construction, or
-  // at any time after initialization (should not be interleaved with
-  // AppendGroup calls). Once disabled, there is no way to re-enable a
-  // trial.
-  // TODO(mad): http://code.google.com/p/chromium/issues/detail?id=121446
-  // This doesn't properly reset to Default when a group was forced.
-  void Disable();
-
-  // Establish the name and probability of the next group in this trial.
-  // Sometimes, based on construction randomization, this call may cause the
-  // provided group to be *THE* group selected for use in this instance.
-  // The return value is the group number of the new group.
-  int AppendGroup(const std::string& name, Probability group_probability);
-
-  // Return the name of the FieldTrial (excluding the group name).
-  const std::string& trial_name() const { return trial_name_; }
-
-  // Return the randomly selected group number that was assigned, and notify
-  // any/all observers that this finalized group number has presumably been used
-  // (queried), and will never change. Note that this will force an instance to
-  // participate, and make it illegal to attempt to probabilistically add any
-  // other groups to the trial.
-  int group();
-
-  // If the group's name is empty, a string version containing the group number
-  // is used as the group name. This causes a winner to be chosen if none was.
-  const std::string& group_name();
-
-  // Finalizes the group choice and returns the chosen group, but does not mark
-  // the trial as active - so its state will not be reported until group_name()
-  // or similar is called.
-  const std::string& GetGroupNameWithoutActivation();
-
-  // Set the field trial as forced, meaning that it was setup earlier than
-  // the hard coded registration of the field trial to override it.
-  // This allows the code that was hard coded to register the field trial to
-  // still succeed even though the field trial has already been registered.
-  // This must be called after appending all the groups, since we will make
-  // the group choice here. Note that this is a NOOP for already forced trials.
-  // And, as the rest of the FieldTrial code, this is not thread safe and must
-  // be done from the UI thread.
-  void SetForced();
-
-  // Enable benchmarking sets field trials to a common setting.
-  static void EnableBenchmarking();
-
-  // Creates a FieldTrial object with the specified parameters, to be used for
-  // simulation of group assignment without actually affecting global field
-  // trial state in the running process. Group assignment will be done based on
-  // |entropy_value|, which must have a range of [0, 1).
-  //
-  // Note: Using this function will not register the field trial globally in the
-  // running process - for that, use FieldTrialList::FactoryGetFieldTrial().
-  //
-  // The ownership of the returned FieldTrial is transfered to the caller which
-  // is responsible for deref'ing it (e.g. by using scoped_refptr<FieldTrial>).
-  static FieldTrial* CreateSimulatedFieldTrial(
-      const std::string& trial_name,
-      Probability total_probability,
-      const std::string& default_group_name,
-      double entropy_value);
-
- private:
-  // Allow tests to access our innards for testing purposes.
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, Registration);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, AbsoluteProbabilities);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, RemainingProbability);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, FiftyFiftyProbability);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, MiddleProbabilities);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, OneWinner);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, DisableProbability);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, ActiveGroups);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, AllGroups);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, ActiveGroupsNotFinalized);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, Save);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SaveAll);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, DuplicateRestore);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedTurnFeatureOff);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedTurnFeatureOn);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedChangeDefault_Default);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, SetForcedChangeDefault_NonDefault);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, FloatBoundariesGiveEqualGroupSizes);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialTest, DoesNotSurpassTotalProbability);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest,
-                           DoNotAddSimulatedFieldTrialsToAllocator);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, ClearParamsFromSharedMemory);
-
-  friend class base::FieldTrialList;
-
-  friend class RefCounted<FieldTrial>;
-
-  // This is the group number of the 'default' group when a choice wasn't forced
-  // by a call to FieldTrialList::CreateFieldTrial. It is kept private so that
-  // consumers don't use it by mistake in cases where the group was forced.
-  static const int kDefaultGroupNumber;
-
-  // Creates a field trial with the specified parameters. Group assignment will
-  // be done based on |entropy_value|, which must have a range of [0, 1).
-  FieldTrial(const std::string& trial_name,
-             Probability total_probability,
-             const std::string& default_group_name,
-             double entropy_value);
-  virtual ~FieldTrial();
-
-  // Return the default group name of the FieldTrial.
-  std::string default_group_name() const { return default_group_name_; }
-
-  // Marks this trial as having been registered with the FieldTrialList. Must be
-  // called no more than once and before any |group()| calls have occurred.
-  void SetTrialRegistered();
-
-  // Sets the chosen group name and number.
-  void SetGroupChoice(const std::string& group_name, int number);
-
-  // Ensures that a group is chosen, if it hasn't yet been. The field trial
-  // might yet be disabled, so this call will *not* notify observers of the
-  // status.
-  void FinalizeGroupChoice();
-
-  // Implements FinalizeGroupChoice() with the added flexibility of being
-  // deadlock-free if |is_locked| is true and the caller is holding a lock.
-  void FinalizeGroupChoiceImpl(bool is_locked);
-
-  // Returns the trial name and selected group name for this field trial via
-  // the output parameter |active_group|, but only if the group has already
-  // been chosen and has been externally observed via |group()| and the trial
-  // has not been disabled. In that case, true is returned and |active_group|
-  // is filled in; otherwise, the result is false and |active_group| is left
-  // untouched.
-  bool GetActiveGroup(ActiveGroup* active_group) const;
-
-  // Returns the trial name and selected group name for this field trial via
-  // the output parameter |field_trial_state| for all the studies when
-  // |bool include_expired| is true. In case when |bool include_expired| is
-  // false, if the trial has not been disabled true is returned and
-  // |field_trial_state| is filled in; otherwise, the result is false and
-  // |field_trial_state| is left untouched.
-  // This function is deadlock-free if the caller is holding a lock.
-  bool GetStateWhileLocked(State* field_trial_state, bool include_expired);
-
-  // Returns the group_name. A winner need not have been chosen.
-  std::string group_name_internal() const { return group_name_; }
-
-  // The name of the field trial, as can be found via the FieldTrialList.
-  const std::string trial_name_;
-
-  // The maximum sum of all probabilities supplied, which corresponds to 100%.
-  // This is the scaling factor used to adjust supplied probabilities.
-  const Probability divisor_;
-
-  // The name of the default group.
-  const std::string default_group_name_;
-
-  // The randomly selected probability that is used to select a group (or have
-  // the instance not participate).  It is the product of divisor_ and a random
-  // number between [0, 1).
-  Probability random_;
-
-  // Sum of the probabilities of all appended groups.
-  Probability accumulated_group_probability_;
-
-  // The number that will be returned by the next AppendGroup() call.
-  int next_group_number_;
-
-  // The pseudo-randomly assigned group number.
-  // This is kNotFinalized if no group has been assigned.
-  int group_;
-
-  // A textual name for the randomly selected group. Valid after |group()|
-  // has been called.
-  std::string group_name_;
-
-  // When enable_field_trial_ is false, field trial reverts to the 'default'
-  // group.
-  bool enable_field_trial_;
-
-  // When forced_ is true, we return the chosen group from AppendGroup when
-  // appropriate.
-  bool forced_;
-
-  // Specifies whether the group choice has been reported to observers.
-  bool group_reported_;
-
-  // Whether this trial is registered with the global FieldTrialList and thus
-  // should notify it when its group is queried.
-  bool trial_registered_;
-
-  // Reference to related field trial struct and data in shared memory.
-  FieldTrialRef ref_;
-
-  // When benchmarking is enabled, field trials all revert to the 'default'
-  // group.
-  static bool enable_benchmarking_;
-
-  DISALLOW_COPY_AND_ASSIGN(FieldTrial);
-};
-
-//------------------------------------------------------------------------------
-// Class with a list of all active field trials.  A trial is active if it has
-// been registered, which includes evaluating its state based on its probaility.
-// Only one instance of this class exists and outside of testing, will live for
-// the entire life time of the process.
-class BASE_EXPORT FieldTrialList {
- public:
-  typedef SharedPersistentMemoryAllocator FieldTrialAllocator;
-
-  // Type for function pointer passed to |AllParamsToString| used to escape
-  // special characters from |input|.
-  typedef std::string (*EscapeDataFunc)(const std::string& input);
-
-  // Year that is guaranteed to not be expired when instantiating a field trial
-  // via |FactoryGetFieldTrial()|.  Set to two years from the build date.
-  static int kNoExpirationYear;
-
-  // Observer is notified when a FieldTrial's group is selected.
-  class BASE_EXPORT Observer {
-   public:
-    // Notify observers when FieldTrials's group is selected.
-    virtual void OnFieldTrialGroupFinalized(const std::string& trial_name,
-                                            const std::string& group_name) = 0;
-
-   protected:
-    virtual ~Observer();
-  };
-
-  // This singleton holds the global list of registered FieldTrials.
-  //
-  // To support one-time randomized field trials, specify a non-null
-  // |entropy_provider| which should be a source of uniformly distributed
-  // entropy values. If one time randomization is not desired, pass in null for
-  // |entropy_provider|.
-  explicit FieldTrialList(
-      std::unique_ptr<const FieldTrial::EntropyProvider> entropy_provider);
-
-  // Destructor Release()'s references to all registered FieldTrial instances.
-  ~FieldTrialList();
-
-  // Get a FieldTrial instance from the factory.
-  //
-  // |name| is used to register the instance with the FieldTrialList class,
-  // and can be used to find the trial (only one trial can be present for each
-  // name). |default_group_name| is the name of the default group which will
-  // be chosen if none of the subsequent appended groups get to be chosen.
-  // |default_group_number| can receive the group number of the default group as
-  // AppendGroup returns the number of the subsequence groups. |trial_name| and
-  // |default_group_name| may not be empty but |default_group_number| can be
-  // NULL if the value is not needed.
-  //
-  // Group probabilities that are later supplied must sum to less than or equal
-  // to the |total_probability|. Arguments |year|, |month| and |day_of_month|
-  // specify the expiration time. If the build time is after the expiration time
-  // then the field trial reverts to the 'default' group.
-  //
-  // Use this static method to get a startup-randomized FieldTrial or a
-  // previously created forced FieldTrial.
-  static FieldTrial* FactoryGetFieldTrial(
-      const std::string& trial_name,
-      FieldTrial::Probability total_probability,
-      const std::string& default_group_name,
-      const int year,
-      const int month,
-      const int day_of_month,
-      FieldTrial::RandomizationType randomization_type,
-      int* default_group_number);
-
-  // Same as FactoryGetFieldTrial(), but allows specifying a custom seed to be
-  // used on one-time randomized field trials (instead of a hash of the trial
-  // name, which is used otherwise or if |randomization_seed| has value 0). The
-  // |randomization_seed| value (other than 0) should never be the same for two
-  // trials, else this would result in correlated group assignments.  Note:
-  // Using a custom randomization seed is only supported by the
-  // PermutedEntropyProvider (which is used when UMA is not enabled). If
-  // |override_entropy_provider| is not null, then it will be used for
-  // randomization instead of the provider given when the FieldTrialList was
-  // instantiated.
-  static FieldTrial* FactoryGetFieldTrialWithRandomizationSeed(
-      const std::string& trial_name,
-      FieldTrial::Probability total_probability,
-      const std::string& default_group_name,
-      const int year,
-      const int month,
-      const int day_of_month,
-      FieldTrial::RandomizationType randomization_type,
-      uint32_t randomization_seed,
-      int* default_group_number,
-      const FieldTrial::EntropyProvider* override_entropy_provider);
-
-  // The Find() method can be used to test to see if a named trial was already
-  // registered, or to retrieve a pointer to it from the global map.
-  static FieldTrial* Find(const std::string& trial_name);
-
-  // Returns the group number chosen for the named trial, or
-  // FieldTrial::kNotFinalized if the trial does not exist.
-  static int FindValue(const std::string& trial_name);
-
-  // Returns the group name chosen for the named trial, or the empty string if
-  // the trial does not exist. The first call of this function on a given field
-  // trial will mark it as active, so that its state will be reported with usage
-  // metrics, crashes, etc.
-  static std::string FindFullName(const std::string& trial_name);
-
-  // Returns true if the named trial has been registered.
-  static bool TrialExists(const std::string& trial_name);
-
-  // Returns true if the named trial exists and has been activated.
-  static bool IsTrialActive(const std::string& trial_name);
-
-  // Creates a persistent representation of active FieldTrial instances for
-  // resurrection in another process. This allows randomization to be done in
-  // one process, and secondary processes can be synchronized on the result.
-  // The resulting string contains the name and group name pairs of all
-  // registered FieldTrials for which the group has been chosen and externally
-  // observed (via |group()|) and which have not been disabled, with "/" used
-  // to separate all names and to terminate the string. This string is parsed
-  // by |CreateTrialsFromString()|.
-  static void StatesToString(std::string* output);
-
-  // Creates a persistent representation of all FieldTrial instances for
-  // resurrection in another process. This allows randomization to be done in
-  // one process, and secondary processes can be synchronized on the result.
-  // The resulting string contains the name and group name pairs of all
-  // registered FieldTrials including disabled based on |include_expired|,
-  // with "/" used to separate all names and to terminate the string. All
-  // activated trials have their name prefixed with "*". This string is parsed
-  // by |CreateTrialsFromString()|.
-  static void AllStatesToString(std::string* output, bool include_expired);
-
-  // Creates a persistent representation of all FieldTrial params for
-  // resurrection in another process. The returned string contains the trial
-  // name and group name pairs of all registered FieldTrials including disabled
-  // based on |include_expired| separated by '.'. The pair is followed by ':'
-  // separator and list of param name and values separated by '/'. It also takes
-  // |encode_data_func| function pointer for encodeing special charactors.
-  // This string is parsed by |AssociateParamsFromString()|.
-  static std::string AllParamsToString(bool include_expired,
-                                       EscapeDataFunc encode_data_func);
-
-  // Fills in the supplied vector |active_groups| (which must be empty when
-  // called) with a snapshot of all registered FieldTrials for which the group
-  // has been chosen and externally observed (via |group()|) and which have
-  // not been disabled.
-  static void GetActiveFieldTrialGroups(
-      FieldTrial::ActiveGroups* active_groups);
-
-  // Returns the field trials that are marked active in |trials_string|.
-  static void GetActiveFieldTrialGroupsFromString(
-      const std::string& trials_string,
-      FieldTrial::ActiveGroups* active_groups);
-
-  // Returns the field trials that were active when the process was
-  // created. Either parses the field trial string or the shared memory
-  // holding field trial information.
-  // Must be called only after a call to CreateTrialsFromCommandLine().
-  static void GetInitiallyActiveFieldTrials(
-      const base::CommandLine& command_line,
-      FieldTrial::ActiveGroups* active_groups);
-
-  // Use a state string (re: StatesToString()) to augment the current list of
-  // field trials to include the supplied trials, and using a 100% probability
-  // for each trial, force them to have the same group string. This is commonly
-  // used in a non-browser process, to carry randomly selected state in a
-  // browser process into this non-browser process, but could also be invoked
-  // through a command line argument to the browser process. Created field
-  // trials will be marked "used" for the purposes of active trial reporting
-  // if they are prefixed with |kActivationMarker|. Trial names in
-  // |ignored_trial_names| are ignored when parsing |trials_string|.
-  static bool CreateTrialsFromString(
-      const std::string& trials_string,
-      const std::set<std::string>& ignored_trial_names);
-
-  // Achieves the same thing as CreateTrialsFromString, except wraps the logic
-  // by taking in the trials from the command line, either via shared memory
-  // handle or command line argument. A bit of a misnomer since on POSIX we
-  // simply get the trials from opening |fd_key| if using shared memory. On
-  // Windows, we expect the |cmd_line| switch for |field_trial_handle_switch| to
-  // contain the shared memory handle that contains the field trial allocator.
-  // We need the |field_trial_handle_switch| and |fd_key| arguments to be passed
-  // in since base/ can't depend on content/.
-  static void CreateTrialsFromCommandLine(const base::CommandLine& cmd_line,
-                                          const char* field_trial_handle_switch,
-                                          int fd_key);
-
-  // Creates base::Feature overrides from the command line by first trying to
-  // use shared memory and then falling back to the command line if it fails.
-  static void CreateFeaturesFromCommandLine(
-      const base::CommandLine& command_line,
-      const char* enable_features_switch,
-      const char* disable_features_switch,
-      FeatureList* feature_list);
-
-#if defined(OS_WIN)
-  // On Windows, we need to explicitly pass down any handles to be inherited.
-  // This function adds the shared memory handle to field trial state to the
-  // list of handles to be inherited.
-  static void AppendFieldTrialHandleIfNeeded(
-      base::HandlesToInheritVector* handles);
-#elif defined(OS_FUCHSIA)
-  // TODO(fuchsia): Implement shared-memory configuration (crbug.com/752368).
-#elif defined(OS_POSIX) && !defined(OS_NACL)
-  // On POSIX, we also need to explicitly pass down this file descriptor that
-  // should be shared with the child process. Returns an invalid handle if it
-  // was not initialized properly.
-  static base::SharedMemoryHandle GetFieldTrialHandle();
-#endif
-
-  // Adds a switch to the command line containing the field trial state as a
-  // string (if not using shared memory to share field trial state), or the
-  // shared memory handle + length.
-  // Needs the |field_trial_handle_switch| argument to be passed in since base/
-  // can't depend on content/.
-  static void CopyFieldTrialStateToFlags(const char* field_trial_handle_switch,
-                                         const char* enable_features_switch,
-                                         const char* disable_features_switch,
-                                         base::CommandLine* cmd_line);
-
-  // Create a FieldTrial with the given |name| and using 100% probability for
-  // the FieldTrial, force FieldTrial to have the same group string as
-  // |group_name|. This is commonly used in a non-browser process, to carry
-  // randomly selected state in a browser process into this non-browser process.
-  // It returns NULL if there is a FieldTrial that is already registered with
-  // the same |name| but has different finalized group string (|group_name|).
-  static FieldTrial* CreateFieldTrial(const std::string& name,
-                                      const std::string& group_name);
-
-  // Add an observer to be notified when a field trial is irrevocably committed
-  // to being part of some specific field_group (and hence the group_name is
-  // also finalized for that field_trial). Returns false and does nothing if
-  // there is no FieldTrialList singleton.
-  static bool AddObserver(Observer* observer);
-
-  // Remove an observer.
-  static void RemoveObserver(Observer* observer);
-
-  // Similar to AddObserver(), but the passed observer will be notified
-  // synchronously when a field trial is activated and its group selected. It
-  // will be notified synchronously on the same thread where the activation and
-  // group selection happened. It is the responsibility of the observer to make
-  // sure that this is a safe operation and the operation must be fast, as this
-  // work is done synchronously as part of group() or related APIs. Only a
-  // single such observer is supported, exposed specifically for crash
-  // reporting. Must be called on the main thread before any other threads
-  // have been started.
-  static void SetSynchronousObserver(Observer* observer);
-
-  // Removes the single synchronous observer.
-  static void RemoveSynchronousObserver(Observer* observer);
-
-  // Grabs the lock if necessary and adds the field trial to the allocator. This
-  // should only be called from FinalizeGroupChoice().
-  static void OnGroupFinalized(bool is_locked, FieldTrial* field_trial);
-
-  // Notify all observers that a group has been finalized for |field_trial|.
-  static void NotifyFieldTrialGroupSelection(FieldTrial* field_trial);
-
-  // Return the number of active field trials.
-  static size_t GetFieldTrialCount();
-
-  // Gets the parameters for |field_trial| from shared memory and stores them in
-  // |params|. This is only exposed for use by FieldTrialParamAssociator and
-  // shouldn't be used by anything else.
-  static bool GetParamsFromSharedMemory(
-      FieldTrial* field_trial,
-      std::map<std::string, std::string>* params);
-
-  // Clears all the params in the allocator.
-  static void ClearParamsFromSharedMemoryForTesting();
-
-  // Dumps field trial state to an allocator so that it can be analyzed after a
-  // crash.
-  static void DumpAllFieldTrialsToPersistentAllocator(
-      PersistentMemoryAllocator* allocator);
-
-  // Retrieves field trial state from an allocator so that it can be analyzed
-  // after a crash. The pointers in the returned vector are into the persistent
-  // memory segment and so are only valid as long as the allocator is valid.
-  static std::vector<const FieldTrial::FieldTrialEntry*>
-  GetAllFieldTrialsFromPersistentAllocator(
-      PersistentMemoryAllocator const& allocator);
-
-  // Returns true if a global field trial list is set. Only used for testing.
-  static bool IsGlobalSetForTesting();
-
- private:
-  // Allow tests to access our innards for testing purposes.
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, InstantiateAllocator);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, AddTrialsToAllocator);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest,
-                           DoNotAddSimulatedFieldTrialsToAllocator);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, AssociateFieldTrialParams);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, ClearParamsFromSharedMemory);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest,
-                           SerializeSharedMemoryHandleMetadata);
-  FRIEND_TEST_ALL_PREFIXES(FieldTrialListTest, CheckReadOnlySharedMemoryHandle);
-
-  // Serialization is used to pass information about the handle to child
-  // processes. It passes a reference to the relevant OS resource, and it passes
-  // a GUID. Serialization and deserialization doesn't actually transport the
-  // underlying OS resource - that must be done by the Process launcher.
-  static std::string SerializeSharedMemoryHandleMetadata(
-      const SharedMemoryHandle& shm);
-#if defined(OS_WIN) || defined(OS_FUCHSIA)
-  static SharedMemoryHandle DeserializeSharedMemoryHandleMetadata(
-      const std::string& switch_value);
-#elif defined(OS_POSIX) && !defined(OS_NACL)
-  static SharedMemoryHandle DeserializeSharedMemoryHandleMetadata(
-      int fd,
-      const std::string& switch_value);
-#endif
-
-#if defined(OS_WIN) || defined(OS_FUCHSIA)
-  // Takes in |handle_switch| from the command line which represents the shared
-  // memory handle for field trials, parses it, and creates the field trials.
-  // Returns true on success, false on failure.
-  // |switch_value| also contains the serialized GUID.
-  static bool CreateTrialsFromSwitchValue(const std::string& switch_value);
-#elif defined(OS_POSIX) && !defined(OS_NACL)
-  // On POSIX systems that use the zygote, we look up the correct fd that backs
-  // the shared memory segment containing the field trials by looking it up via
-  // an fd key in GlobalDescriptors. Returns true on success, false on failure.
-  // |switch_value| also contains the serialized GUID.
-  static bool CreateTrialsFromDescriptor(int fd_key,
-                                         const std::string& switch_value);
-#endif
-
-  // Takes an unmapped SharedMemoryHandle, creates a SharedMemory object from it
-  // and maps it with the correct size.
-  static bool CreateTrialsFromSharedMemoryHandle(SharedMemoryHandle shm_handle);
-
-  // Expects a mapped piece of shared memory |shm| that was created from the
-  // browser process's field_trial_allocator and shared via the command line.
-  // This function recreates the allocator, iterates through all the field
-  // trials in it, and creates them via CreateFieldTrial(). Returns true if
-  // successful and false otherwise.
-  static bool CreateTrialsFromSharedMemory(
-      std::unique_ptr<base::SharedMemory> shm);
-
-  // Instantiate the field trial allocator, add all existing field trials to it,
-  // and duplicates its handle to a read-only handle, which gets stored in
-  // |readonly_allocator_handle|.
-  static void InstantiateFieldTrialAllocatorIfNeeded();
-
-  // Adds the field trial to the allocator. Caller must hold a lock before
-  // calling this.
-  static void AddToAllocatorWhileLocked(PersistentMemoryAllocator* allocator,
-                                        FieldTrial* field_trial);
-
-  // Activate the corresponding field trial entry struct in shared memory.
-  static void ActivateFieldTrialEntryWhileLocked(FieldTrial* field_trial);
-
-  // A map from FieldTrial names to the actual instances.
-  typedef std::map<std::string, FieldTrial*> RegistrationMap;
-
-  // If one-time randomization is enabled, returns a weak pointer to the
-  // corresponding EntropyProvider. Otherwise, returns NULL.
-  static const FieldTrial::EntropyProvider*
-      GetEntropyProviderForOneTimeRandomization();
-
-  // Helper function should be called only while holding lock_.
-  FieldTrial* PreLockedFind(const std::string& name);
-
-  // Register() stores a pointer to the given trial in a global map.
-  // This method also AddRef's the indicated trial.
-  // This should always be called after creating a new FieldTrial instance.
-  static void Register(FieldTrial* trial);
-
-  // Returns all the registered trials.
-  static RegistrationMap GetRegisteredTrials();
-
-  static FieldTrialList* global_;  // The singleton of this class.
-
-  // This will tell us if there is an attempt to register a field
-  // trial or check if one-time randomization is enabled without
-  // creating the FieldTrialList. This is not an error, unless a
-  // FieldTrialList is created after that.
-  static bool used_without_global_;
-
-  // Lock for access to registered_ and field_trial_allocator_.
-  Lock lock_;
-  RegistrationMap registered_;
-
-  std::map<std::string, std::string> seen_states_;
-
-  // Entropy provider to be used for one-time randomized field trials. If NULL,
-  // one-time randomization is not supported.
-  std::unique_ptr<const FieldTrial::EntropyProvider> entropy_provider_;
-
-  // List of observers to be notified when a group is selected for a FieldTrial.
-  scoped_refptr<ObserverListThreadSafe<Observer> > observer_list_;
-
-  // Single synchronous observer to be notified when a trial group is chosen.
-  Observer* synchronous_observer_ = nullptr;
-
-  // Allocator in shared memory containing field trial data. Used in both
-  // browser and child processes, but readonly in the child.
-  // In the future, we may want to move this to a more generic place if we want
-  // to start passing more data other than field trials.
-  std::unique_ptr<FieldTrialAllocator> field_trial_allocator_ = nullptr;
-
-  // Readonly copy of the handle to the allocator. Needs to be a member variable
-  // because it's needed from both CopyFieldTrialStateToFlags() and
-  // AppendFieldTrialHandleIfNeeded().
-  base::SharedMemoryHandle readonly_allocator_handle_;
-
-  // Tracks whether CreateTrialsFromCommandLine() has been called.
-  bool create_trials_from_command_line_called_ = false;
-
-  DISALLOW_COPY_AND_ASSIGN(FieldTrialList);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_FIELD_TRIAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram.h b/native/zucchini/vendor/libchrome/base/metrics/histogram.h
deleted file mode 100644
index bd5a9eb..0000000
--- a/native/zucchini/vendor/libchrome/base/metrics/histogram.h
+++ /dev/null
@@ -1,610 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Histogram is an object that aggregates statistics, and can summarize them in
-// various forms, including ASCII graphical, HTML, and numerically (as a
-// vector of numbers corresponding to each of the aggregating buckets).
-
-// It supports calls to accumulate either time intervals (which are processed
-// as integral number of milliseconds), or arbitrary integral units.
-
-// For Histogram (exponential histogram), LinearHistogram and CustomHistogram,
-// the minimum for a declared range is 1 (instead of 0), while the maximum is
-// (HistogramBase::kSampleType_MAX - 1). However, there will always be underflow
-// and overflow buckets added automatically, so a 0 bucket will always exist
-// even when a minimum value of 1 is specified.
-
-// Each use of a histogram with the same name will reference the same underlying
-// data, so it is safe to record to the same histogram from multiple locations
-// in the code. It is a runtime error if all uses of the same histogram do not
-// agree exactly in type, bucket size and range.
-
-// For Histogram and LinearHistogram, the maximum for a declared range should
-// always be larger (not equal) than minimal range. Zero and
-// HistogramBase::kSampleType_MAX are implicitly added as first and last ranges,
-// so the smallest legal bucket_count is 3. However CustomHistogram can have
-// bucket count as 2 (when you give a custom ranges vector containing only 1
-// range).
-// For these 3 kinds of histograms, the max bucket count is always
-// (Histogram::kBucketCount_MAX - 1).
-
-// The buckets layout of class Histogram is exponential. For example, buckets
-// might contain (sequentially) the count of values in the following intervals:
-// [0,1), [1,2), [2,4), [4,8), [8,16), [16,32), [32,64), [64,infinity)
-// That bucket allocation would actually result from construction of a histogram
-// for values between 1 and 64, with 8 buckets, such as:
-// Histogram count("some name", 1, 64, 8);
-// Note that the underflow bucket [0,1) and the overflow bucket [64,infinity)
-// are also counted by the constructor in the user supplied "bucket_count"
-// argument.
-// The above example has an exponential ratio of 2 (doubling the bucket width
-// in each consecutive bucket).  The Histogram class automatically calculates
-// the smallest ratio that it can use to construct the number of buckets
-// selected in the constructor.  An another example, if you had 50 buckets,
-// and millisecond time values from 1 to 10000, then the ratio between
-// consecutive bucket widths will be approximately somewhere around the 50th
-// root of 10000.  This approach provides very fine grain (narrow) buckets
-// at the low end of the histogram scale, but allows the histogram to cover a
-// gigantic range with the addition of very few buckets.
-
-// Usually we use macros to define and use a histogram, which are defined in
-// base/metrics/histogram_macros.h. Note: Callers should include that header
-// directly if they only access the histogram APIs through macros.
-//
-// Macros use a pattern involving a function static variable, that is a pointer
-// to a histogram.  This static is explicitly initialized on any thread
-// that detects a uninitialized (NULL) pointer.  The potentially racy
-// initialization is not a problem as it is always set to point to the same
-// value (i.e., the FactoryGet always returns the same value).  FactoryGet
-// is also completely thread safe, which results in a completely thread safe,
-// and relatively fast, set of counters.  To avoid races at shutdown, the static
-// pointer is NOT deleted, and we leak the histograms at process termination.
-
-#ifndef BASE_METRICS_HISTOGRAM_H_
-#define BASE_METRICS_HISTOGRAM_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "base/containers/span.h"
-#include "base/gtest_prod_util.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/metrics/bucket_ranges.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/strings/string_piece.h"
-#include "base/time/time.h"
-
-namespace base {
-
-class BooleanHistogram;
-class CustomHistogram;
-class DelayedPersistentAllocation;
-class Histogram;
-class HistogramTest;
-class LinearHistogram;
-class Pickle;
-class PickleIterator;
-class SampleVector;
-class SampleVectorBase;
-
-class BASE_EXPORT Histogram : public HistogramBase {
- public:
-  // Initialize maximum number of buckets in histograms as 16,384.
-  static const uint32_t kBucketCount_MAX;
-
-  typedef std::vector<Count> Counts;
-
-  ~Histogram() override;
-
-  //----------------------------------------------------------------------------
-  // For a valid histogram, input should follow these restrictions:
-  // minimum > 0 (if a minimum below 1 is specified, it will implicitly be
-  //              normalized up to 1)
-  // maximum > minimum
-  // buckets > 2 [minimum buckets needed: underflow, overflow and the range]
-  // Additionally,
-  // buckets <= (maximum - minimum + 2) - this is to ensure that we don't have
-  // more buckets than the range of numbers; having more buckets than 1 per
-  // value in the range would be nonsensical.
-  static HistogramBase* FactoryGet(const std::string& name,
-                                   Sample minimum,
-                                   Sample maximum,
-                                   uint32_t bucket_count,
-                                   int32_t flags);
-  static HistogramBase* FactoryTimeGet(const std::string& name,
-                                       base::TimeDelta minimum,
-                                       base::TimeDelta maximum,
-                                       uint32_t bucket_count,
-                                       int32_t flags);
-  static HistogramBase* FactoryMicrosecondsTimeGet(const std::string& name,
-                                                   base::TimeDelta minimum,
-                                                   base::TimeDelta maximum,
-                                                   uint32_t bucket_count,
-                                                   int32_t flags);
-
-  // Overloads of the above functions that take a const char* |name| param, to
-  // avoid code bloat from the std::string constructor being inlined into call
-  // sites.
-  static HistogramBase* FactoryGet(const char* name,
-                                   Sample minimum,
-                                   Sample maximum,
-                                   uint32_t bucket_count,
-                                   int32_t flags);
-  static HistogramBase* FactoryTimeGet(const char* name,
-                                       base::TimeDelta minimum,
-                                       base::TimeDelta maximum,
-                                       uint32_t bucket_count,
-                                       int32_t flags);
-  static HistogramBase* FactoryMicrosecondsTimeGet(const char* name,
-                                                   base::TimeDelta minimum,
-                                                   base::TimeDelta maximum,
-                                                   uint32_t bucket_count,
-                                                   int32_t flags);
-
-  // Create a histogram using data in persistent storage.
-  static std::unique_ptr<HistogramBase> PersistentCreate(
-      const char* name,
-      Sample minimum,
-      Sample maximum,
-      const BucketRanges* ranges,
-      const DelayedPersistentAllocation& counts,
-      const DelayedPersistentAllocation& logged_counts,
-      HistogramSamples::Metadata* meta,
-      HistogramSamples::Metadata* logged_meta);
-
-  static void InitializeBucketRanges(Sample minimum,
-                                     Sample maximum,
-                                     BucketRanges* ranges);
-
-  // This constant if for FindCorruption. Since snapshots of histograms are
-  // taken asynchronously relative to sampling, and our counting code currently
-  // does not prevent race conditions, it is pretty likely that we'll catch a
-  // redundant count that doesn't match the sample count.  We allow for a
-  // certain amount of slop before flagging this as an inconsistency. Even with
-  // an inconsistency, we'll snapshot it again (for UMA in about a half hour),
-  // so we'll eventually get the data, if it was not the result of a corruption.
-  static const int kCommonRaceBasedCountMismatch;
-
-  // Check to see if bucket ranges, counts and tallies in the snapshot are
-  // consistent with the bucket ranges and checksums in our histogram.  This can
-  // produce a false-alarm if a race occurred in the reading of the data during
-  // a SnapShot process, but should otherwise be false at all times (unless we
-  // have memory over-writes, or DRAM failures). Flag definitions are located
-  // under "enum Inconsistency" in base/metrics/histogram_base.h.
-  uint32_t FindCorruption(const HistogramSamples& samples) const override;
-
-  //----------------------------------------------------------------------------
-  // Accessors for factory construction, serialization and testing.
-  //----------------------------------------------------------------------------
-  const BucketRanges* bucket_ranges() const;
-  Sample declared_min() const;
-  Sample declared_max() const;
-  virtual Sample ranges(uint32_t i) const;
-  virtual uint32_t bucket_count() const;
-
-  // This function validates histogram construction arguments. It returns false
-  // if some of the arguments are bad but also corrects them so they should
-  // function on non-dcheck builds without crashing.
-  // Note. Currently it allow some bad input, e.g. 0 as minimum, but silently
-  // converts it to good input: 1.
-  // TODO(bcwhite): Use false returns to create "sink" histograms so that bad
-  // data doesn't create confusion on the servers.
-  static bool InspectConstructionArguments(StringPiece name,
-                                           Sample* minimum,
-                                           Sample* maximum,
-                                           uint32_t* bucket_count);
-
-  // HistogramBase implementation:
-  uint64_t name_hash() const override;
-  HistogramType GetHistogramType() const override;
-  bool HasConstructionArguments(Sample expected_minimum,
-                                Sample expected_maximum,
-                                uint32_t expected_bucket_count) const override;
-  void Add(Sample value) override;
-  void AddCount(Sample value, int count) override;
-  std::unique_ptr<HistogramSamples> SnapshotSamples() const override;
-  std::unique_ptr<HistogramSamples> SnapshotDelta() override;
-  std::unique_ptr<HistogramSamples> SnapshotFinalDelta() const override;
-  void AddSamples(const HistogramSamples& samples) override;
-  bool AddSamplesFromPickle(base::PickleIterator* iter) override;
-  void WriteHTMLGraph(std::string* output) const override;
-  void WriteAscii(std::string* output) const override;
-
-  // Validates the histogram contents and CHECKs on errors.
-  // TODO(bcwhite): Remove this after https://crbug/836875.
-  void ValidateHistogramContents() const override;
-
- protected:
-  // This class, defined entirely within the .cc file, contains all the
-  // common logic for building a Histogram and can be overridden by more
-  // specific types to alter details of how the creation is done. It is
-  // defined as an embedded class (rather than an anonymous one) so it
-  // can access the protected constructors.
-  class Factory;
-
-  // |ranges| should contain the underflow and overflow buckets. See top
-  // comments for example.
-  Histogram(const char* name,
-            Sample minimum,
-            Sample maximum,
-            const BucketRanges* ranges);
-
-  // Traditionally, histograms allocate their own memory for the bucket
-  // vector but "shared" histograms use memory regions allocated from a
-  // special memory segment that is passed in here.  It is assumed that
-  // the life of this memory is managed externally and exceeds the lifetime
-  // of this object. Practically, this memory is never released until the
-  // process exits and the OS cleans it up.
-  Histogram(const char* name,
-            Sample minimum,
-            Sample maximum,
-            const BucketRanges* ranges,
-            const DelayedPersistentAllocation& counts,
-            const DelayedPersistentAllocation& logged_counts,
-            HistogramSamples::Metadata* meta,
-            HistogramSamples::Metadata* logged_meta);
-
-  // HistogramBase implementation:
-  void SerializeInfoImpl(base::Pickle* pickle) const override;
-
-  // Method to override to skip the display of the i'th bucket if it's empty.
-  virtual bool PrintEmptyBucket(uint32_t index) const;
-
-  // Get normalized size, relative to the ranges(i).
-  virtual double GetBucketSize(Count current, uint32_t i) const;
-
-  // Return a string description of what goes in a given bucket.
-  // Most commonly this is the numeric value, but in derived classes it may
-  // be a name (or string description) given to the bucket.
-  virtual const std::string GetAsciiBucketRange(uint32_t it) const;
-
- private:
-  // Allow tests to corrupt our innards for testing purposes.
-  friend class HistogramTest;
-  FRIEND_TEST_ALL_PREFIXES(HistogramTest, BoundsTest);
-  FRIEND_TEST_ALL_PREFIXES(HistogramTest, BucketPlacementTest);
-  FRIEND_TEST_ALL_PREFIXES(HistogramTest, CorruptSampleCounts);
-
-  friend class StatisticsRecorder;  // To allow it to delete duplicates.
-  friend class StatisticsRecorderTest;
-
-  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
-      base::PickleIterator* iter);
-  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
-
-  // Create a snapshot containing all samples (both logged and unlogged).
-  // Implementation of SnapshotSamples method with a more specific type for
-  // internal use.
-  std::unique_ptr<SampleVector> SnapshotAllSamples() const;
-
-  // Create a copy of unlogged samples.
-  std::unique_ptr<SampleVector> SnapshotUnloggedSamples() const;
-
-  //----------------------------------------------------------------------------
-  // Helpers for emitting Ascii graphic.  Each method appends data to output.
-
-  void WriteAsciiImpl(bool graph_it,
-                      const std::string& newline,
-                      std::string* output) const;
-
-  // Find out how large (graphically) the largest bucket will appear to be.
-  double GetPeakBucketSize(const SampleVectorBase& samples) const;
-
-  // Write a common header message describing this histogram.
-  void WriteAsciiHeader(const SampleVectorBase& samples,
-                        Count sample_count,
-                        std::string* output) const;
-
-  // Write information about previous, current, and next buckets.
-  // Information such as cumulative percentage, etc.
-  void WriteAsciiBucketContext(const int64_t past,
-                               const Count current,
-                               const int64_t remaining,
-                               const uint32_t i,
-                               std::string* output) const;
-
-  // WriteJSON calls these.
-  void GetParameters(DictionaryValue* params) const override;
-
-  void GetCountAndBucketData(Count* count,
-                             int64_t* sum,
-                             ListValue* buckets) const override;
-
-  // Samples that have not yet been logged with SnapshotDelta().
-  std::unique_ptr<SampleVectorBase> unlogged_samples_;
-
-  // Accumulation of all samples that have been logged with SnapshotDelta().
-  std::unique_ptr<SampleVectorBase> logged_samples_;
-
-#if DCHECK_IS_ON()  // Don't waste memory if it won't be used.
-  // Flag to indicate if PrepareFinalDelta has been previously called. It is
-  // used to DCHECK that a final delta is not created multiple times.
-  mutable bool final_delta_created_ = false;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(Histogram);
-};
-
-//------------------------------------------------------------------------------
-
-// LinearHistogram is a more traditional histogram, with evenly spaced
-// buckets.
-class BASE_EXPORT LinearHistogram : public Histogram {
- public:
-  ~LinearHistogram() override;
-
-  /* minimum should start from 1. 0 is as minimum is invalid. 0 is an implicit
-     default underflow bucket. */
-  static HistogramBase* FactoryGet(const std::string& name,
-                                   Sample minimum,
-                                   Sample maximum,
-                                   uint32_t bucket_count,
-                                   int32_t flags);
-  static HistogramBase* FactoryTimeGet(const std::string& name,
-                                       TimeDelta minimum,
-                                       TimeDelta maximum,
-                                       uint32_t bucket_count,
-                                       int32_t flags);
-
-  // Overloads of the above two functions that take a const char* |name| param,
-  // to avoid code bloat from the std::string constructor being inlined into
-  // call sites.
-  static HistogramBase* FactoryGet(const char* name,
-                                   Sample minimum,
-                                   Sample maximum,
-                                   uint32_t bucket_count,
-                                   int32_t flags);
-  static HistogramBase* FactoryTimeGet(const char* name,
-                                       TimeDelta minimum,
-                                       TimeDelta maximum,
-                                       uint32_t bucket_count,
-                                       int32_t flags);
-
-  // Create a histogram using data in persistent storage.
-  static std::unique_ptr<HistogramBase> PersistentCreate(
-      const char* name,
-      Sample minimum,
-      Sample maximum,
-      const BucketRanges* ranges,
-      const DelayedPersistentAllocation& counts,
-      const DelayedPersistentAllocation& logged_counts,
-      HistogramSamples::Metadata* meta,
-      HistogramSamples::Metadata* logged_meta);
-
-  struct DescriptionPair {
-    Sample sample;
-    const char* description;  // Null means end of a list of pairs.
-  };
-
-  // Create a LinearHistogram and store a list of number/text values for use in
-  // writing the histogram graph.
-  // |descriptions| can be NULL, which means no special descriptions to set. If
-  // it's not NULL, the last element in the array must has a NULL in its
-  // "description" field.
-  static HistogramBase* FactoryGetWithRangeDescription(
-      const std::string& name,
-      Sample minimum,
-      Sample maximum,
-      uint32_t bucket_count,
-      int32_t flags,
-      const DescriptionPair descriptions[]);
-
-  static void InitializeBucketRanges(Sample minimum,
-                                     Sample maximum,
-                                     BucketRanges* ranges);
-
-  // Overridden from Histogram:
-  HistogramType GetHistogramType() const override;
-
- protected:
-  class Factory;
-
-  LinearHistogram(const char* name,
-                  Sample minimum,
-                  Sample maximum,
-                  const BucketRanges* ranges);
-
-  LinearHistogram(const char* name,
-                  Sample minimum,
-                  Sample maximum,
-                  const BucketRanges* ranges,
-                  const DelayedPersistentAllocation& counts,
-                  const DelayedPersistentAllocation& logged_counts,
-                  HistogramSamples::Metadata* meta,
-                  HistogramSamples::Metadata* logged_meta);
-
-  double GetBucketSize(Count current, uint32_t i) const override;
-
-  // If we have a description for a bucket, then return that.  Otherwise
-  // let parent class provide a (numeric) description.
-  const std::string GetAsciiBucketRange(uint32_t i) const override;
-
-  // Skip printing of name for numeric range if we have a name (and if this is
-  // an empty bucket).
-  bool PrintEmptyBucket(uint32_t index) const override;
-
- private:
-  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
-      base::PickleIterator* iter);
-  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
-
-  // For some ranges, we store a printable description of a bucket range.
-  // If there is no description, then GetAsciiBucketRange() uses parent class
-  // to provide a description.
-  typedef std::map<Sample, std::string> BucketDescriptionMap;
-  BucketDescriptionMap bucket_description_;
-
-  DISALLOW_COPY_AND_ASSIGN(LinearHistogram);
-};
-
-//------------------------------------------------------------------------------
-
-// ScaledLinearHistogram is a wrapper around a linear histogram that scales the
-// counts down by some factor. Remainder values are kept locally but lost when
-// uploaded or serialized. The integral counts are rounded up/down so should
-// average to the correct value when many reports are added.
-//
-// This is most useful when adding many counts at once via AddCount() that can
-// cause overflows of the 31-bit counters, usually with an enum as the value.
-class BASE_EXPORT ScaledLinearHistogram {
-  using AtomicCount = Histogram::AtomicCount;
-  using Sample = Histogram::Sample;
-
- public:
-  // Currently only works with "exact" linear histograms: minimum=1, maximum=N,
-  // and bucket_count=N+1.
-  ScaledLinearHistogram(const char* name,
-                        Sample minimum,
-                        Sample maximum,
-                        uint32_t bucket_count,
-                        int32_t scale,
-                        int32_t flags);
-
-  ~ScaledLinearHistogram();
-
-  // Like AddCount() but actually accumulates |count|/|scale| and increments
-  // the accumulated remainder by |count|%|scale|. An additional increment
-  // is done when the remainder has grown sufficiently large.
-  void AddScaledCount(Sample value, int count);
-
-  int32_t scale() const { return scale_; }
-  LinearHistogram* histogram() { return histogram_; }
-
- private:
-  // Pointer to the underlying histogram. Ownership of it remains with
-  // the statistics-recorder.
-  LinearHistogram* const histogram_;
-
-  // The scale factor of the sample counts.
-  const int32_t scale_;
-
-  // A vector of "remainder" counts indexed by bucket number. These values
-  // may be negative as the scaled count is actually bumped once the
-  // remainder is 1/2 way to the scale value (thus "rounding").
-  std::vector<AtomicCount> remainders_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScaledLinearHistogram);
-};
-
-//------------------------------------------------------------------------------
-
-// BooleanHistogram is a histogram for booleans.
-class BASE_EXPORT BooleanHistogram : public LinearHistogram {
- public:
-  static HistogramBase* FactoryGet(const std::string& name, int32_t flags);
-
-  // Overload of the above function that takes a const char* |name| param,
-  // to avoid code bloat from the std::string constructor being inlined into
-  // call sites.
-  static HistogramBase* FactoryGet(const char* name, int32_t flags);
-
-  // Create a histogram using data in persistent storage.
-  static std::unique_ptr<HistogramBase> PersistentCreate(
-      const char* name,
-      const BucketRanges* ranges,
-      const DelayedPersistentAllocation& counts,
-      const DelayedPersistentAllocation& logged_counts,
-      HistogramSamples::Metadata* meta,
-      HistogramSamples::Metadata* logged_meta);
-
-  HistogramType GetHistogramType() const override;
-
- protected:
-  class Factory;
-
- private:
-  BooleanHistogram(const char* name, const BucketRanges* ranges);
-  BooleanHistogram(const char* name,
-                   const BucketRanges* ranges,
-                   const DelayedPersistentAllocation& counts,
-                   const DelayedPersistentAllocation& logged_counts,
-                   HistogramSamples::Metadata* meta,
-                   HistogramSamples::Metadata* logged_meta);
-
-  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
-      base::PickleIterator* iter);
-  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
-
-  DISALLOW_COPY_AND_ASSIGN(BooleanHistogram);
-};
-
-//------------------------------------------------------------------------------
-
-// CustomHistogram is a histogram for a set of custom integers.
-class BASE_EXPORT CustomHistogram : public Histogram {
- public:
-  // |custom_ranges| contains a vector of limits on ranges. Each limit should be
-  // > 0 and < kSampleType_MAX. (Currently 0 is still accepted for backward
-  // compatibility). The limits can be unordered or contain duplication, but
-  // client should not depend on this.
-  static HistogramBase* FactoryGet(const std::string& name,
-                                   const std::vector<Sample>& custom_ranges,
-                                   int32_t flags);
-
-  // Overload of the above function that takes a const char* |name| param,
-  // to avoid code bloat from the std::string constructor being inlined into
-  // call sites.
-  static HistogramBase* FactoryGet(const char* name,
-                                   const std::vector<Sample>& custom_ranges,
-                                   int32_t flags);
-
-  // Create a histogram using data in persistent storage.
-  static std::unique_ptr<HistogramBase> PersistentCreate(
-      const char* name,
-      const BucketRanges* ranges,
-      const DelayedPersistentAllocation& counts,
-      const DelayedPersistentAllocation& logged_counts,
-      HistogramSamples::Metadata* meta,
-      HistogramSamples::Metadata* logged_meta);
-
-  // Overridden from Histogram:
-  HistogramType GetHistogramType() const override;
-
-  // Helper method for transforming an array of valid enumeration values
-  // to the std::vector<int> expected by UMA_HISTOGRAM_CUSTOM_ENUMERATION.
-  // This function ensures that a guard bucket exists right after any
-  // valid sample value (unless the next higher sample is also a valid value),
-  // so that invalid samples never fall into the same bucket as valid samples.
-  static std::vector<Sample> ArrayToCustomEnumRanges(
-      base::span<const Sample> values);
-
- protected:
-  class Factory;
-
-  CustomHistogram(const char* name, const BucketRanges* ranges);
-
-  CustomHistogram(const char* name,
-                  const BucketRanges* ranges,
-                  const DelayedPersistentAllocation& counts,
-                  const DelayedPersistentAllocation& logged_counts,
-                  HistogramSamples::Metadata* meta,
-                  HistogramSamples::Metadata* logged_meta);
-
-  // HistogramBase implementation:
-  void SerializeInfoImpl(base::Pickle* pickle) const override;
-
-  double GetBucketSize(Count current, uint32_t i) const override;
-
- private:
-  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
-      base::PickleIterator* iter);
-  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
-
-  static bool ValidateCustomRanges(const std::vector<Sample>& custom_ranges);
-
-  DISALLOW_COPY_AND_ASSIGN(CustomHistogram);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_HISTOGRAM_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram_base.h b/native/zucchini/vendor/libchrome/base/metrics/histogram_base.h
deleted file mode 100644
index f128ff2..0000000
--- a/native/zucchini/vendor/libchrome/base/metrics/histogram_base.h
+++ /dev/null
@@ -1,307 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_METRICS_HISTOGRAM_BASE_H_
-#define BASE_METRICS_HISTOGRAM_BASE_H_
-
-#include <limits.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-#include "base/time/time.h"
-
-namespace base {
-
-class DictionaryValue;
-class HistogramBase;
-class HistogramSamples;
-class ListValue;
-class Pickle;
-class PickleIterator;
-
-////////////////////////////////////////////////////////////////////////////////
-// This enum is used to facilitate deserialization of histograms from other
-// processes into the browser. If you create another class that inherits from
-// HistogramBase, add new histogram types and names below.
-
-enum HistogramType {
-  HISTOGRAM,
-  LINEAR_HISTOGRAM,
-  BOOLEAN_HISTOGRAM,
-  CUSTOM_HISTOGRAM,
-  SPARSE_HISTOGRAM,
-  DUMMY_HISTOGRAM,
-};
-
-// Controls the verbosity of the information when the histogram is serialized to
-// a JSON.
-// GENERATED_JAVA_ENUM_PACKAGE: org.chromium.base.metrics
-enum JSONVerbosityLevel {
-  // The histogram is completely serialized.
-  JSON_VERBOSITY_LEVEL_FULL,
-  // The bucket information is not serialized.
-  JSON_VERBOSITY_LEVEL_OMIT_BUCKETS,
-};
-
-std::string HistogramTypeToString(HistogramType type);
-
-// This enum is used for reporting how many histograms and of what types and
-// variations are being created. It has to be in the main .h file so it is
-// visible to files that define the various histogram types.
-enum HistogramReport {
-  // Count the number of reports created. The other counts divided by this
-  // number will give the average per run of the program.
-  HISTOGRAM_REPORT_CREATED = 0,
-
-  // Count the total number of histograms created. It is the limit against
-  // which all others are compared.
-  HISTOGRAM_REPORT_HISTOGRAM_CREATED = 1,
-
-  // Count the total number of histograms looked-up. It's better to cache
-  // the result of a single lookup rather than do it repeatedly.
-  HISTOGRAM_REPORT_HISTOGRAM_LOOKUP = 2,
-
-  // These count the individual histogram types. This must follow the order
-  // of HistogramType above.
-  HISTOGRAM_REPORT_TYPE_LOGARITHMIC = 3,
-  HISTOGRAM_REPORT_TYPE_LINEAR = 4,
-  HISTOGRAM_REPORT_TYPE_BOOLEAN = 5,
-  HISTOGRAM_REPORT_TYPE_CUSTOM = 6,
-  HISTOGRAM_REPORT_TYPE_SPARSE = 7,
-
-  // These indicate the individual flags that were set.
-  HISTOGRAM_REPORT_FLAG_UMA_TARGETED = 8,
-  HISTOGRAM_REPORT_FLAG_UMA_STABILITY = 9,
-  HISTOGRAM_REPORT_FLAG_PERSISTENT = 10,
-
-  // This must be last.
-  HISTOGRAM_REPORT_MAX = 11
-};
-
-// Create or find existing histogram that matches the pickled info.
-// Returns NULL if the pickled data has problems.
-BASE_EXPORT HistogramBase* DeserializeHistogramInfo(base::PickleIterator* iter);
-
-////////////////////////////////////////////////////////////////////////////////
-
-class BASE_EXPORT HistogramBase {
- public:
-  typedef int32_t Sample;                // Used for samples.
-  typedef subtle::Atomic32 AtomicCount;  // Used to count samples.
-  typedef int32_t Count;  // Used to manipulate counts in temporaries.
-
-  static const Sample kSampleType_MAX;  // INT_MAX
-
-  enum Flags {
-    kNoFlags = 0x0,
-
-    // Histogram should be UMA uploaded.
-    kUmaTargetedHistogramFlag = 0x1,
-
-    // Indicates that this is a stability histogram. This flag exists to specify
-    // which histograms should be included in the initial stability log. Please
-    // refer to |MetricsService::PrepareInitialStabilityLog|.
-    kUmaStabilityHistogramFlag = kUmaTargetedHistogramFlag | 0x2,
-
-    // Indicates that the histogram was pickled to be sent across an IPC
-    // Channel. If we observe this flag on a histogram being aggregated into
-    // after IPC, then we are running in a single process mode, and the
-    // aggregation should not take place (as we would be aggregating back into
-    // the source histogram!).
-    kIPCSerializationSourceFlag = 0x10,
-
-    // Indicates that a callback exists for when a new sample is recorded on
-    // this histogram. We store this as a flag with the histogram since
-    // histograms can be in performance critical code, and this allows us
-    // to shortcut looking up the callback if it doesn't exist.
-    kCallbackExists = 0x20,
-
-    // Indicates that the histogram is held in "persistent" memory and may
-    // be accessible between processes. This is only possible if such a
-    // memory segment has been created/attached, used to create a Persistent-
-    // MemoryAllocator, and that loaded into the Histogram module before this
-    // histogram is created.
-    kIsPersistent = 0x40,
-  };
-
-  // Histogram data inconsistency types.
-  enum Inconsistency : uint32_t {
-    NO_INCONSISTENCIES = 0x0,
-    RANGE_CHECKSUM_ERROR = 0x1,
-    BUCKET_ORDER_ERROR = 0x2,
-    COUNT_HIGH_ERROR = 0x4,
-    COUNT_LOW_ERROR = 0x8,
-
-    NEVER_EXCEEDED_VALUE = 0x10,
-  };
-
-  // Construct the base histogram. The name is not copied; it's up to the
-  // caller to ensure that it lives at least as long as this object.
-  explicit HistogramBase(const char* name);
-  virtual ~HistogramBase();
-
-  const char* histogram_name() const { return histogram_name_; }
-
-  // Compares |name| to the histogram name and triggers a DCHECK if they do not
-  // match. This is a helper function used by histogram macros, which results in
-  // in more compact machine code being generated by the macros.
-  virtual void CheckName(const StringPiece& name) const;
-
-  // Get a unique ID for this histogram's samples.
-  virtual uint64_t name_hash() const = 0;
-
-  // Operations with Flags enum.
-  int32_t flags() const { return subtle::NoBarrier_Load(&flags_); }
-  void SetFlags(int32_t flags);
-  void ClearFlags(int32_t flags);
-
-  virtual HistogramType GetHistogramType() const = 0;
-
-  // Whether the histogram has construction arguments as parameters specified.
-  // For histograms that don't have the concept of minimum, maximum or
-  // bucket_count, this function always returns false.
-  virtual bool HasConstructionArguments(
-      Sample expected_minimum,
-      Sample expected_maximum,
-      uint32_t expected_bucket_count) const = 0;
-
-  virtual void Add(Sample value) = 0;
-
-  // In Add function the |value| bucket is increased by one, but in some use
-  // cases we need to increase this value by an arbitrary integer. AddCount
-  // function increases the |value| bucket by |count|. |count| should be greater
-  // than or equal to 1.
-  virtual void AddCount(Sample value, int count) = 0;
-
-  // Similar to above but divides |count| by the |scale| amount. Probabilistic
-  // rounding is used to yield a reasonably accurate total when many samples
-  // are added. Methods for common cases of scales 1000 and 1024 are included.
-  // The ScaledLinearHistogram (which can also used be for enumerations) may be
-  // a better (and faster) solution.
-  void AddScaled(Sample value, int count, int scale);
-  void AddKilo(Sample value, int count);  // scale=1000
-  void AddKiB(Sample value, int count);   // scale=1024
-
-  // Convenient functions that call Add(Sample).
-  void AddTime(const TimeDelta& time) { AddTimeMillisecondsGranularity(time); }
-  void AddTimeMillisecondsGranularity(const TimeDelta& time);
-  // Note: AddTimeMicrosecondsGranularity() drops the report if this client
-  // doesn't have a high-resolution clock.
-  void AddTimeMicrosecondsGranularity(const TimeDelta& time);
-  void AddBoolean(bool value);
-
-  virtual void AddSamples(const HistogramSamples& samples) = 0;
-  virtual bool AddSamplesFromPickle(base::PickleIterator* iter) = 0;
-
-  // Serialize the histogram info into |pickle|.
-  // Note: This only serializes the construction arguments of the histogram, but
-  // does not serialize the samples.
-  void SerializeInfo(base::Pickle* pickle) const;
-
-  // Try to find out data corruption from histogram and the samples.
-  // The returned value is a combination of Inconsistency enum.
-  virtual uint32_t FindCorruption(const HistogramSamples& samples) const;
-
-  // Snapshot the current complete set of sample data.
-  // Override with atomic/locked snapshot if needed.
-  // NOTE: this data can overflow for long-running sessions. It should be
-  // handled with care and this method is recommended to be used only
-  // in about:histograms and test code.
-  virtual std::unique_ptr<HistogramSamples> SnapshotSamples() const = 0;
-
-  // Calculate the change (delta) in histogram counts since the previous call
-  // to this method. Each successive call will return only those counts
-  // changed since the last call.
-  virtual std::unique_ptr<HistogramSamples> SnapshotDelta() = 0;
-
-  // Calculate the change (delta) in histogram counts since the previous call
-  // to SnapshotDelta() but do so without modifying any internal data as to
-  // what was previous logged. After such a call, no further calls to this
-  // method or to SnapshotDelta() should be done as the result would include
-  // data previously returned. Because no internal data is changed, this call
-  // can be made on "const" histograms such as those with data held in
-  // read-only memory.
-  virtual std::unique_ptr<HistogramSamples> SnapshotFinalDelta() const = 0;
-
-  // The following methods provide graphical histogram displays.
-  virtual void WriteHTMLGraph(std::string* output) const = 0;
-  virtual void WriteAscii(std::string* output) const = 0;
-
-  // TODO(bcwhite): Remove this after https://crbug/836875.
-  virtual void ValidateHistogramContents() const;
-
-  // Produce a JSON representation of the histogram with |verbosity_level| as
-  // the serialization verbosity. This is implemented with the help of
-  // GetParameters and GetCountAndBucketData; overwrite them to customize the
-  // output.
-  void WriteJSON(std::string* output, JSONVerbosityLevel verbosity_level) const;
-
- protected:
-  enum ReportActivity { HISTOGRAM_CREATED, HISTOGRAM_LOOKUP };
-
-  // Subclasses should implement this function to make SerializeInfo work.
-  virtual void SerializeInfoImpl(base::Pickle* pickle) const = 0;
-
-  // Writes information about the construction parameters in |params|.
-  virtual void GetParameters(DictionaryValue* params) const = 0;
-
-  // Writes information about the current (non-empty) buckets and their sample
-  // counts to |buckets|, the total sample count to |count| and the total sum
-  // to |sum|.
-  virtual void GetCountAndBucketData(Count* count,
-                                     int64_t* sum,
-                                     ListValue* buckets) const = 0;
-
-  //// Produce actual graph (set of blank vs non blank char's) for a bucket.
-  void WriteAsciiBucketGraph(double current_size,
-                             double max_size,
-                             std::string* output) const;
-
-  // Return a string description of what goes in a given bucket.
-  const std::string GetSimpleAsciiBucketRange(Sample sample) const;
-
-  // Write textual description of the bucket contents (relative to histogram).
-  // Output is the count in the buckets, as well as the percentage.
-  void WriteAsciiBucketValue(Count current,
-                             double scaled_sum,
-                             std::string* output) const;
-
-  // Retrieves the callback for this histogram, if one exists, and runs it
-  // passing |sample| as the parameter.
-  void FindAndRunCallback(Sample sample) const;
-
-  // Gets a permanent string that can be used for histogram objects when the
-  // original is not a code constant or held in persistent memory.
-  static const char* GetPermanentName(const std::string& name);
-
- private:
-  friend class HistogramBaseTest;
-
-  // A pointer to permanent storage where the histogram name is held. This can
-  // be code space or the output of GetPermanentName() or any other storage
-  // that is known to never change. This is not StringPiece because (a) char*
-  // is 1/2 the size and (b) StringPiece transparently casts from std::string
-  // which can easily lead to a pointer to non-permanent space.
-  // For persistent histograms, this will simply point into the persistent
-  // memory segment, thus avoiding duplication. For heap histograms, the
-  // GetPermanentName method will create the necessary copy.
-  const char* const histogram_name_;
-
-  // Additional information about the histogram.
-  AtomicCount flags_;
-
-  DISALLOW_COPY_AND_ASSIGN(HistogramBase);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_HISTOGRAM_BASE_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram_functions.h b/native/zucchini/vendor/libchrome/base/metrics/histogram_functions.h
deleted file mode 100644
index 60c0057..0000000
--- a/native/zucchini/vendor/libchrome/base/metrics/histogram_functions.h
+++ /dev/null
@@ -1,158 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_METRICS_HISTOGRAM_FUNCTIONS_H_
-#define BASE_METRICS_HISTOGRAM_FUNCTIONS_H_
-
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_base.h"
-#include "base/time/time.h"
-
-// Functions for recording metrics.
-//
-// For best practices on deciding when to emit to a histogram and what form
-// the histogram should take, see
-// https://chromium.googlesource.com/chromium/src.git/+/HEAD/tools/metrics/histograms/README.md
-
-// Functions for recording UMA histograms. These can be used for cases
-// when the histogram name is generated at runtime. The functionality is
-// equivalent to macros defined in histogram_macros.h but allowing non-constant
-// histogram names. These functions are slower compared to their macro
-// equivalent because the histogram objects are not cached between calls.
-// So, these shouldn't be used in performance critical code.
-namespace base {
-
-// For histograms with linear buckets.
-// Used for capturing integer data with a linear bucketing scheme. This can be
-// used when you want the exact value of some small numeric count, with a max of
-// 100 or less. If you need to capture a range of greater than 100, we recommend
-// the use of the COUNT histograms below.
-// Sample usage:
-//   base::UmaHistogramExactLinear("Histogram.Linear", some_value, 10);
-BASE_EXPORT void UmaHistogramExactLinear(const std::string& name,
-                                         int sample,
-                                         int value_max);
-
-// For adding a sample to an enumerated histogram.
-// Sample usage:
-//   // These values are persisted to logs. Entries should not be renumbered and
-//   // numeric values should never be reused.
-//   enum class MyEnum {
-//     FIRST_VALUE = 0,
-//     SECOND_VALUE = 1,
-//     ...
-//     FINAL_VALUE = N,
-//     COUNT
-//   };
-//   base::UmaHistogramEnumeration("My.Enumeration",
-//                                 MyEnum::SOME_VALUE, MyEnum::COUNT);
-//
-// Note: The value in |sample| must be strictly less than |enum_size|.
-template <typename T>
-void UmaHistogramEnumeration(const std::string& name, T sample, T enum_size) {
-  static_assert(std::is_enum<T>::value,
-                "Non enum passed to UmaHistogramEnumeration");
-  DCHECK_LE(static_cast<uintmax_t>(enum_size), static_cast<uintmax_t>(INT_MAX));
-  DCHECK_LT(static_cast<uintmax_t>(sample), static_cast<uintmax_t>(enum_size));
-  return UmaHistogramExactLinear(name, static_cast<int>(sample),
-                                 static_cast<int>(enum_size));
-}
-
-// Same as above, but uses T::kMaxValue as the inclusive maximum value of the
-// enum.
-template <typename T>
-void UmaHistogramEnumeration(const std::string& name, T sample) {
-  static_assert(std::is_enum<T>::value,
-                "Non enum passed to UmaHistogramEnumeration");
-  DCHECK_LE(static_cast<uintmax_t>(T::kMaxValue),
-            static_cast<uintmax_t>(INT_MAX) - 1);
-  DCHECK_LE(static_cast<uintmax_t>(sample),
-            static_cast<uintmax_t>(T::kMaxValue));
-  return UmaHistogramExactLinear(name, static_cast<int>(sample),
-                                 static_cast<int>(T::kMaxValue) + 1);
-}
-
-// For adding boolean sample to histogram.
-// Sample usage:
-//   base::UmaHistogramBoolean("My.Boolean", true)
-BASE_EXPORT void UmaHistogramBoolean(const std::string& name, bool sample);
-
-// For adding histogram with percent.
-// Percents are integer between 1 and 100.
-// Sample usage:
-//   base::UmaHistogramPercentage("My.Percent", 69)
-BASE_EXPORT void UmaHistogramPercentage(const std::string& name, int percent);
-
-// For adding counts histogram.
-// Sample usage:
-//   base::UmaHistogramCustomCounts("My.Counts", some_value, 1, 600, 30)
-BASE_EXPORT void UmaHistogramCustomCounts(const std::string& name,
-                                          int sample,
-                                          int min,
-                                          int max,
-                                          int buckets);
-
-// Counts specialization for maximum counts 100, 1000, 10k, 100k, 1M and 10M.
-BASE_EXPORT void UmaHistogramCounts100(const std::string& name, int sample);
-BASE_EXPORT void UmaHistogramCounts1000(const std::string& name, int sample);
-BASE_EXPORT void UmaHistogramCounts10000(const std::string& name, int sample);
-BASE_EXPORT void UmaHistogramCounts100000(const std::string& name, int sample);
-BASE_EXPORT void UmaHistogramCounts1M(const std::string& name, int sample);
-BASE_EXPORT void UmaHistogramCounts10M(const std::string& name, int sample);
-
-// For histograms storing times.
-BASE_EXPORT void UmaHistogramCustomTimes(const std::string& name,
-                                         TimeDelta sample,
-                                         TimeDelta min,
-                                         TimeDelta max,
-                                         int buckets);
-// For short timings from 1 ms up to 10 seconds (50 buckets).
-BASE_EXPORT void UmaHistogramTimes(const std::string& name, TimeDelta sample);
-// For medium timings up to 3 minutes (50 buckets).
-BASE_EXPORT void UmaHistogramMediumTimes(const std::string& name,
-                                         TimeDelta sample);
-// For time intervals up to 1 hr (50 buckets).
-BASE_EXPORT void UmaHistogramLongTimes(const std::string& name,
-                                       TimeDelta sample);
-
-// For recording memory related histograms.
-// Used to measure common KB-granularity memory stats. Range is up to 500M.
-BASE_EXPORT void UmaHistogramMemoryKB(const std::string& name, int sample);
-// Used to measure common MB-granularity memory stats. Range is up to ~1G.
-BASE_EXPORT void UmaHistogramMemoryMB(const std::string& name, int sample);
-// Used to measure common MB-granularity memory stats. Range is up to ~64G.
-BASE_EXPORT void UmaHistogramMemoryLargeMB(const std::string& name, int sample);
-
-// For recording sparse histograms.
-// The |sample| can be a negative or non-negative number.
-//
-// Sparse histograms are well suited for recording counts of exact sample values
-// that are sparsely distributed over a relatively large range, in cases where
-// ultra-fast performance is not critical. For instance, Sqlite.Version.* are
-// sparse because for any given database, there's going to be exactly one
-// version logged.
-//
-// Performance:
-// ------------
-// Sparse histograms are typically more memory-efficient but less time-efficient
-// than other histograms. Essentially, they sparse histograms use a map rather
-// than a vector for their backing storage; they also require lock acquisition
-// to increment a sample, whereas other histogram do not. Hence, each increment
-// operation is a bit slower than for other histograms. But, if the data is
-// sparse, then they use less memory client-side, because they allocate buckets
-// on demand rather than preallocating.
-//
-// Data size:
-// ----------
-// Note that server-side, we still need to load all buckets, across all users,
-// at once. Thus, please avoid exploding such histograms, i.e. uploading many
-// many distinct values to the server (across all users). Concretely, keep the
-// number of distinct values <= 100 ideally, definitely <= 1000. If you have no
-// guarantees on the range of your data, use clamping, e.g.:
-//   UmaHistogramSparse("MyHistogram", ClampToRange(value, 0, 200));
-BASE_EXPORT void UmaHistogramSparse(const std::string& name, int sample);
-
-}  // namespace base
-
-#endif  // BASE_METRICS_HISTOGRAM_FUNCTIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram_macros.h b/native/zucchini/vendor/libchrome/base/metrics/histogram_macros.h
deleted file mode 100644
index 93bd4bd..0000000
--- a/native/zucchini/vendor/libchrome/base/metrics/histogram_macros.h
+++ /dev/null
@@ -1,382 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_METRICS_HISTOGRAM_MACROS_H_
-#define BASE_METRICS_HISTOGRAM_MACROS_H_
-
-#include "base/macros.h"
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_macros_internal.h"
-#include "base/metrics/histogram_macros_local.h"
-#include "base/time/time.h"
-
-
-// Macros for efficient use of histograms.
-//
-// For best practices on deciding when to emit to a histogram and what form
-// the histogram should take, see
-// https://chromium.googlesource.com/chromium/src.git/+/HEAD/tools/metrics/histograms/README.md
-
-// TODO(rkaplow): Link to proper documentation on metric creation once we have
-// it in a good state.
-
-// All of these macros must be called with |name| as a runtime constant - it
-// doesn't have to literally be a constant, but it must be the same string on
-// all calls from a particular call site. If this rule is violated, it is
-// possible the data will be written to the wrong histogram.
-
-//------------------------------------------------------------------------------
-// Enumeration histograms.
-
-// These macros create histograms for enumerated data. Ideally, the data should
-// be of the form of "event occurs, log the result". We recommended not putting
-// related but not directly connected data as enums within the same histogram.
-// You should be defining an associated Enum, and the input sample should be
-// an element of the Enum.
-// All of these macros must be called with |name| as a runtime constant.
-
-// The first variant of UMA_HISTOGRAM_ENUMERATION accepts two arguments: the
-// histogram name and the enum sample. It deduces the correct boundary value to
-// use by looking for an enumerator with the name kMaxValue. kMaxValue should
-// share the value of the highest enumerator: this avoids switch statements
-// having to handle a sentinel no-op value.
-//
-// Sample usage:
-//   // These values are persisted to logs. Entries should not be renumbered and
-//   // numeric values should never be reused.
-//   enum class MyEnum {
-//     kFirstValue = 0,
-//     kSecondValue = 1,
-//     ...
-//     kFinalValue = N,
-//     kMaxValue = kFinalValue,
-//   };
-//   UMA_HISTOGRAM_ENUMERATION("My.Enumeration", MyEnum::kSomeValue);
-//
-// The second variant requires three arguments: the first two are the same as
-// before, and the third argument is the enum boundary: this must be strictly
-// greater than any other enumerator that will be sampled.
-//
-// Sample usage:
-//   // These values are persisted to logs. Entries should not be renumbered and
-//   // numeric values should never be reused.
-//   enum class MyEnum {
-//     FIRST_VALUE = 0,
-//     SECOND_VALUE = 1,
-//     ...
-//     FINAL_VALUE = N,
-//     COUNT
-//   };
-//   UMA_HISTOGRAM_ENUMERATION("My.Enumeration",
-//                             MyEnum::SOME_VALUE, MyEnum::COUNT);
-//
-// Note: If the enum is used in a switch, it is often desirable to avoid writing
-// a case statement to handle an unused sentinel value (i.e. COUNT in the above
-// example). For scoped enums, this is awkward since it requires casting the
-// enum to an arithmetic type and adding one. Instead, prefer the two argument
-// version of the macro which automatically deduces the boundary from kMaxValue.
-#define UMA_HISTOGRAM_ENUMERATION(name, ...)                            \
-  CR_EXPAND_ARG(INTERNAL_UMA_HISTOGRAM_ENUMERATION_GET_MACRO(           \
-      __VA_ARGS__, INTERNAL_UMA_HISTOGRAM_ENUMERATION_SPECIFY_BOUNDARY, \
-      INTERNAL_UMA_HISTOGRAM_ENUMERATION_DEDUCE_BOUNDARY)(              \
-      name, __VA_ARGS__, base::HistogramBase::kUmaTargetedHistogramFlag))
-
-// As above but "scaled" count to avoid overflows caused by increments of
-// large amounts. See UMA_HISTOGRAM_SCALED_EXACT_LINEAR for more information.
-// Only the new format utilizing an internal kMaxValue is supported.
-// It'll be necessary to #include "base/lazy_instance.h" to use this macro.
-#define UMA_HISTOGRAM_SCALED_ENUMERATION(name, sample, count, scale) \
-  INTERNAL_HISTOGRAM_SCALED_ENUMERATION_WITH_FLAG(                   \
-      name, sample, count, scale,                                    \
-      base::HistogramBase::kUmaTargetedHistogramFlag)
-
-// Histogram for boolean values.
-
-// Sample usage:
-//   UMA_HISTOGRAM_BOOLEAN("Histogram.Boolean", bool);
-#define UMA_HISTOGRAM_BOOLEAN(name, sample)                                    \
-    STATIC_HISTOGRAM_POINTER_BLOCK(name, AddBoolean(sample),                   \
-        base::BooleanHistogram::FactoryGet(name,                               \
-            base::HistogramBase::kUmaTargetedHistogramFlag))
-
-//------------------------------------------------------------------------------
-// Linear histograms.
-
-// All of these macros must be called with |name| as a runtime constant.
-
-// Used for capturing integer data with a linear bucketing scheme. This can be
-// used when you want the exact value of some small numeric count, with a max of
-// 100 or less. If you need to capture a range of greater than 100, we recommend
-// the use of the COUNT histograms below.
-
-// Sample usage:
-//   UMA_HISTOGRAM_EXACT_LINEAR("Histogram.Linear", count, 10);
-#define UMA_HISTOGRAM_EXACT_LINEAR(name, sample, value_max) \
-  INTERNAL_HISTOGRAM_EXACT_LINEAR_WITH_FLAG(                \
-      name, sample, value_max, base::HistogramBase::kUmaTargetedHistogramFlag)
-
-// Used for capturing basic percentages. This will be 100 buckets of size 1.
-
-// Sample usage:
-//   UMA_HISTOGRAM_PERCENTAGE("Histogram.Percent", percent_as_int);
-#define UMA_HISTOGRAM_PERCENTAGE(name, percent_as_int) \
-  UMA_HISTOGRAM_EXACT_LINEAR(name, percent_as_int, 101)
-
-//------------------------------------------------------------------------------
-// Scaled Linear histograms.
-
-// These take |count| and |scale| parameters to allow cumulative reporting of
-// large numbers. Only the scaled count is reported but the reminder is kept so
-// multiple calls will accumulate correctly.  Only "exact linear" is supported.
-// It'll be necessary to #include "base/lazy_instance.h" to use this macro.
-
-#define UMA_HISTOGRAM_SCALED_EXACT_LINEAR(name, sample, count, value_max, \
-                                          scale)                          \
-  INTERNAL_HISTOGRAM_SCALED_EXACT_LINEAR_WITH_FLAG(                       \
-      name, sample, count, value_max, scale,                              \
-      base::HistogramBase::kUmaTargetedHistogramFlag)
-
-//------------------------------------------------------------------------------
-// Count histograms. These are used for collecting numeric data. Note that we
-// have macros for more specialized use cases below (memory, time, percentages).
-
-// The number suffixes here refer to the max size of the sample, i.e. COUNT_1000
-// will be able to collect samples of counts up to 1000. The default number of
-// buckets in all default macros is 50. We recommend erring on the side of too
-// large a range versus too short a range.
-// These macros default to exponential histograms - i.e. the lengths of the
-// bucket ranges exponentially increase as the sample range increases.
-// These should *not* be used if you are interested in exact counts, i.e. a
-// bucket range of 1. In these cases, you should use the ENUMERATION macros
-// defined later. These should also not be used to capture the number of some
-// event, i.e. "button X was clicked N times". In this cases, an enum should be
-// used, ideally with an appropriate baseline enum entry included.
-// All of these macros must be called with |name| as a runtime constant.
-
-// Sample usage:
-//   UMA_HISTOGRAM_COUNTS_1M("My.Histogram", sample);
-
-#define UMA_HISTOGRAM_COUNTS_100(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(    \
-    name, sample, 1, 100, 50)
-
-#define UMA_HISTOGRAM_COUNTS_1000(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(   \
-    name, sample, 1, 1000, 50)
-
-#define UMA_HISTOGRAM_COUNTS_10000(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(  \
-    name, sample, 1, 10000, 50)
-
-#define UMA_HISTOGRAM_COUNTS_100000(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS( \
-    name, sample, 1, 100000, 50)
-
-#define UMA_HISTOGRAM_COUNTS_1M(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(     \
-    name, sample, 1, 1000000, 50)
-
-#define UMA_HISTOGRAM_COUNTS_10M(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(    \
-    name, sample, 1, 10000000, 50)
-
-// This can be used when the default ranges are not sufficient. This macro lets
-// the metric developer customize the min and max of the sampled range, as well
-// as the number of buckets recorded.
-// Any data outside the range here will be put in underflow and overflow
-// buckets. Min values should be >=1 as emitted 0s will still go into the
-// underflow bucket.
-
-// Sample usage:
-//   UMA_HISTOGRAM_CUSTOM_COUNTS("My.Histogram", 1, 100000000, 100);
-#define UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count)      \
-    INTERNAL_HISTOGRAM_CUSTOM_COUNTS_WITH_FLAG(                                \
-        name, sample, min, max, bucket_count,                                  \
-        base::HistogramBase::kUmaTargetedHistogramFlag)
-
-//------------------------------------------------------------------------------
-// Timing histograms. These are used for collecting timing data (generally
-// latencies).
-
-// These macros create exponentially sized histograms (lengths of the bucket
-// ranges exponentially increase as the sample range increases). The input
-// sample is a base::TimeDelta. The output data is measured in ms granularity.
-// All of these macros must be called with |name| as a runtime constant.
-
-// Sample usage:
-//   UMA_HISTOGRAM_TIMES("My.Timing.Histogram", time_delta);
-
-// Short timings - up to 10 seconds. For high-resolution (microseconds) timings,
-// see UMA_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES.
-#define UMA_HISTOGRAM_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES(          \
-    name, sample, base::TimeDelta::FromMilliseconds(1),                        \
-    base::TimeDelta::FromSeconds(10), 50)
-
-// Medium timings - up to 3 minutes. Note this starts at 10ms (no good reason,
-// but not worth changing).
-#define UMA_HISTOGRAM_MEDIUM_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES(   \
-    name, sample, base::TimeDelta::FromMilliseconds(10),                       \
-    base::TimeDelta::FromMinutes(3), 50)
-
-// Long timings - up to an hour.
-#define UMA_HISTOGRAM_LONG_TIMES(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES(     \
-    name, sample, base::TimeDelta::FromMilliseconds(1),                        \
-    base::TimeDelta::FromHours(1), 50)
-
-// Long timings with higher granularity - up to an hour with 100 buckets.
-#define UMA_HISTOGRAM_LONG_TIMES_100(name, sample) UMA_HISTOGRAM_CUSTOM_TIMES( \
-    name, sample, base::TimeDelta::FromMilliseconds(1),                        \
-    base::TimeDelta::FromHours(1), 100)
-
-// This can be used when the default ranges are not sufficient. This macro lets
-// the metric developer customize the min and max of the sampled range, as well
-// as the number of buckets recorded.
-
-// Sample usage:
-//   UMA_HISTOGRAM_CUSTOM_TIMES("Very.Long.Timing.Histogram", time_delta,
-//       base::TimeDelta::FromSeconds(1), base::TimeDelta::FromDays(1), 100);
-#define UMA_HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) \
-  STATIC_HISTOGRAM_POINTER_BLOCK(                                        \
-      name, AddTimeMillisecondsGranularity(sample),                      \
-      base::Histogram::FactoryTimeGet(                                   \
-          name, min, max, bucket_count,                                  \
-          base::HistogramBase::kUmaTargetedHistogramFlag))
-
-// Same as UMA_HISTOGRAM_CUSTOM_TIMES but reports |sample| in microseconds,
-// dropping the report if this client doesn't have a high-resolution clock.
-//
-// Note: dropping reports on clients with low-resolution clocks means these
-// reports will be biased to a portion of the population on Windows. See
-// Windows.HasHighResolutionTimeTicks for the affected sample.
-//
-// Sample usage:
-//  UMA_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(
-//      "High.Resolution.TimingMicroseconds.Histogram", time_delta,
-//      base::TimeDelta::FromMicroseconds(1),
-//      base::TimeDelta::FromMilliseconds(10), 100);
-#define UMA_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(name, sample, min, max, \
-                                                bucket_count)           \
-  STATIC_HISTOGRAM_POINTER_BLOCK(                                       \
-      name, AddTimeMicrosecondsGranularity(sample),                     \
-      base::Histogram::FactoryMicrosecondsTimeGet(                      \
-          name, min, max, bucket_count,                                 \
-          base::HistogramBase::kUmaTargetedHistogramFlag))
-
-// Scoped class which logs its time on this earth as a UMA statistic. This is
-// recommended for when you want a histogram which measures the time it takes
-// for a method to execute. This measures up to 10 seconds. It uses
-// UMA_HISTOGRAM_TIMES under the hood.
-
-// Sample usage:
-//   void Function() {
-//     SCOPED_UMA_HISTOGRAM_TIMER("Component.FunctionTime");
-//     ...
-//   }
-#define SCOPED_UMA_HISTOGRAM_TIMER(name)                                       \
-  INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_EXPANDER(name, false, __COUNTER__)
-
-// Similar scoped histogram timer, but this uses UMA_HISTOGRAM_LONG_TIMES_100,
-// which measures up to an hour, and uses 100 buckets. This is more expensive
-// to store, so only use if this often takes >10 seconds.
-#define SCOPED_UMA_HISTOGRAM_LONG_TIMER(name)                                  \
-  INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_EXPANDER(name, true, __COUNTER__)
-
-
-//------------------------------------------------------------------------------
-// Memory histograms.
-
-// These macros create exponentially sized histograms (lengths of the bucket
-// ranges exponentially increase as the sample range increases). The input
-// sample must be a number measured in kilobytes.
-// All of these macros must be called with |name| as a runtime constant.
-
-// Sample usage:
-//   UMA_HISTOGRAM_MEMORY_KB("My.Memory.Histogram", memory_in_kb);
-
-// Used to measure common KB-granularity memory stats. Range is up to 500000KB -
-// approximately 500M.
-#define UMA_HISTOGRAM_MEMORY_KB(name, sample)                                  \
-    UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1000, 500000, 50)
-
-// Used to measure common MB-granularity memory stats. Range is up to ~64G.
-#define UMA_HISTOGRAM_MEMORY_LARGE_MB(name, sample)                            \
-    UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 64000, 100)
-
-
-//------------------------------------------------------------------------------
-// Stability-specific histograms.
-
-// Histograms logged in as stability histograms will be included in the initial
-// stability log. See comments by declaration of
-// MetricsService::PrepareInitialStabilityLog().
-// All of these macros must be called with |name| as a runtime constant.
-
-// For details on usage, see the documentation on the non-stability equivalents.
-
-#define UMA_STABILITY_HISTOGRAM_COUNTS_100(name, sample)                       \
-    UMA_STABILITY_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 100, 50)
-
-#define UMA_STABILITY_HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max,          \
-                                              bucket_count)                    \
-    INTERNAL_HISTOGRAM_CUSTOM_COUNTS_WITH_FLAG(                                \
-        name, sample, min, max, bucket_count,                                  \
-        base::HistogramBase::kUmaStabilityHistogramFlag)
-
-#define UMA_STABILITY_HISTOGRAM_ENUMERATION(name, sample, enum_max)            \
-    INTERNAL_HISTOGRAM_ENUMERATION_WITH_FLAG(                                  \
-        name, sample, enum_max,                                                \
-        base::HistogramBase::kUmaStabilityHistogramFlag)
-
-//------------------------------------------------------------------------------
-// Histogram instantiation helpers.
-
-// Support a collection of histograms, perhaps one for each entry in an
-// enumeration. This macro manages a block of pointers, adding to a specific
-// one by its index.
-//
-// A typical instantiation looks something like this:
-//  STATIC_HISTOGRAM_POINTER_GROUP(
-//      GetHistogramNameForIndex(histogram_index),
-//      histogram_index, MAXIMUM_HISTOGRAM_INDEX, Add(some_delta),
-//      base::Histogram::FactoryGet(
-//          GetHistogramNameForIndex(histogram_index),
-//          MINIMUM_SAMPLE, MAXIMUM_SAMPLE, BUCKET_COUNT,
-//          base::HistogramBase::kUmaTargetedHistogramFlag));
-//
-// Though it seems inefficient to generate the name twice, the first
-// instance will be used only for DCHECK builds and the second will
-// execute only during the first access to the given index, after which
-// the pointer is cached and the name never needed again.
-#define STATIC_HISTOGRAM_POINTER_GROUP(constant_histogram_name, index,        \
-                                       constant_maximum,                      \
-                                       histogram_add_method_invocation,       \
-                                       histogram_factory_get_invocation)      \
-  do {                                                                        \
-    static base::subtle::AtomicWord atomic_histograms[constant_maximum];      \
-    DCHECK_LE(0, index);                                                      \
-    DCHECK_LT(index, constant_maximum);                                       \
-    HISTOGRAM_POINTER_USE(&atomic_histograms[index], constant_histogram_name, \
-                          histogram_add_method_invocation,                    \
-                          histogram_factory_get_invocation);                  \
-  } while (0)
-
-//------------------------------------------------------------------------------
-// Deprecated histogram macros. Not recommended for current use.
-
-// Legacy name for UMA_HISTOGRAM_COUNTS_1M. Suggest using explicit naming
-// and not using this macro going forward.
-#define UMA_HISTOGRAM_COUNTS(name, sample) UMA_HISTOGRAM_CUSTOM_COUNTS(        \
-    name, sample, 1, 1000000, 50)
-
-// MB-granularity memory metric. This has a short max (1G).
-#define UMA_HISTOGRAM_MEMORY_MB(name, sample)                                  \
-    UMA_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 1000, 50)
-
-// For an enum with customized range. In general, sparse histograms should be
-// used instead.
-// Samples should be one of the std::vector<int> list provided via
-// |custom_ranges|. See comments above CustomRanges::FactoryGet about the
-// requirement of |custom_ranges|. You can use the helper function
-// CustomHistogram::ArrayToCustomEnumRanges to transform a C-style array of
-// valid sample values to a std::vector<int>.
-#define UMA_HISTOGRAM_CUSTOM_ENUMERATION(name, sample, custom_ranges)          \
-    STATIC_HISTOGRAM_POINTER_BLOCK(name, Add(sample),                          \
-        base::CustomHistogram::FactoryGet(name, custom_ranges,                 \
-            base::HistogramBase::kUmaTargetedHistogramFlag))
-
-#endif  // BASE_METRICS_HISTOGRAM_MACROS_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram_macros_internal.h b/native/zucchini/vendor/libchrome/base/metrics/histogram_macros_internal.h
deleted file mode 100644
index cc7c76a..0000000
--- a/native/zucchini/vendor/libchrome/base/metrics/histogram_macros_internal.h
+++ /dev/null
@@ -1,268 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_METRICS_HISTOGRAM_MACROS_INTERNAL_H_
-#define BASE_METRICS_HISTOGRAM_MACROS_INTERNAL_H_
-
-#include <stdint.h>
-
-#include <limits>
-#include <type_traits>
-
-#include "base/atomicops.h"
-#include "base/logging.h"
-#include "base/metrics/histogram.h"
-#include "base/metrics/sparse_histogram.h"
-#include "base/time/time.h"
-
-// This is for macros and helpers internal to base/metrics. They should not be
-// used outside of this directory. For writing to UMA histograms, see
-// histogram_macros.h.
-
-namespace base {
-namespace internal {
-
-// Helper traits for deducing the boundary value for enums.
-template <typename Enum, typename SFINAE = void>
-struct EnumSizeTraits {
-  static constexpr Enum Count() {
-    static_assert(
-        sizeof(Enum) == 0,
-        "enumerator must define kMaxValue enumerator to use this macro!");
-    return Enum();
-  }
-};
-
-// Since the UMA histogram macros expect a value one larger than the max defined
-// enumerator value, add one.
-template <typename Enum>
-struct EnumSizeTraits<
-    Enum,
-    std::enable_if_t<std::is_enum<decltype(Enum::kMaxValue)>::value>> {
-  static constexpr Enum Count() {
-    return static_cast<Enum>(
-        static_cast<std::underlying_type_t<Enum>>(Enum::kMaxValue) + 1);
-  }
-};
-
-}  // namespace internal
-}  // namespace base
-
-// TODO(rkaplow): Improve commenting of these methods.
-//------------------------------------------------------------------------------
-// Histograms are often put in areas where they are called many many times, and
-// performance is critical.  As a result, they are designed to have a very low
-// recurring cost of executing (adding additional samples). Toward that end,
-// the macros declare a static pointer to the histogram in question, and only
-// take a "slow path" to construct (or find) the histogram on the first run
-// through the macro. We leak the histograms at shutdown time so that we don't
-// have to validate using the pointers at any time during the running of the
-// process.
-
-// In some cases (integration into 3rd party code), it's useful to separate the
-// definition of |atomic_histogram_pointer| from its use. To achieve this we
-// define HISTOGRAM_POINTER_USE, which uses an |atomic_histogram_pointer|, and
-// STATIC_HISTOGRAM_POINTER_BLOCK, which defines an |atomic_histogram_pointer|
-// and forwards to HISTOGRAM_POINTER_USE.
-#define HISTOGRAM_POINTER_USE(atomic_histogram_pointer,                        \
-                              constant_histogram_name,                         \
-                              histogram_add_method_invocation,                 \
-                              histogram_factory_get_invocation)                \
-  do {                                                                         \
-    /*                                                                         \
-     * Acquire_Load() ensures that we acquire visibility to the                \
-     * pointed-to data in the histogram.                                       \
-     */                                                                        \
-    base::HistogramBase* histogram_pointer(                                    \
-        reinterpret_cast<base::HistogramBase*>(                                \
-            base::subtle::Acquire_Load(atomic_histogram_pointer)));            \
-    if (!histogram_pointer) {                                                  \
-      /*                                                                       \
-       * This is the slow path, which will construct OR find the               \
-       * matching histogram.  histogram_factory_get_invocation includes        \
-       * locks on a global histogram name map and is completely thread         \
-       * safe.                                                                 \
-       */                                                                      \
-      histogram_pointer = histogram_factory_get_invocation;                    \
-                                                                               \
-      /*                                                                       \
-       * Use Release_Store to ensure that the histogram data is made           \
-       * available globally before we make the pointer visible. Several        \
-       * threads may perform this store, but the same value will be            \
-       * stored in all cases (for a given named/spec'ed histogram).            \
-       * We could do this without any barrier, since FactoryGet entered        \
-       * and exited a lock after construction, but this barrier makes          \
-       * things clear.                                                         \
-       */                                                                      \
-      base::subtle::Release_Store(                                             \
-          atomic_histogram_pointer,                                            \
-          reinterpret_cast<base::subtle::AtomicWord>(histogram_pointer));      \
-    }                                                                          \
-    if (DCHECK_IS_ON())                                                        \
-      histogram_pointer->CheckName(constant_histogram_name);                   \
-    histogram_pointer->histogram_add_method_invocation;                        \
-  } while (0)
-
-// This is a helper macro used by other macros and shouldn't be used directly.
-// Defines the static |atomic_histogram_pointer| and forwards to
-// HISTOGRAM_POINTER_USE.
-#define STATIC_HISTOGRAM_POINTER_BLOCK(constant_histogram_name,                \
-                                       histogram_add_method_invocation,        \
-                                       histogram_factory_get_invocation)       \
-  do {                                                                         \
-    /*                                                                         \
-     * The pointer's presence indicates that the initialization is complete.   \
-     * Initialization is idempotent, so it can safely be atomically repeated.  \
-     */                                                                        \
-    static base::subtle::AtomicWord atomic_histogram_pointer = 0;              \
-    HISTOGRAM_POINTER_USE(&atomic_histogram_pointer, constant_histogram_name,  \
-                          histogram_add_method_invocation,                     \
-                          histogram_factory_get_invocation);                   \
-  } while (0)
-
-// This is a helper macro used by other macros and shouldn't be used directly.
-#define INTERNAL_HISTOGRAM_CUSTOM_COUNTS_WITH_FLAG(name, sample, min, max,     \
-                                                   bucket_count, flag)         \
-    STATIC_HISTOGRAM_POINTER_BLOCK(                                            \
-        name, Add(sample),                                                     \
-        base::Histogram::FactoryGet(name, min, max, bucket_count, flag))
-
-// This is a helper macro used by other macros and shouldn't be used directly.
-// The bucketing scheme is linear with a bucket size of 1. For N items,
-// recording values in the range [0, N - 1] creates a linear histogram with N +
-// 1 buckets:
-//   [0, 1), [1, 2), ..., [N - 1, N)
-// and an overflow bucket [N, infinity).
-//
-// Code should never emit to the overflow bucket; only to the other N buckets.
-// This allows future versions of Chrome to safely increase the boundary size.
-// Otherwise, the histogram would have [N - 1, infinity) as its overflow bucket,
-// and so the maximal value (N - 1) would be emitted to this overflow bucket.
-// But, if an additional value were later added, the bucket label for
-// the value (N - 1) would change to [N - 1, N), which would result in different
-// versions of Chrome using different bucket labels for identical data.
-#define INTERNAL_HISTOGRAM_EXACT_LINEAR_WITH_FLAG(name, sample, boundary,  \
-                                                  flag)                    \
-  do {                                                                     \
-    static_assert(!std::is_enum<decltype(sample)>::value,                  \
-                  "|sample| should not be an enum type!");                 \
-    static_assert(!std::is_enum<decltype(boundary)>::value,                \
-                  "|boundary| should not be an enum type!");               \
-    STATIC_HISTOGRAM_POINTER_BLOCK(                                        \
-        name, Add(sample),                                                 \
-        base::LinearHistogram::FactoryGet(name, 1, boundary, boundary + 1, \
-                                          flag));                          \
-  } while (0)
-
-// While this behaves the same as the above macro, the wrapping of a linear
-// histogram with another object to do the scaling means the POINTER_BLOCK
-// macro can't be used as it is tied to HistogramBase
-#define INTERNAL_HISTOGRAM_SCALED_EXACT_LINEAR_WITH_FLAG(                      \
-    name, sample, count, boundary, scale, flag)                                \
-  do {                                                                         \
-    static_assert(!std::is_enum<decltype(sample)>::value,                      \
-                  "|sample| should not be an enum type!");                     \
-    static_assert(!std::is_enum<decltype(boundary)>::value,                    \
-                  "|boundary| should not be an enum type!");                   \
-    class ScaledLinearHistogramInstance : public base::ScaledLinearHistogram { \
-     public:                                                                   \
-      ScaledLinearHistogramInstance()                                          \
-          : ScaledLinearHistogram(name,                                        \
-                                  1,                                           \
-                                  boundary,                                    \
-                                  boundary + 1,                                \
-                                  scale,                                       \
-                                  flag) {}                                     \
-    };                                                                         \
-    static base::LazyInstance<ScaledLinearHistogramInstance>::Leaky scaled;    \
-    scaled.Get().AddScaledCount(sample, count);                                \
-  } while (0)
-
-// Helper for 'overloading' UMA_HISTOGRAM_ENUMERATION with a variable number of
-// arguments.
-#define INTERNAL_UMA_HISTOGRAM_ENUMERATION_GET_MACRO(_1, _2, NAME, ...) NAME
-
-#define INTERNAL_UMA_HISTOGRAM_ENUMERATION_DEDUCE_BOUNDARY(name, sample,       \
-                                                           flags)              \
-  INTERNAL_HISTOGRAM_ENUMERATION_WITH_FLAG(                                    \
-      name, sample, base::internal::EnumSizeTraits<decltype(sample)>::Count(), \
-      flags)
-
-// Note: The value in |sample| must be strictly less than |enum_size|.
-#define INTERNAL_UMA_HISTOGRAM_ENUMERATION_SPECIFY_BOUNDARY(name, sample,     \
-                                                            enum_size, flags) \
-  INTERNAL_HISTOGRAM_ENUMERATION_WITH_FLAG(name, sample, enum_size, flags)
-
-// Similar to the previous macro but intended for enumerations. This delegates
-// the work to the previous macro, but supports scoped enumerations as well by
-// forcing an explicit cast to the HistogramBase::Sample integral type.
-//
-// Note the range checks verify two separate issues:
-// - that the declared enum size isn't out of range of HistogramBase::Sample
-// - that the declared enum size is > 0
-//
-// TODO(dcheng): This should assert that the passed in types are actually enum
-// types.
-#define INTERNAL_HISTOGRAM_ENUMERATION_WITH_FLAG(name, sample, boundary, flag) \
-  do {                                                                         \
-    using decayed_sample = std::decay<decltype(sample)>::type;                 \
-    using decayed_boundary = std::decay<decltype(boundary)>::type;             \
-    static_assert(!std::is_enum<decayed_boundary>::value ||                    \
-                      std::is_enum<decayed_sample>::value,                     \
-                  "Unexpected: |boundary| is enum, but |sample| is not.");     \
-    static_assert(!std::is_enum<decayed_sample>::value ||                      \
-                      !std::is_enum<decayed_boundary>::value ||                \
-                      std::is_same<decayed_sample, decayed_boundary>::value,   \
-                  "|sample| and |boundary| shouldn't be of different enums");  \
-    static_assert(                                                             \
-        static_cast<uintmax_t>(boundary) <                                     \
-            static_cast<uintmax_t>(                                            \
-                std::numeric_limits<base::HistogramBase::Sample>::max()),      \
-        "|boundary| is out of range of HistogramBase::Sample");                \
-    INTERNAL_HISTOGRAM_EXACT_LINEAR_WITH_FLAG(                                 \
-        name, static_cast<base::HistogramBase::Sample>(sample),                \
-        static_cast<base::HistogramBase::Sample>(boundary), flag);             \
-  } while (0)
-
-#define INTERNAL_HISTOGRAM_SCALED_ENUMERATION_WITH_FLAG(name, sample, count, \
-                                                        scale, flag)         \
-  do {                                                                       \
-    using decayed_sample = std::decay<decltype(sample)>::type;               \
-    static_assert(std::is_enum<decayed_sample>::value,                       \
-                  "Unexpected: |sample| is not at enum.");                   \
-    constexpr auto boundary =                                                \
-        base::internal::EnumSizeTraits<decltype(sample)>::Count();           \
-    static_assert(                                                           \
-        static_cast<uintmax_t>(boundary) <                                   \
-            static_cast<uintmax_t>(                                          \
-                std::numeric_limits<base::HistogramBase::Sample>::max()),    \
-        "|boundary| is out of range of HistogramBase::Sample");              \
-    INTERNAL_HISTOGRAM_SCALED_EXACT_LINEAR_WITH_FLAG(                        \
-        name, static_cast<base::HistogramBase::Sample>(sample), count,       \
-        static_cast<base::HistogramBase::Sample>(boundary), scale, flag);    \
-  } while (0)
-
-// This is a helper macro used by other macros and shouldn't be used directly.
-// This is necessary to expand __COUNTER__ to an actual value.
-#define INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_EXPANDER(name, is_long, key)       \
-  INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_UNIQUE(name, is_long, key)
-
-// This is a helper macro used by other macros and shouldn't be used directly.
-#define INTERNAL_SCOPED_UMA_HISTOGRAM_TIMER_UNIQUE(name, is_long, key)         \
-  class ScopedHistogramTimer##key {                                            \
-   public:                                                                     \
-    ScopedHistogramTimer##key() : constructed_(base::TimeTicks::Now()) {}      \
-    ~ScopedHistogramTimer##key() {                                             \
-      base::TimeDelta elapsed = base::TimeTicks::Now() - constructed_;         \
-      if (is_long) {                                                           \
-        UMA_HISTOGRAM_LONG_TIMES_100(name, elapsed);                           \
-      } else {                                                                 \
-        UMA_HISTOGRAM_TIMES(name, elapsed);                                    \
-      }                                                                        \
-    }                                                                          \
-   private:                                                                    \
-    base::TimeTicks constructed_;                                              \
-  } scoped_histogram_timer_##key
-
-#endif  // BASE_METRICS_HISTOGRAM_MACROS_INTERNAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram_macros_local.h b/native/zucchini/vendor/libchrome/base/metrics/histogram_macros_local.h
deleted file mode 100644
index c4d333b..0000000
--- a/native/zucchini/vendor/libchrome/base/metrics/histogram_macros_local.h
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_METRICS_HISTOGRAM_MACROS_LOCAL_H_
-#define BASE_METRICS_HISTOGRAM_MACROS_LOCAL_H_
-
-#include "base/logging.h"
-#include "base/metrics/histogram.h"
-#include "base/metrics/histogram_macros_internal.h"
-#include "base/time/time.h"
-
-// TODO(rkaplow): Migrate all LOCAL_* usage within Chromium to include this
-// file instead of the histogram_macros.h file.
-
-//------------------------------------------------------------------------------
-// Enumeration histograms.
-//
-// For usage details, see the equivalents in histogram_macros.h.
-
-#define LOCAL_HISTOGRAM_ENUMERATION(name, ...)                          \
-  CR_EXPAND_ARG(INTERNAL_UMA_HISTOGRAM_ENUMERATION_GET_MACRO(           \
-      __VA_ARGS__, INTERNAL_UMA_HISTOGRAM_ENUMERATION_SPECIFY_BOUNDARY, \
-      INTERNAL_UMA_HISTOGRAM_ENUMERATION_DEDUCE_BOUNDARY)(              \
-      name, __VA_ARGS__, base::HistogramBase::kNoFlags))
-
-#define LOCAL_HISTOGRAM_BOOLEAN(name, sample)                                  \
-    STATIC_HISTOGRAM_POINTER_BLOCK(name, AddBoolean(sample),                   \
-        base::BooleanHistogram::FactoryGet(name, base::Histogram::kNoFlags))
-
-//------------------------------------------------------------------------------
-// Percentage histograms.
-//
-// For usage details, see the equivalents in histogram_macros.h
-
-#define LOCAL_HISTOGRAM_PERCENTAGE(name, under_one_hundred)                    \
-    LOCAL_HISTOGRAM_ENUMERATION(name, under_one_hundred, 101)
-
-//------------------------------------------------------------------------------
-// Count histograms. These are used for collecting numeric data. Note that we
-// have macros for more specialized use cases below (memory, time, percentages).
-// For usage details, see the equivalents in histogram_macros.h.
-
-#define LOCAL_HISTOGRAM_COUNTS_100(name, sample)                               \
-    LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 100, 50)
-
-#define LOCAL_HISTOGRAM_COUNTS_10000(name, sample)                             \
-    LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 10000, 50)
-
-#define LOCAL_HISTOGRAM_COUNTS_1000000(name, sample)                           \
-    LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 1000000, 50)
-
-#define LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, min, max, bucket_count)    \
-    INTERNAL_HISTOGRAM_CUSTOM_COUNTS_WITH_FLAG(                                \
-        name, sample, min, max, bucket_count, base::HistogramBase::kNoFlags)
-
-//------------------------------------------------------------------------------
-// Timing histograms. These are used for collecting timing data (generally
-// latencies).
-//
-// For usage details, see the equivalents in histogram_macros.h.
-
-#define LOCAL_HISTOGRAM_TIMES(name, sample) LOCAL_HISTOGRAM_CUSTOM_TIMES(      \
-    name, sample, base::TimeDelta::FromMilliseconds(1),                        \
-    base::TimeDelta::FromSeconds(10), 50)
-
-#define LOCAL_HISTOGRAM_CUSTOM_TIMES(name, sample, min, max, bucket_count) \
-  STATIC_HISTOGRAM_POINTER_BLOCK(                                          \
-      name, AddTimeMillisecondsGranularity(sample),                        \
-      base::Histogram::FactoryTimeGet(name, min, max, bucket_count,        \
-                                      base::HistogramBase::kNoFlags))
-
-//------------------------------------------------------------------------------
-// Memory histograms.
-//
-// For usage details, see the equivalents in histogram_macros.h.
-
-#define LOCAL_HISTOGRAM_MEMORY_KB(name, sample) LOCAL_HISTOGRAM_CUSTOM_COUNTS( \
-    name, sample, 1000, 500000, 50)
-
-//------------------------------------------------------------------------------
-// Deprecated histograms. Not recommended for current use.
-
-// TODO(rkaplow): See if we can clean up this macro and usage.
-// Legacy non-explicit version. We suggest using LOCAL_HISTOGRAM_COUNTS_1000000
-// instead.
-#define LOCAL_HISTOGRAM_COUNTS(name, sample)                                   \
-    LOCAL_HISTOGRAM_CUSTOM_COUNTS(name, sample, 1, 1000000, 50)
-
-#endif  // BASE_METRICS_HISTOGRAM_MACROS_LOCAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/histogram_samples.h b/native/zucchini/vendor/libchrome/base/metrics/histogram_samples.h
deleted file mode 100644
index 6908873..0000000
--- a/native/zucchini/vendor/libchrome/base/metrics/histogram_samples.h
+++ /dev/null
@@ -1,267 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_METRICS_HISTOGRAM_SAMPLES_H_
-#define BASE_METRICS_HISTOGRAM_SAMPLES_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <limits>
-#include <memory>
-
-#include "base/atomicops.h"
-#include "base/macros.h"
-#include "base/metrics/histogram_base.h"
-
-namespace base {
-
-class Pickle;
-class PickleIterator;
-class SampleCountIterator;
-
-// HistogramSamples is a container storing all samples of a histogram. All
-// elements must be of a fixed width to ensure 32/64-bit interoperability.
-// If this structure changes, bump the version number for kTypeIdHistogram
-// in persistent_histogram_allocator.cc.
-//
-// Note that though these samples are individually consistent (through the use
-// of atomic operations on the counts), there is only "eventual consistency"
-// overall when multiple threads are accessing this data. That means that the
-// sum, redundant-count, etc. could be momentarily out-of-sync with the stored
-// counts but will settle to a consistent "steady state" once all threads have
-// exited this code.
-class BASE_EXPORT HistogramSamples {
- public:
-  // A single bucket and count. To fit within a single atomic on 32-bit build
-  // architectures, both |bucket| and |count| are limited in size to 16 bits.
-  // This limits the functionality somewhat but if an entry can't fit then
-  // the full array of samples can be allocated and used.
-  struct SingleSample {
-    uint16_t bucket;
-    uint16_t count;
-  };
-
-  // A structure for managing an atomic single sample. Because this is generally
-  // used in association with other atomic values, the defined methods use
-  // acquire/release operations to guarantee ordering with outside values.
-  union BASE_EXPORT AtomicSingleSample {
-    AtomicSingleSample() : as_atomic(0) {}
-    AtomicSingleSample(subtle::Atomic32 rhs) : as_atomic(rhs) {}
-
-    // Returns the single sample in an atomic manner. This in an "acquire"
-    // load. The returned sample isn't shared and thus its fields can be safely
-    // accessed.
-    SingleSample Load() const;
-
-    // Extracts the single sample in an atomic manner. If |disable| is true
-    // then this object will be set so it will never accumulate another value.
-    // This is "no barrier" so doesn't enforce ordering with other atomic ops.
-    SingleSample Extract(bool disable);
-
-    // Adds a given count to the held bucket. If not possible, it returns false
-    // and leaves the parts unchanged. Once extracted/disabled, this always
-    // returns false. This in an "acquire/release" operation.
-    bool Accumulate(size_t bucket, HistogramBase::Count count);
-
-    // Returns if the sample has been "disabled" (via Extract) and thus not
-    // allowed to accept further accumulation.
-    bool IsDisabled() const;
-
-   private:
-    // union field: The actual sample bucket and count.
-    SingleSample as_parts;
-
-    // union field: The sample as an atomic value. Atomic64 would provide
-    // more flexibility but isn't available on all builds. This can hold a
-    // special, internal "disabled" value indicating that it must not accept
-    // further accumulation.
-    subtle::Atomic32 as_atomic;
-  };
-
-  // A structure of information about the data, common to all sample containers.
-  // Because of how this is used in persistent memory, it must be a POD object
-  // that makes sense when initialized to all zeros.
-  struct Metadata {
-    // Expected size for 32/64-bit check.
-    static constexpr size_t kExpectedInstanceSize = 24;
-
-    // Initialized when the sample-set is first created with a value provided
-    // by the caller. It is generally used to identify the sample-set across
-    // threads and processes, though not necessarily uniquely as it is possible
-    // to have multiple sample-sets representing subsets of the data.
-    uint64_t id;
-
-    // The sum of all the entries, effectivly the sum(sample * count) for
-    // all samples. Despite being atomic, no guarantees are made on the
-    // accuracy of this value; there may be races during histogram
-    // accumulation and snapshotting that we choose to accept. It should
-    // be treated as approximate.
-#ifdef ARCH_CPU_64_BITS
-    subtle::Atomic64 sum;
-#else
-    // 32-bit systems don't have atomic 64-bit operations. Use a basic type
-    // and don't worry about "shearing".
-    int64_t sum;
-#endif
-
-    // A "redundant" count helps identify memory corruption. It redundantly
-    // stores the total number of samples accumulated in the histogram. We
-    // can compare this count to the sum of the counts (TotalCount() function),
-    // and detect problems. Note, depending on the implementation of different
-    // histogram types, there might be races during histogram accumulation
-    // and snapshotting that we choose to accept. In this case, the tallies
-    // might mismatch even when no memory corruption has happened.
-    HistogramBase::AtomicCount redundant_count;
-
-    // A single histogram value and associated count. This allows histograms
-    // that typically report only a single value to not require full storage
-    // to be allocated.
-    AtomicSingleSample single_sample;  // 32 bits
-  };
-
-  // Because structures held in persistent memory must be POD, there can be no
-  // default constructor to clear the fields. This derived class exists just
-  // to clear them when being allocated on the heap.
-  struct BASE_EXPORT LocalMetadata : Metadata {
-    LocalMetadata();
-  };
-
-  HistogramSamples(uint64_t id, Metadata* meta);
-  virtual ~HistogramSamples();
-
-  virtual void Accumulate(HistogramBase::Sample value,
-                          HistogramBase::Count count) = 0;
-  virtual HistogramBase::Count GetCount(HistogramBase::Sample value) const = 0;
-  virtual HistogramBase::Count TotalCount() const = 0;
-
-  virtual void Add(const HistogramSamples& other);
-
-  // Add from serialized samples.
-  virtual bool AddFromPickle(PickleIterator* iter);
-
-  virtual void Subtract(const HistogramSamples& other);
-
-  virtual std::unique_ptr<SampleCountIterator> Iterator() const = 0;
-  virtual void Serialize(Pickle* pickle) const;
-
-  // Accessor fuctions.
-  uint64_t id() const { return meta_->id; }
-  int64_t sum() const {
-#ifdef ARCH_CPU_64_BITS
-    return subtle::NoBarrier_Load(&meta_->sum);
-#else
-    return meta_->sum;
-#endif
-  }
-  HistogramBase::Count redundant_count() const {
-    return subtle::NoBarrier_Load(&meta_->redundant_count);
-  }
-
- protected:
-  enum NegativeSampleReason {
-    SAMPLES_HAVE_LOGGED_BUT_NOT_SAMPLE,
-    SAMPLES_SAMPLE_LESS_THAN_LOGGED,
-    SAMPLES_ADDED_NEGATIVE_COUNT,
-    SAMPLES_ADD_WENT_NEGATIVE,
-    SAMPLES_ADD_OVERFLOW,
-    SAMPLES_ACCUMULATE_NEGATIVE_COUNT,
-    SAMPLES_ACCUMULATE_WENT_NEGATIVE,
-    DEPRECATED_SAMPLES_ACCUMULATE_OVERFLOW,
-    SAMPLES_ACCUMULATE_OVERFLOW,
-    MAX_NEGATIVE_SAMPLE_REASONS
-  };
-
-  // Based on |op| type, add or subtract sample counts data from the iterator.
-  enum Operator { ADD, SUBTRACT };
-  virtual bool AddSubtractImpl(SampleCountIterator* iter, Operator op) = 0;
-
-  // Accumulates to the embedded single-sample field if possible. Returns true
-  // on success, false otherwise. Sum and redundant-count are also updated in
-  // the success case.
-  bool AccumulateSingleSample(HistogramBase::Sample value,
-                              HistogramBase::Count count,
-                              size_t bucket);
-
-  // Atomically adjust the sum and redundant-count.
-  void IncreaseSumAndCount(int64_t sum, HistogramBase::Count count);
-
-  // Record a negative-sample observation and the reason why.
-  void RecordNegativeSample(NegativeSampleReason reason,
-                            HistogramBase::Count increment);
-
-  AtomicSingleSample& single_sample() { return meta_->single_sample; }
-  const AtomicSingleSample& single_sample() const {
-    return meta_->single_sample;
-  }
-
-  Metadata* meta() { return meta_; }
-
- private:
-  // Depending on derived class meta values can come from local stoarge or
-  // external storage in which case HistogramSamples class cannot take ownership
-  // of Metadata*.
-  Metadata* meta_;
-
-  DISALLOW_COPY_AND_ASSIGN(HistogramSamples);
-};
-
-class BASE_EXPORT SampleCountIterator {
- public:
-  virtual ~SampleCountIterator();
-
-  virtual bool Done() const = 0;
-  virtual void Next() = 0;
-
-  // Get the sample and count at current position.
-  // |min| |max| and |count| can be NULL if the value is not of interest.
-  // Note: |max| is int64_t because histograms support logged values in the
-  // full int32_t range and bucket max is exclusive, so it needs to support
-  // values up to MAXINT32+1.
-  // Requires: !Done();
-  virtual void Get(HistogramBase::Sample* min,
-                   int64_t* max,
-                   HistogramBase::Count* count) const = 0;
-  static_assert(std::numeric_limits<HistogramBase::Sample>::max() <
-                    std::numeric_limits<int64_t>::max(),
-                "Get() |max| must be able to hold Histogram::Sample max + 1");
-
-  // Get the index of current histogram bucket.
-  // For histograms that don't use predefined buckets, it returns false.
-  // Requires: !Done();
-  virtual bool GetBucketIndex(size_t* index) const;
-};
-
-class BASE_EXPORT SingleSampleIterator : public SampleCountIterator {
- public:
-  SingleSampleIterator(HistogramBase::Sample min,
-                       int64_t max,
-                       HistogramBase::Count count);
-  SingleSampleIterator(HistogramBase::Sample min,
-                       int64_t max,
-                       HistogramBase::Count count,
-                       size_t bucket_index);
-  ~SingleSampleIterator() override;
-
-  // SampleCountIterator:
-  bool Done() const override;
-  void Next() override;
-  void Get(HistogramBase::Sample* min,
-           int64_t* max,
-           HistogramBase::Count* count) const override;
-
-  // SampleVector uses predefined buckets so iterator can return bucket index.
-  bool GetBucketIndex(size_t* index) const override;
-
- private:
-  // Information about the single value to return.
-  const HistogramBase::Sample min_;
-  const int64_t max_;
-  const size_t bucket_index_;
-  HistogramBase::Count count_;
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_HISTOGRAM_SAMPLES_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.cc b/native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.cc
deleted file mode 100644
index 9b18a00..0000000
--- a/native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.cc
+++ /dev/null
@@ -1,1204 +0,0 @@
-// Copyright (c) 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/metrics/persistent_memory_allocator.h"
-
-#include <assert.h>
-#include <algorithm>
-
-#if defined(OS_WIN)
-#include <windows.h>
-#include "winbase.h"
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <sys/mman.h>
-#endif
-
-#include "base/files/memory_mapped_file.h"
-#include "base/logging.h"
-#include "base/memory/shared_memory.h"
-#include "base/metrics/histogram_functions.h"
-#include "base/metrics/sparse_histogram.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/sys_info.h"
-#include "base/threading/thread_restrictions.h"
-#include "build/build_config.h"
-
-namespace {
-
-// Limit of memory segment size. It has to fit in an unsigned 32-bit number
-// and should be a power of 2 in order to accomodate almost any page size.
-const uint32_t kSegmentMaxSize = 1 << 30;  // 1 GiB
-
-// A constant (random) value placed in the shared metadata to identify
-// an already initialized memory segment.
-const uint32_t kGlobalCookie = 0x408305DC;
-
-// The current version of the metadata. If updates are made that change
-// the metadata, the version number can be queried to operate in a backward-
-// compatible manner until the memory segment is completely re-initalized.
-const uint32_t kGlobalVersion = 2;
-
-// Constant values placed in the block headers to indicate its state.
-const uint32_t kBlockCookieFree = 0;
-const uint32_t kBlockCookieQueue = 1;
-const uint32_t kBlockCookieWasted = (uint32_t)-1;
-const uint32_t kBlockCookieAllocated = 0xC8799269;
-
-// TODO(bcwhite): When acceptable, consider moving flags to std::atomic<char>
-// types rather than combined bitfield.
-
-// Flags stored in the flags_ field of the SharedMetadata structure below.
-enum : int {
-  kFlagCorrupt = 1 << 0,
-  kFlagFull    = 1 << 1
-};
-
-// Errors that are logged in "errors" histogram.
-enum AllocatorError : int {
-  kMemoryIsCorrupt = 1,
-};
-
-bool CheckFlag(const volatile std::atomic<uint32_t>* flags, int flag) {
-  uint32_t loaded_flags = flags->load(std::memory_order_relaxed);
-  return (loaded_flags & flag) != 0;
-}
-
-void SetFlag(volatile std::atomic<uint32_t>* flags, int flag) {
-  uint32_t loaded_flags = flags->load(std::memory_order_relaxed);
-  for (;;) {
-    uint32_t new_flags = (loaded_flags & ~flag) | flag;
-    // In the failue case, actual "flags" value stored in loaded_flags.
-    // These access are "relaxed" because they are completely independent
-    // of all other values.
-    if (flags->compare_exchange_weak(loaded_flags, new_flags,
-                                     std::memory_order_relaxed,
-                                     std::memory_order_relaxed)) {
-      break;
-    }
-  }
-}
-
-}  // namespace
-
-namespace base {
-
-// All allocations and data-structures must be aligned to this byte boundary.
-// Alignment as large as the physical bus between CPU and RAM is _required_
-// for some architectures, is simply more efficient on other CPUs, and
-// generally a Good Idea(tm) for all platforms as it reduces/eliminates the
-// chance that a type will span cache lines. Alignment mustn't be less
-// than 8 to ensure proper alignment for all types. The rest is a balance
-// between reducing spans across multiple cache lines and wasted space spent
-// padding out allocations. An alignment of 16 would ensure that the block
-// header structure always sits in a single cache line. An average of about
-// 1/2 this value will be wasted with every allocation.
-const uint32_t PersistentMemoryAllocator::kAllocAlignment = 8;
-
-// The block-header is placed at the top of every allocation within the
-// segment to describe the data that follows it.
-struct PersistentMemoryAllocator::BlockHeader {
-  uint32_t size;       // Number of bytes in this block, including header.
-  uint32_t cookie;     // Constant value indicating completed allocation.
-  std::atomic<uint32_t> type_id;  // Arbitrary number indicating data type.
-  std::atomic<uint32_t> next;     // Pointer to the next block when iterating.
-};
-
-// The shared metadata exists once at the top of the memory segment to
-// describe the state of the allocator to all processes. The size of this
-// structure must be a multiple of 64-bits to ensure compatibility between
-// architectures.
-struct PersistentMemoryAllocator::SharedMetadata {
-  uint32_t cookie;     // Some value that indicates complete initialization.
-  uint32_t size;       // Total size of memory segment.
-  uint32_t page_size;  // Paging size within memory segment.
-  uint32_t version;    // Version code so upgrades don't break.
-  uint64_t id;         // Arbitrary ID number given by creator.
-  uint32_t name;       // Reference to stored name string.
-  uint32_t padding1;   // Pad-out read-only data to 64-bit alignment.
-
-  // Above is read-only after first construction. Below may be changed and
-  // so must be marked "volatile" to provide correct inter-process behavior.
-
-  // State of the memory, plus some padding to keep alignment.
-  volatile std::atomic<uint8_t> memory_state;  // MemoryState enum values.
-  uint8_t padding2[3];
-
-  // Bitfield of information flags. Access to this should be done through
-  // the CheckFlag() and SetFlag() methods defined above.
-  volatile std::atomic<uint32_t> flags;
-
-  // Offset/reference to first free space in segment.
-  volatile std::atomic<uint32_t> freeptr;
-
-  // The "iterable" queue is an M&S Queue as described here, append-only:
-  // https://www.research.ibm.com/people/m/michael/podc-1996.pdf
-  // |queue| needs to be 64-bit aligned and is itself a multiple of 64 bits.
-  volatile std::atomic<uint32_t> tailptr;  // Last block of iteration queue.
-  volatile BlockHeader queue;   // Empty block for linked-list head/tail.
-};
-
-// The "queue" block header is used to detect "last node" so that zero/null
-// can be used to indicate that it hasn't been added at all. It is part of
-// the SharedMetadata structure which itself is always located at offset zero.
-const PersistentMemoryAllocator::Reference
-    PersistentMemoryAllocator::kReferenceQueue =
-        offsetof(SharedMetadata, queue);
-
-const base::FilePath::CharType PersistentMemoryAllocator::kFileExtension[] =
-    FILE_PATH_LITERAL(".pma");
-
-
-PersistentMemoryAllocator::Iterator::Iterator(
-    const PersistentMemoryAllocator* allocator)
-    : allocator_(allocator), last_record_(kReferenceQueue), record_count_(0) {}
-
-PersistentMemoryAllocator::Iterator::Iterator(
-    const PersistentMemoryAllocator* allocator,
-    Reference starting_after)
-    : allocator_(allocator), last_record_(0), record_count_(0) {
-  Reset(starting_after);
-}
-
-void PersistentMemoryAllocator::Iterator::Reset() {
-  last_record_.store(kReferenceQueue, std::memory_order_relaxed);
-  record_count_.store(0, std::memory_order_relaxed);
-}
-
-void PersistentMemoryAllocator::Iterator::Reset(Reference starting_after) {
-  if (starting_after == 0) {
-    Reset();
-    return;
-  }
-
-  last_record_.store(starting_after, std::memory_order_relaxed);
-  record_count_.store(0, std::memory_order_relaxed);
-
-  // Ensure that the starting point is a valid, iterable block (meaning it can
-  // be read and has a non-zero "next" pointer).
-  const volatile BlockHeader* block =
-      allocator_->GetBlock(starting_after, 0, 0, false, false);
-  if (!block || block->next.load(std::memory_order_relaxed) == 0) {
-    NOTREACHED();
-    last_record_.store(kReferenceQueue, std::memory_order_release);
-  }
-}
-
-PersistentMemoryAllocator::Reference
-PersistentMemoryAllocator::Iterator::GetLast() {
-  Reference last = last_record_.load(std::memory_order_relaxed);
-  if (last == kReferenceQueue)
-    return kReferenceNull;
-  return last;
-}
-
-PersistentMemoryAllocator::Reference
-PersistentMemoryAllocator::Iterator::GetNext(uint32_t* type_return) {
-  // Make a copy of the existing count of found-records, acquiring all changes
-  // made to the allocator, notably "freeptr" (see comment in loop for why
-  // the load of that value cannot be moved above here) that occurred during
-  // any previous runs of this method, including those by parallel threads
-  // that interrupted it. It pairs with the Release at the end of this method.
-  //
-  // Otherwise, if the compiler were to arrange the two loads such that
-  // "count" was fetched _after_ "freeptr" then it would be possible for
-  // this thread to be interrupted between them and other threads perform
-  // multiple allocations, make-iterables, and iterations (with the included
-  // increment of |record_count_|) culminating in the check at the bottom
-  // mistakenly determining that a loop exists. Isn't this stuff fun?
-  uint32_t count = record_count_.load(std::memory_order_acquire);
-
-  Reference last = last_record_.load(std::memory_order_acquire);
-  Reference next;
-  while (true) {
-    const volatile BlockHeader* block =
-        allocator_->GetBlock(last, 0, 0, true, false);
-    if (!block)  // Invalid iterator state.
-      return kReferenceNull;
-
-    // The compiler and CPU can freely reorder all memory accesses on which
-    // there are no dependencies. It could, for example, move the load of
-    // "freeptr" to above this point because there are no explicit dependencies
-    // between it and "next". If it did, however, then another block could
-    // be queued after that but before the following load meaning there is
-    // one more queued block than the future "detect loop by having more
-    // blocks that could fit before freeptr" will allow.
-    //
-    // By "acquiring" the "next" value here, it's synchronized to the enqueue
-    // of the node which in turn is synchronized to the allocation (which sets
-    // freeptr). Thus, the scenario above cannot happen.
-    next = block->next.load(std::memory_order_acquire);
-    if (next == kReferenceQueue)  // No next allocation in queue.
-      return kReferenceNull;
-    block = allocator_->GetBlock(next, 0, 0, false, false);
-    if (!block) {  // Memory is corrupt.
-      allocator_->SetCorrupt();
-      return kReferenceNull;
-    }
-
-    // Update the "last_record" pointer to be the reference being returned.
-    // If it fails then another thread has already iterated past it so loop
-    // again. Failing will also load the existing value into "last" so there
-    // is no need to do another such load when the while-loop restarts. A
-    // "strong" compare-exchange is used because failing unnecessarily would
-    // mean repeating some fairly costly validations above.
-    if (last_record_.compare_exchange_strong(
-            last, next, std::memory_order_acq_rel, std::memory_order_acquire)) {
-      *type_return = block->type_id.load(std::memory_order_relaxed);
-      break;
-    }
-  }
-
-  // Memory corruption could cause a loop in the list. Such must be detected
-  // so as to not cause an infinite loop in the caller. This is done by simply
-  // making sure it doesn't iterate more times than the absolute maximum
-  // number of allocations that could have been made. Callers are likely
-  // to loop multiple times before it is detected but at least it stops.
-  const uint32_t freeptr = std::min(
-      allocator_->shared_meta()->freeptr.load(std::memory_order_relaxed),
-      allocator_->mem_size_);
-  const uint32_t max_records =
-      freeptr / (sizeof(BlockHeader) + kAllocAlignment);
-  if (count > max_records) {
-    allocator_->SetCorrupt();
-    return kReferenceNull;
-  }
-
-  // Increment the count and release the changes made above. It pairs with
-  // the Acquire at the top of this method. Note that this operation is not
-  // strictly synchonized with fetching of the object to return, which would
-  // have to be done inside the loop and is somewhat complicated to achieve.
-  // It does not matter if it falls behind temporarily so long as it never
-  // gets ahead.
-  record_count_.fetch_add(1, std::memory_order_release);
-  return next;
-}
-
-PersistentMemoryAllocator::Reference
-PersistentMemoryAllocator::Iterator::GetNextOfType(uint32_t type_match) {
-  Reference ref;
-  uint32_t type_found;
-  while ((ref = GetNext(&type_found)) != 0) {
-    if (type_found == type_match)
-      return ref;
-  }
-  return kReferenceNull;
-}
-
-
-// static
-bool PersistentMemoryAllocator::IsMemoryAcceptable(const void* base,
-                                                   size_t size,
-                                                   size_t page_size,
-                                                   bool readonly) {
-  return ((base && reinterpret_cast<uintptr_t>(base) % kAllocAlignment == 0) &&
-          (size >= sizeof(SharedMetadata) && size <= kSegmentMaxSize) &&
-          (size % kAllocAlignment == 0 || readonly) &&
-          (page_size == 0 || size % page_size == 0 || readonly));
-}
-
-PersistentMemoryAllocator::PersistentMemoryAllocator(void* base,
-                                                     size_t size,
-                                                     size_t page_size,
-                                                     uint64_t id,
-                                                     base::StringPiece name,
-                                                     bool readonly)
-    : PersistentMemoryAllocator(Memory(base, MEM_EXTERNAL),
-                                size,
-                                page_size,
-                                id,
-                                name,
-                                readonly) {}
-
-PersistentMemoryAllocator::PersistentMemoryAllocator(Memory memory,
-                                                     size_t size,
-                                                     size_t page_size,
-                                                     uint64_t id,
-                                                     base::StringPiece name,
-                                                     bool readonly)
-    : mem_base_(static_cast<char*>(memory.base)),
-      mem_type_(memory.type),
-      mem_size_(static_cast<uint32_t>(size)),
-      mem_page_(static_cast<uint32_t>((page_size ? page_size : size))),
-#if defined(OS_NACL)
-      vm_page_size_(4096U),  // SysInfo is not built for NACL.
-#else
-      vm_page_size_(SysInfo::VMAllocationGranularity()),
-#endif
-      readonly_(readonly),
-      corrupt_(0),
-      allocs_histogram_(nullptr),
-      used_histogram_(nullptr),
-      errors_histogram_(nullptr) {
-  // These asserts ensure that the structures are 32/64-bit agnostic and meet
-  // all the requirements of use within the allocator. They access private
-  // definitions and so cannot be moved to the global scope.
-  static_assert(sizeof(PersistentMemoryAllocator::BlockHeader) == 16,
-                "struct is not portable across different natural word widths");
-  static_assert(sizeof(PersistentMemoryAllocator::SharedMetadata) == 64,
-                "struct is not portable across different natural word widths");
-
-  static_assert(sizeof(BlockHeader) % kAllocAlignment == 0,
-                "BlockHeader is not a multiple of kAllocAlignment");
-  static_assert(sizeof(SharedMetadata) % kAllocAlignment == 0,
-                "SharedMetadata is not a multiple of kAllocAlignment");
-  static_assert(kReferenceQueue % kAllocAlignment == 0,
-                "\"queue\" is not aligned properly; must be at end of struct");
-
-  // Ensure that memory segment is of acceptable size.
-  CHECK(IsMemoryAcceptable(memory.base, size, page_size, readonly));
-
-  // These atomics operate inter-process and so must be lock-free. The local
-  // casts are to make sure it can be evaluated at compile time to a constant.
-  CHECK(((SharedMetadata*)nullptr)->freeptr.is_lock_free());
-  CHECK(((SharedMetadata*)nullptr)->flags.is_lock_free());
-  CHECK(((BlockHeader*)nullptr)->next.is_lock_free());
-  CHECK(corrupt_.is_lock_free());
-
-  if (shared_meta()->cookie != kGlobalCookie) {
-    if (readonly) {
-      SetCorrupt();
-      return;
-    }
-
-    // This block is only executed when a completely new memory segment is
-    // being initialized. It's unshared and single-threaded...
-    volatile BlockHeader* const first_block =
-        reinterpret_cast<volatile BlockHeader*>(mem_base_ +
-                                                sizeof(SharedMetadata));
-    if (shared_meta()->cookie != 0 ||
-        shared_meta()->size != 0 ||
-        shared_meta()->version != 0 ||
-        shared_meta()->freeptr.load(std::memory_order_relaxed) != 0 ||
-        shared_meta()->flags.load(std::memory_order_relaxed) != 0 ||
-        shared_meta()->id != 0 ||
-        shared_meta()->name != 0 ||
-        shared_meta()->tailptr != 0 ||
-        shared_meta()->queue.cookie != 0 ||
-        shared_meta()->queue.next.load(std::memory_order_relaxed) != 0 ||
-        first_block->size != 0 ||
-        first_block->cookie != 0 ||
-        first_block->type_id.load(std::memory_order_relaxed) != 0 ||
-        first_block->next != 0) {
-      // ...or something malicious has been playing with the metadata.
-      SetCorrupt();
-    }
-
-    // This is still safe to do even if corruption has been detected.
-    shared_meta()->cookie = kGlobalCookie;
-    shared_meta()->size = mem_size_;
-    shared_meta()->page_size = mem_page_;
-    shared_meta()->version = kGlobalVersion;
-    shared_meta()->id = id;
-    shared_meta()->freeptr.store(sizeof(SharedMetadata),
-                                 std::memory_order_release);
-
-    // Set up the queue of iterable allocations.
-    shared_meta()->queue.size = sizeof(BlockHeader);
-    shared_meta()->queue.cookie = kBlockCookieQueue;
-    shared_meta()->queue.next.store(kReferenceQueue, std::memory_order_release);
-    shared_meta()->tailptr.store(kReferenceQueue, std::memory_order_release);
-
-    // Allocate space for the name so other processes can learn it.
-    if (!name.empty()) {
-      const size_t name_length = name.length() + 1;
-      shared_meta()->name = Allocate(name_length, 0);
-      char* name_cstr = GetAsArray<char>(shared_meta()->name, 0, name_length);
-      if (name_cstr)
-        memcpy(name_cstr, name.data(), name.length());
-    }
-
-    shared_meta()->memory_state.store(MEMORY_INITIALIZED,
-                                      std::memory_order_release);
-  } else {
-    if (shared_meta()->size == 0 || shared_meta()->version != kGlobalVersion ||
-        shared_meta()->freeptr.load(std::memory_order_relaxed) == 0 ||
-        shared_meta()->tailptr == 0 || shared_meta()->queue.cookie == 0 ||
-        shared_meta()->queue.next.load(std::memory_order_relaxed) == 0) {
-      SetCorrupt();
-    }
-    if (!readonly) {
-      // The allocator is attaching to a previously initialized segment of
-      // memory. If the initialization parameters differ, make the best of it
-      // by reducing the local construction parameters to match those of
-      // the actual memory area. This ensures that the local object never
-      // tries to write outside of the original bounds.
-      // Because the fields are const to ensure that no code other than the
-      // constructor makes changes to them as well as to give optimization
-      // hints to the compiler, it's necessary to const-cast them for changes
-      // here.
-      if (shared_meta()->size < mem_size_)
-        *const_cast<uint32_t*>(&mem_size_) = shared_meta()->size;
-      if (shared_meta()->page_size < mem_page_)
-        *const_cast<uint32_t*>(&mem_page_) = shared_meta()->page_size;
-
-      // Ensure that settings are still valid after the above adjustments.
-      if (!IsMemoryAcceptable(memory.base, mem_size_, mem_page_, readonly))
-        SetCorrupt();
-    }
-  }
-}
-
-PersistentMemoryAllocator::~PersistentMemoryAllocator() {
-  // It's strictly forbidden to do any memory access here in case there is
-  // some issue with the underlying memory segment. The "Local" allocator
-  // makes use of this to allow deletion of the segment on the heap from
-  // within its destructor.
-}
-
-uint64_t PersistentMemoryAllocator::Id() const {
-  return shared_meta()->id;
-}
-
-const char* PersistentMemoryAllocator::Name() const {
-  Reference name_ref = shared_meta()->name;
-  const char* name_cstr =
-      GetAsArray<char>(name_ref, 0, PersistentMemoryAllocator::kSizeAny);
-  if (!name_cstr)
-    return "";
-
-  size_t name_length = GetAllocSize(name_ref);
-  if (name_cstr[name_length - 1] != '\0') {
-    NOTREACHED();
-    SetCorrupt();
-    return "";
-  }
-
-  return name_cstr;
-}
-
-void PersistentMemoryAllocator::CreateTrackingHistograms(
-    base::StringPiece name) {
-  if (name.empty() || readonly_)
-    return;
-  std::string name_string = name.as_string();
-
-#if 0
-  // This histogram wasn't being used so has been disabled. It is left here
-  // in case development of a new use of the allocator could benefit from
-  // recording (temporarily and locally) the allocation sizes.
-  DCHECK(!allocs_histogram_);
-  allocs_histogram_ = Histogram::FactoryGet(
-      "UMA.PersistentAllocator." + name_string + ".Allocs", 1, 10000, 50,
-      HistogramBase::kUmaTargetedHistogramFlag);
-#endif
-
-  DCHECK(!used_histogram_);
-  used_histogram_ = LinearHistogram::FactoryGet(
-      "UMA.PersistentAllocator." + name_string + ".UsedPct", 1, 101, 21,
-      HistogramBase::kUmaTargetedHistogramFlag);
-
-  DCHECK(!errors_histogram_);
-  errors_histogram_ = SparseHistogram::FactoryGet(
-      "UMA.PersistentAllocator." + name_string + ".Errors",
-      HistogramBase::kUmaTargetedHistogramFlag);
-}
-
-void PersistentMemoryAllocator::Flush(bool sync) {
-  FlushPartial(used(), sync);
-}
-
-void PersistentMemoryAllocator::SetMemoryState(uint8_t memory_state) {
-  shared_meta()->memory_state.store(memory_state, std::memory_order_relaxed);
-  FlushPartial(sizeof(SharedMetadata), false);
-}
-
-uint8_t PersistentMemoryAllocator::GetMemoryState() const {
-  return shared_meta()->memory_state.load(std::memory_order_relaxed);
-}
-
-size_t PersistentMemoryAllocator::used() const {
-  return std::min(shared_meta()->freeptr.load(std::memory_order_relaxed),
-                  mem_size_);
-}
-
-PersistentMemoryAllocator::Reference PersistentMemoryAllocator::GetAsReference(
-    const void* memory,
-    uint32_t type_id) const {
-  uintptr_t address = reinterpret_cast<uintptr_t>(memory);
-  if (address < reinterpret_cast<uintptr_t>(mem_base_))
-    return kReferenceNull;
-
-  uintptr_t offset = address - reinterpret_cast<uintptr_t>(mem_base_);
-  if (offset >= mem_size_ || offset < sizeof(BlockHeader))
-    return kReferenceNull;
-
-  Reference ref = static_cast<Reference>(offset) - sizeof(BlockHeader);
-  if (!GetBlockData(ref, type_id, kSizeAny))
-    return kReferenceNull;
-
-  return ref;
-}
-
-size_t PersistentMemoryAllocator::GetAllocSize(Reference ref) const {
-  const volatile BlockHeader* const block = GetBlock(ref, 0, 0, false, false);
-  if (!block)
-    return 0;
-  uint32_t size = block->size;
-  // Header was verified by GetBlock() but a malicious actor could change
-  // the value between there and here. Check it again.
-  if (size <= sizeof(BlockHeader) || ref + size > mem_size_) {
-    SetCorrupt();
-    return 0;
-  }
-  return size - sizeof(BlockHeader);
-}
-
-uint32_t PersistentMemoryAllocator::GetType(Reference ref) const {
-  const volatile BlockHeader* const block = GetBlock(ref, 0, 0, false, false);
-  if (!block)
-    return 0;
-  return block->type_id.load(std::memory_order_relaxed);
-}
-
-bool PersistentMemoryAllocator::ChangeType(Reference ref,
-                                           uint32_t to_type_id,
-                                           uint32_t from_type_id,
-                                           bool clear) {
-  DCHECK(!readonly_);
-  volatile BlockHeader* const block = GetBlock(ref, 0, 0, false, false);
-  if (!block)
-    return false;
-
-  // "Strong" exchanges are used below because there is no loop that can retry
-  // in the wake of spurious failures possible with "weak" exchanges. It is,
-  // in aggregate, an "acquire-release" operation so no memory accesses can be
-  // reordered either before or after this method (since changes based on type
-  // could happen on either side).
-
-  if (clear) {
-    // If clearing the memory, first change it to the "transitioning" type so
-    // there can be no confusion by other threads. After the memory is cleared,
-    // it can be changed to its final type.
-    if (!block->type_id.compare_exchange_strong(
-            from_type_id, kTypeIdTransitioning, std::memory_order_acquire,
-            std::memory_order_acquire)) {
-      // Existing type wasn't what was expected: fail (with no changes)
-      return false;
-    }
-
-    // Clear the memory in an atomic manner. Using "release" stores force
-    // every write to be done after the ones before it. This is better than
-    // using memset because (a) it supports "volatile" and (b) it creates a
-    // reliable pattern upon which other threads may rely.
-    volatile std::atomic<int>* data =
-        reinterpret_cast<volatile std::atomic<int>*>(
-            reinterpret_cast<volatile char*>(block) + sizeof(BlockHeader));
-    const uint32_t words = (block->size - sizeof(BlockHeader)) / sizeof(int);
-    DCHECK_EQ(0U, (block->size - sizeof(BlockHeader)) % sizeof(int));
-    for (uint32_t i = 0; i < words; ++i) {
-      data->store(0, std::memory_order_release);
-      ++data;
-    }
-
-    // If the destination type is "transitioning" then skip the final exchange.
-    if (to_type_id == kTypeIdTransitioning)
-      return true;
-
-    // Finish the change to the desired type.
-    from_type_id = kTypeIdTransitioning;  // Exchange needs modifiable original.
-    bool success = block->type_id.compare_exchange_strong(
-        from_type_id, to_type_id, std::memory_order_release,
-        std::memory_order_relaxed);
-    DCHECK(success);  // Should never fail.
-    return success;
-  }
-
-  // One step change to the new type. Will return false if the existing value
-  // doesn't match what is expected.
-  return block->type_id.compare_exchange_strong(from_type_id, to_type_id,
-                                                std::memory_order_acq_rel,
-                                                std::memory_order_acquire);
-}
-
-PersistentMemoryAllocator::Reference PersistentMemoryAllocator::Allocate(
-    size_t req_size,
-    uint32_t type_id) {
-  Reference ref = AllocateImpl(req_size, type_id);
-  if (ref) {
-    // Success: Record this allocation in usage stats (if active).
-    if (allocs_histogram_)
-      allocs_histogram_->Add(static_cast<HistogramBase::Sample>(req_size));
-  } else {
-    // Failure: Record an allocation of zero for tracking.
-    if (allocs_histogram_)
-      allocs_histogram_->Add(0);
-  }
-  return ref;
-}
-
-PersistentMemoryAllocator::Reference PersistentMemoryAllocator::AllocateImpl(
-    size_t req_size,
-    uint32_t type_id) {
-  DCHECK(!readonly_);
-
-  // Validate req_size to ensure it won't overflow when used as 32-bit value.
-  if (req_size > kSegmentMaxSize - sizeof(BlockHeader)) {
-    NOTREACHED();
-    return kReferenceNull;
-  }
-
-  // Round up the requested size, plus header, to the next allocation alignment.
-  uint32_t size = static_cast<uint32_t>(req_size + sizeof(BlockHeader));
-  size = (size + (kAllocAlignment - 1)) & ~(kAllocAlignment - 1);
-  if (size <= sizeof(BlockHeader) || size > mem_page_) {
-    NOTREACHED();
-    return kReferenceNull;
-  }
-
-  // Get the current start of unallocated memory. Other threads may
-  // update this at any time and cause us to retry these operations.
-  // This value should be treated as "const" to avoid confusion through
-  // the code below but recognize that any failed compare-exchange operation
-  // involving it will cause it to be loaded with a more recent value. The
-  // code should either exit or restart the loop in that case.
-  /* const */ uint32_t freeptr =
-      shared_meta()->freeptr.load(std::memory_order_acquire);
-
-  // Allocation is lockless so we do all our caculation and then, if saving
-  // indicates a change has occurred since we started, scrap everything and
-  // start over.
-  for (;;) {
-    if (IsCorrupt())
-      return kReferenceNull;
-
-    if (freeptr + size > mem_size_) {
-      SetFlag(&shared_meta()->flags, kFlagFull);
-      return kReferenceNull;
-    }
-
-    // Get pointer to the "free" block. If something has been allocated since
-    // the load of freeptr above, it is still safe as nothing will be written
-    // to that location until after the compare-exchange below.
-    volatile BlockHeader* const block = GetBlock(freeptr, 0, 0, false, true);
-    if (!block) {
-      SetCorrupt();
-      return kReferenceNull;
-    }
-
-    // An allocation cannot cross page boundaries. If it would, create a
-    // "wasted" block and begin again at the top of the next page. This
-    // area could just be left empty but we fill in the block header just
-    // for completeness sake.
-    const uint32_t page_free = mem_page_ - freeptr % mem_page_;
-    if (size > page_free) {
-      if (page_free <= sizeof(BlockHeader)) {
-        SetCorrupt();
-        return kReferenceNull;
-      }
-      const uint32_t new_freeptr = freeptr + page_free;
-      if (shared_meta()->freeptr.compare_exchange_strong(
-              freeptr, new_freeptr, std::memory_order_acq_rel,
-              std::memory_order_acquire)) {
-        block->size = page_free;
-        block->cookie = kBlockCookieWasted;
-      }
-      continue;
-    }
-
-    // Don't leave a slice at the end of a page too small for anything. This
-    // can result in an allocation up to two alignment-sizes greater than the
-    // minimum required by requested-size + header + alignment.
-    if (page_free - size < sizeof(BlockHeader) + kAllocAlignment)
-      size = page_free;
-
-    const uint32_t new_freeptr = freeptr + size;
-    if (new_freeptr > mem_size_) {
-      SetCorrupt();
-      return kReferenceNull;
-    }
-
-    // Save our work. Try again if another thread has completed an allocation
-    // while we were processing. A "weak" exchange would be permissable here
-    // because the code will just loop and try again but the above processing
-    // is significant so make the extra effort of a "strong" exchange.
-    if (!shared_meta()->freeptr.compare_exchange_strong(
-            freeptr, new_freeptr, std::memory_order_acq_rel,
-            std::memory_order_acquire)) {
-      continue;
-    }
-
-    // Given that all memory was zeroed before ever being given to an instance
-    // of this class and given that we only allocate in a monotomic fashion
-    // going forward, it must be that the newly allocated block is completely
-    // full of zeros. If we find anything in the block header that is NOT a
-    // zero then something must have previously run amuck through memory,
-    // writing beyond the allocated space and into unallocated space.
-    if (block->size != 0 ||
-        block->cookie != kBlockCookieFree ||
-        block->type_id.load(std::memory_order_relaxed) != 0 ||
-        block->next.load(std::memory_order_relaxed) != 0) {
-      SetCorrupt();
-      return kReferenceNull;
-    }
-
-    // Make sure the memory exists by writing to the first byte of every memory
-    // page it touches beyond the one containing the block header itself.
-    // As the underlying storage is often memory mapped from disk or shared
-    // space, sometimes things go wrong and those address don't actually exist
-    // leading to a SIGBUS (or Windows equivalent) at some arbitrary location
-    // in the code. This should concentrate all those failures into this
-    // location for easy tracking and, eventually, proper handling.
-    volatile char* mem_end = reinterpret_cast<volatile char*>(block) + size;
-    volatile char* mem_begin = reinterpret_cast<volatile char*>(
-        (reinterpret_cast<uintptr_t>(block) + sizeof(BlockHeader) +
-         (vm_page_size_ - 1)) &
-        ~static_cast<uintptr_t>(vm_page_size_ - 1));
-    for (volatile char* memory = mem_begin; memory < mem_end;
-         memory += vm_page_size_) {
-      // It's required that a memory segment start as all zeros and thus the
-      // newly allocated block is all zeros at this point. Thus, writing a
-      // zero to it allows testing that the memory exists without actually
-      // changing its contents. The compiler doesn't know about the requirement
-      // and so cannot optimize-away these writes.
-      *memory = 0;
-    }
-
-    // Load information into the block header. There is no "release" of the
-    // data here because this memory can, currently, be seen only by the thread
-    // performing the allocation. When it comes time to share this, the thread
-    // will call MakeIterable() which does the release operation.
-    block->size = size;
-    block->cookie = kBlockCookieAllocated;
-    block->type_id.store(type_id, std::memory_order_relaxed);
-    return freeptr;
-  }
-}
-
-void PersistentMemoryAllocator::GetMemoryInfo(MemoryInfo* meminfo) const {
-  uint32_t remaining = std::max(
-      mem_size_ - shared_meta()->freeptr.load(std::memory_order_relaxed),
-      (uint32_t)sizeof(BlockHeader));
-  meminfo->total = mem_size_;
-  meminfo->free = remaining - sizeof(BlockHeader);
-}
-
-void PersistentMemoryAllocator::MakeIterable(Reference ref) {
-  DCHECK(!readonly_);
-  if (IsCorrupt())
-    return;
-  volatile BlockHeader* block = GetBlock(ref, 0, 0, false, false);
-  if (!block)  // invalid reference
-    return;
-  if (block->next.load(std::memory_order_acquire) != 0)  // Already iterable.
-    return;
-  block->next.store(kReferenceQueue, std::memory_order_release);  // New tail.
-
-  // Try to add this block to the tail of the queue. May take multiple tries.
-  // If so, tail will be automatically updated with a more recent value during
-  // compare-exchange operations.
-  uint32_t tail = shared_meta()->tailptr.load(std::memory_order_acquire);
-  for (;;) {
-    // Acquire the current tail-pointer released by previous call to this
-    // method and validate it.
-    block = GetBlock(tail, 0, 0, true, false);
-    if (!block) {
-      SetCorrupt();
-      return;
-    }
-
-    // Try to insert the block at the tail of the queue. The tail node always
-    // has an existing value of kReferenceQueue; if that is somehow not the
-    // existing value then another thread has acted in the meantime. A "strong"
-    // exchange is necessary so the "else" block does not get executed when
-    // that is not actually the case (which can happen with a "weak" exchange).
-    uint32_t next = kReferenceQueue;  // Will get replaced with existing value.
-    if (block->next.compare_exchange_strong(next, ref,
-                                            std::memory_order_acq_rel,
-                                            std::memory_order_acquire)) {
-      // Update the tail pointer to the new offset. If the "else" clause did
-      // not exist, then this could be a simple Release_Store to set the new
-      // value but because it does, it's possible that other threads could add
-      // one or more nodes at the tail before reaching this point. We don't
-      // have to check the return value because it either operates correctly
-      // or the exact same operation has already been done (by the "else"
-      // clause) on some other thread.
-      shared_meta()->tailptr.compare_exchange_strong(tail, ref,
-                                                     std::memory_order_release,
-                                                     std::memory_order_relaxed);
-      return;
-    } else {
-      // In the unlikely case that a thread crashed or was killed between the
-      // update of "next" and the update of "tailptr", it is necessary to
-      // perform the operation that would have been done. There's no explicit
-      // check for crash/kill which means that this operation may also happen
-      // even when the other thread is in perfect working order which is what
-      // necessitates the CompareAndSwap above.
-      shared_meta()->tailptr.compare_exchange_strong(tail, next,
-                                                     std::memory_order_acq_rel,
-                                                     std::memory_order_acquire);
-    }
-  }
-}
-
-// The "corrupted" state is held both locally and globally (shared). The
-// shared flag can't be trusted since a malicious actor could overwrite it.
-// Because corruption can be detected during read-only operations such as
-// iteration, this method may be called by other "const" methods. In this
-// case, it's safe to discard the constness and modify the local flag and
-// maybe even the shared flag if the underlying data isn't actually read-only.
-void PersistentMemoryAllocator::SetCorrupt() const {
-  if (!corrupt_.load(std::memory_order_relaxed) &&
-      !CheckFlag(
-          const_cast<volatile std::atomic<uint32_t>*>(&shared_meta()->flags),
-          kFlagCorrupt)) {
-    LOG(ERROR) << "Corruption detected in shared-memory segment.";
-    RecordError(kMemoryIsCorrupt);
-  }
-
-  corrupt_.store(true, std::memory_order_relaxed);
-  if (!readonly_) {
-    SetFlag(const_cast<volatile std::atomic<uint32_t>*>(&shared_meta()->flags),
-            kFlagCorrupt);
-  }
-}
-
-bool PersistentMemoryAllocator::IsCorrupt() const {
-  if (corrupt_.load(std::memory_order_relaxed) ||
-      CheckFlag(&shared_meta()->flags, kFlagCorrupt)) {
-    SetCorrupt();  // Make sure all indicators are set.
-    return true;
-  }
-  return false;
-}
-
-bool PersistentMemoryAllocator::IsFull() const {
-  return CheckFlag(&shared_meta()->flags, kFlagFull);
-}
-
-// Dereference a block |ref| and ensure that it's valid for the desired
-// |type_id| and |size|. |special| indicates that we may try to access block
-// headers not available to callers but still accessed by this module. By
-// having internal dereferences go through this same function, the allocator
-// is hardened against corruption.
-const volatile PersistentMemoryAllocator::BlockHeader*
-PersistentMemoryAllocator::GetBlock(Reference ref, uint32_t type_id,
-                                    uint32_t size, bool queue_ok,
-                                    bool free_ok) const {
-  // Handle special cases.
-  if (ref == kReferenceQueue && queue_ok)
-    return reinterpret_cast<const volatile BlockHeader*>(mem_base_ + ref);
-
-  // Validation of parameters.
-  if (ref < sizeof(SharedMetadata))
-    return nullptr;
-  if (ref % kAllocAlignment != 0)
-    return nullptr;
-  size += sizeof(BlockHeader);
-  if (ref + size > mem_size_)
-    return nullptr;
-
-  // Validation of referenced block-header.
-  if (!free_ok) {
-    const volatile BlockHeader* const block =
-        reinterpret_cast<volatile BlockHeader*>(mem_base_ + ref);
-    if (block->cookie != kBlockCookieAllocated)
-      return nullptr;
-    if (block->size < size)
-      return nullptr;
-    if (ref + block->size > mem_size_)
-      return nullptr;
-    if (type_id != 0 &&
-        block->type_id.load(std::memory_order_relaxed) != type_id) {
-      return nullptr;
-    }
-  }
-
-  // Return pointer to block data.
-  return reinterpret_cast<const volatile BlockHeader*>(mem_base_ + ref);
-}
-
-void PersistentMemoryAllocator::FlushPartial(size_t length, bool sync) {
-  // Generally there is nothing to do as every write is done through volatile
-  // memory with atomic instructions to guarantee consistency. This (virtual)
-  // method exists so that derivced classes can do special things, such as
-  // tell the OS to write changes to disk now rather than when convenient.
-}
-
-void PersistentMemoryAllocator::RecordError(int error) const {
-  if (errors_histogram_)
-    errors_histogram_->Add(error);
-}
-
-const volatile void* PersistentMemoryAllocator::GetBlockData(
-    Reference ref,
-    uint32_t type_id,
-    uint32_t size) const {
-  DCHECK(size > 0);
-  const volatile BlockHeader* block =
-      GetBlock(ref, type_id, size, false, false);
-  if (!block)
-    return nullptr;
-  return reinterpret_cast<const volatile char*>(block) + sizeof(BlockHeader);
-}
-
-void PersistentMemoryAllocator::UpdateTrackingHistograms() {
-  DCHECK(!readonly_);
-  if (used_histogram_) {
-    MemoryInfo meminfo;
-    GetMemoryInfo(&meminfo);
-    HistogramBase::Sample used_percent = static_cast<HistogramBase::Sample>(
-        ((meminfo.total - meminfo.free) * 100ULL / meminfo.total));
-    used_histogram_->Add(used_percent);
-  }
-}
-
-
-//----- LocalPersistentMemoryAllocator -----------------------------------------
-
-LocalPersistentMemoryAllocator::LocalPersistentMemoryAllocator(
-    size_t size,
-    uint64_t id,
-    base::StringPiece name)
-    : PersistentMemoryAllocator(AllocateLocalMemory(size),
-                                size, 0, id, name, false) {}
-
-LocalPersistentMemoryAllocator::~LocalPersistentMemoryAllocator() {
-  DeallocateLocalMemory(const_cast<char*>(mem_base_), mem_size_, mem_type_);
-}
-
-// static
-PersistentMemoryAllocator::Memory
-LocalPersistentMemoryAllocator::AllocateLocalMemory(size_t size) {
-  void* address;
-
-#if defined(OS_WIN)
-  address =
-      ::VirtualAlloc(nullptr, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
-  if (address)
-    return Memory(address, MEM_VIRTUAL);
-  UmaHistogramSparse("UMA.LocalPersistentMemoryAllocator.Failures.Win",
-                     ::GetLastError());
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  // MAP_ANON is deprecated on Linux but MAP_ANONYMOUS is not universal on Mac.
-  // MAP_SHARED is not available on Linux <2.4 but required on Mac.
-  address = ::mmap(nullptr, size, PROT_READ | PROT_WRITE,
-                   MAP_ANON | MAP_SHARED, -1, 0);
-  if (address != MAP_FAILED)
-    return Memory(address, MEM_VIRTUAL);
-  UmaHistogramSparse("UMA.LocalPersistentMemoryAllocator.Failures.Posix",
-                     errno);
-#else
-#error This architecture is not (yet) supported.
-#endif
-
-  // As a last resort, just allocate the memory from the heap. This will
-  // achieve the same basic result but the acquired memory has to be
-  // explicitly zeroed and thus realized immediately (i.e. all pages are
-  // added to the process now istead of only when first accessed).
-  address = malloc(size);
-  DPCHECK(address);
-  memset(address, 0, size);
-  return Memory(address, MEM_MALLOC);
-}
-
-// static
-void LocalPersistentMemoryAllocator::DeallocateLocalMemory(void* memory,
-                                                           size_t size,
-                                                           MemoryType type) {
-  if (type == MEM_MALLOC) {
-    free(memory);
-    return;
-  }
-
-  DCHECK_EQ(MEM_VIRTUAL, type);
-#if defined(OS_WIN)
-  BOOL success = ::VirtualFree(memory, 0, MEM_DECOMMIT);
-  DCHECK(success);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  int result = ::munmap(memory, size);
-  DCHECK_EQ(0, result);
-#else
-#error This architecture is not (yet) supported.
-#endif
-}
-
-
-//----- SharedPersistentMemoryAllocator ----------------------------------------
-
-SharedPersistentMemoryAllocator::SharedPersistentMemoryAllocator(
-    std::unique_ptr<SharedMemory> memory,
-    uint64_t id,
-    base::StringPiece name,
-    bool read_only)
-    : PersistentMemoryAllocator(
-          Memory(static_cast<uint8_t*>(memory->memory()), MEM_SHARED),
-          memory->mapped_size(),
-          0,
-          id,
-          name,
-          read_only),
-      shared_memory_(std::move(memory)) {}
-
-SharedPersistentMemoryAllocator::~SharedPersistentMemoryAllocator() = default;
-
-// static
-bool SharedPersistentMemoryAllocator::IsSharedMemoryAcceptable(
-    const SharedMemory& memory) {
-  return IsMemoryAcceptable(memory.memory(), memory.mapped_size(), 0, false);
-}
-
-
-#if !defined(OS_NACL)
-//----- FilePersistentMemoryAllocator ------------------------------------------
-
-FilePersistentMemoryAllocator::FilePersistentMemoryAllocator(
-    std::unique_ptr<MemoryMappedFile> file,
-    size_t max_size,
-    uint64_t id,
-    base::StringPiece name,
-    bool read_only)
-    : PersistentMemoryAllocator(
-          Memory(const_cast<uint8_t*>(file->data()), MEM_FILE),
-          max_size != 0 ? max_size : file->length(),
-          0,
-          id,
-          name,
-          read_only),
-      mapped_file_(std::move(file)) {}
-
-FilePersistentMemoryAllocator::~FilePersistentMemoryAllocator() = default;
-
-// static
-bool FilePersistentMemoryAllocator::IsFileAcceptable(
-    const MemoryMappedFile& file,
-    bool read_only) {
-  return IsMemoryAcceptable(file.data(), file.length(), 0, read_only);
-}
-
-void FilePersistentMemoryAllocator::FlushPartial(size_t length, bool sync) {
-  if (sync)
-    AssertBlockingAllowed();
-  if (IsReadonly())
-    return;
-
-#if defined(OS_WIN)
-  // Windows doesn't support asynchronous flush.
-  AssertBlockingAllowed();
-  BOOL success = ::FlushViewOfFile(data(), length);
-  DPCHECK(success);
-#elif defined(OS_MACOSX)
-  // On OSX, "invalidate" removes all cached pages, forcing a re-read from
-  // disk. That's not applicable to "flush" so omit it.
-  int result =
-      ::msync(const_cast<void*>(data()), length, sync ? MS_SYNC : MS_ASYNC);
-  DCHECK_NE(EINVAL, result);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  // On POSIX, "invalidate" forces _other_ processes to recognize what has
-  // been written to disk and so is applicable to "flush".
-  int result = ::msync(const_cast<void*>(data()), length,
-                       MS_INVALIDATE | (sync ? MS_SYNC : MS_ASYNC));
-  DCHECK_NE(EINVAL, result);
-#else
-#error Unsupported OS.
-#endif
-}
-#endif  // !defined(OS_NACL)
-
-//----- DelayedPersistentAllocation --------------------------------------------
-
-// Forwarding constructors.
-DelayedPersistentAllocation::DelayedPersistentAllocation(
-    PersistentMemoryAllocator* allocator,
-    subtle::Atomic32* ref,
-    uint32_t type,
-    size_t size,
-    bool make_iterable)
-    : DelayedPersistentAllocation(
-          allocator,
-          reinterpret_cast<std::atomic<Reference>*>(ref),
-          type,
-          size,
-          0,
-          make_iterable) {}
-
-DelayedPersistentAllocation::DelayedPersistentAllocation(
-    PersistentMemoryAllocator* allocator,
-    subtle::Atomic32* ref,
-    uint32_t type,
-    size_t size,
-    size_t offset,
-    bool make_iterable)
-    : DelayedPersistentAllocation(
-          allocator,
-          reinterpret_cast<std::atomic<Reference>*>(ref),
-          type,
-          size,
-          offset,
-          make_iterable) {}
-
-DelayedPersistentAllocation::DelayedPersistentAllocation(
-    PersistentMemoryAllocator* allocator,
-    std::atomic<Reference>* ref,
-    uint32_t type,
-    size_t size,
-    bool make_iterable)
-    : DelayedPersistentAllocation(allocator,
-                                  ref,
-                                  type,
-                                  size,
-                                  0,
-                                  make_iterable) {}
-
-// Real constructor.
-DelayedPersistentAllocation::DelayedPersistentAllocation(
-    PersistentMemoryAllocator* allocator,
-    std::atomic<Reference>* ref,
-    uint32_t type,
-    size_t size,
-    size_t offset,
-    bool make_iterable)
-    : allocator_(allocator),
-      type_(type),
-      size_(checked_cast<uint32_t>(size)),
-      offset_(checked_cast<uint32_t>(offset)),
-      make_iterable_(make_iterable),
-      reference_(ref) {
-  DCHECK(allocator_);
-  DCHECK_NE(0U, type_);
-  DCHECK_LT(0U, size_);
-  DCHECK(reference_);
-}
-
-DelayedPersistentAllocation::~DelayedPersistentAllocation() = default;
-
-void* DelayedPersistentAllocation::Get() const {
-  // Relaxed operations are acceptable here because it's not protecting the
-  // contents of the allocation in any way.
-  Reference ref = reference_->load(std::memory_order_acquire);
-  if (!ref) {
-    ref = allocator_->Allocate(size_, type_);
-    if (!ref)
-      return nullptr;
-
-    // Store the new reference in its proper location using compare-and-swap.
-    // Use a "strong" exchange to ensure no false-negatives since the operation
-    // cannot be retried.
-    Reference existing = 0;  // Must be mutable; receives actual value.
-    if (reference_->compare_exchange_strong(existing, ref,
-                                            std::memory_order_release,
-                                            std::memory_order_relaxed)) {
-      if (make_iterable_)
-        allocator_->MakeIterable(ref);
-    } else {
-      // Failure indicates that something else has raced ahead, performed the
-      // allocation, and stored its reference. Purge the allocation that was
-      // just done and use the other one instead.
-      DCHECK_EQ(type_, allocator_->GetType(existing));
-      DCHECK_LE(size_, allocator_->GetAllocSize(existing));
-      allocator_->ChangeType(ref, 0, type_, /*clear=*/false);
-      ref = existing;
-    }
-  }
-
-  char* mem = allocator_->GetAsArray<char>(ref, type_, size_);
-  if (!mem) {
-    // This should never happen but be tolerant if it does as corruption from
-    // the outside is something to guard against.
-    NOTREACHED();
-    return nullptr;
-  }
-  return mem + offset_;
-}
-
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.h b/native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.h
deleted file mode 100644
index 978a362..0000000
--- a/native/zucchini/vendor/libchrome/base/metrics/persistent_memory_allocator.h
+++ /dev/null
@@ -1,872 +0,0 @@
-// Copyright (c) 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
-#define BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
-
-#include <stdint.h>
-
-#include <atomic>
-#include <memory>
-#include <type_traits>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/files/file_path.h"
-#include "base/gtest_prod_util.h"
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-
-namespace base {
-
-class HistogramBase;
-class MemoryMappedFile;
-class SharedMemory;
-
-// Simple allocator for pieces of a memory block that may be persistent
-// to some storage or shared across multiple processes. This class resides
-// under base/metrics because it was written for that purpose. It is,
-// however, fully general-purpose and can be freely moved to base/memory
-// if other uses are found.
-//
-// This class provides for thread-secure (i.e. safe against other threads
-// or processes that may be compromised and thus have malicious intent)
-// allocation of memory within a designated block and also a mechanism by
-// which other threads can learn of these allocations.
-//
-// There is (currently) no way to release an allocated block of data because
-// doing so would risk invalidating pointers held by other processes and
-// greatly complicate the allocation algorithm.
-//
-// Construction of this object can accept new, clean (i.e. zeroed) memory
-// or previously initialized memory. In the first case, construction must
-// be allowed to complete before letting other allocators attach to the same
-// segment. In other words, don't share the segment until at least one
-// allocator has been attached to it.
-//
-// Note that memory not in active use is not accessed so it is possible to
-// use virtual memory, including memory-mapped files, as backing storage with
-// the OS "pinning" new (zeroed) physical RAM pages only as they are needed.
-//
-// OBJECTS: Although the allocator can be used in a "malloc" sense, fetching
-// character arrays and manipulating that memory manually, the better way is
-// generally to use the "object" methods to create and manage allocations. In
-// this way the sizing, type-checking, and construction are all automatic. For
-// this to work, however, every type of stored object must define two public
-// "constexpr" values, kPersistentTypeId and kExpectedInstanceSize, as such:
-//
-// struct MyPersistentObjectType {
-//     // SHA1(MyPersistentObjectType): Increment this if structure changes!
-//     static constexpr uint32_t kPersistentTypeId = 0x3E15F6DE + 1;
-//
-//     // Expected size for 32/64-bit check. Update this if structure changes!
-//     static constexpr size_t kExpectedInstanceSize = 20;
-//
-//     ...
-// };
-//
-// kPersistentTypeId: This value is an arbitrary identifier that allows the
-//   identification of these objects in the allocator, including the ability
-//   to find them via iteration. The number is arbitrary but using the first
-//   four bytes of the SHA1 hash of the type name means that there shouldn't
-//   be any conflicts with other types that may also be stored in the memory.
-//   The fully qualified name (e.g. base::debug::MyPersistentObjectType) could
-//   be used to generate the hash if the type name seems common. Use a command
-//   like this to get the hash: echo -n "MyPersistentObjectType" | sha1sum
-//   If the structure layout changes, ALWAYS increment this number so that
-//   newer versions of the code don't try to interpret persistent data written
-//   by older versions with a different layout.
-//
-// kExpectedInstanceSize: This value is the hard-coded number that matches
-//   what sizeof(T) would return. By providing it explicitly, the allocator can
-//   verify that the structure is compatible between both 32-bit and 64-bit
-//   versions of the code.
-//
-// Using New manages the memory and then calls the default constructor for the
-// object. Given that objects are persistent, no destructor is ever called
-// automatically though a caller can explicitly call Delete to destruct it and
-// change the type to something indicating it is no longer in use.
-//
-// Though persistent memory segments are transferrable between programs built
-// for different natural word widths, they CANNOT be exchanged between CPUs
-// of different endianess. Attempts to do so will simply see the existing data
-// as corrupt and refuse to access any of it.
-class BASE_EXPORT PersistentMemoryAllocator {
- public:
-  typedef uint32_t Reference;
-
-  // These states are used to indicate the overall condition of the memory
-  // segment irrespective of what is stored within it. Because the data is
-  // often persistent and thus needs to be readable by different versions of
-  // a program, these values are fixed and can never change.
-  enum MemoryState : uint8_t {
-    // Persistent memory starts all zeros and so shows "uninitialized".
-    MEMORY_UNINITIALIZED = 0,
-
-    // The header has been written and the memory is ready for use.
-    MEMORY_INITIALIZED = 1,
-
-    // The data should be considered deleted. This would be set when the
-    // allocator is being cleaned up. If file-backed, the file is likely
-    // to be deleted but since deletion can fail for a variety of reasons,
-    // having this extra status means a future reader can realize what
-    // should have happened.
-    MEMORY_DELETED = 2,
-
-    // Outside code can create states starting with this number; these too
-    // must also never change between code versions.
-    MEMORY_USER_DEFINED = 100,
-  };
-
-  // Iterator for going through all iterable memory records in an allocator.
-  // Like the allocator itself, iterators are lock-free and thread-secure.
-  // That means that multiple threads can share an iterator and the same
-  // reference will not be returned twice.
-  //
-  // The order of the items returned by an iterator matches the order in which
-  // MakeIterable() was called on them. Once an allocation is made iterable,
-  // it is always such so the only possible difference between successive
-  // iterations is for more to be added to the end.
-  //
-  // Iteration, in general, is tolerant of corrupted memory. It will return
-  // what it can and stop only when corruption forces it to. Bad corruption
-  // could cause the same object to be returned many times but it will
-  // eventually quit.
-  class BASE_EXPORT Iterator {
-   public:
-    // Constructs an iterator on a given |allocator|, starting at the beginning.
-    // The allocator must live beyond the lifetime of the iterator. This class
-    // has read-only access to the allocator (hence "const") but the returned
-    // references can be used on a read/write version, too.
-    explicit Iterator(const PersistentMemoryAllocator* allocator);
-
-    // As above but resuming from the |starting_after| reference. The first call
-    // to GetNext() will return the next object found after that reference. The
-    // reference must be to an "iterable" object; references to non-iterable
-    // objects (those that never had MakeIterable() called for them) will cause
-    // a run-time error.
-    Iterator(const PersistentMemoryAllocator* allocator,
-             Reference starting_after);
-
-    // Resets the iterator back to the beginning.
-    void Reset();
-
-    // Resets the iterator, resuming from the |starting_after| reference.
-    void Reset(Reference starting_after);
-
-    // Returns the previously retrieved reference, or kReferenceNull if none.
-    // If constructor or reset with a starting_after location, this will return
-    // that value.
-    Reference GetLast();
-
-    // Gets the next iterable, storing that type in |type_return|. The actual
-    // return value is a reference to the allocation inside the allocator or
-    // zero if there are no more. GetNext() may still be called again at a
-    // later time to retrieve any new allocations that have been added.
-    Reference GetNext(uint32_t* type_return);
-
-    // Similar to above but gets the next iterable of a specific |type_match|.
-    // This should not be mixed with calls to GetNext() because any allocations
-    // skipped here due to a type mis-match will never be returned by later
-    // calls to GetNext() meaning it's possible to completely miss entries.
-    Reference GetNextOfType(uint32_t type_match);
-
-    // As above but works using object type.
-    template <typename T>
-    Reference GetNextOfType() {
-      return GetNextOfType(T::kPersistentTypeId);
-    }
-
-    // As above but works using objects and returns null if not found.
-    template <typename T>
-    const T* GetNextOfObject() {
-      return GetAsObject<T>(GetNextOfType<T>());
-    }
-
-    // Converts references to objects. This is a convenience method so that
-    // users of the iterator don't need to also have their own pointer to the
-    // allocator over which the iterator runs in order to retrieve objects.
-    // Because the iterator is not read/write, only "const" objects can be
-    // fetched. Non-const objects can be fetched using the reference on a
-    // non-const (external) pointer to the same allocator (or use const_cast
-    // to remove the qualifier).
-    template <typename T>
-    const T* GetAsObject(Reference ref) const {
-      return allocator_->GetAsObject<T>(ref);
-    }
-
-    // Similar to GetAsObject() but converts references to arrays of things.
-    template <typename T>
-    const T* GetAsArray(Reference ref, uint32_t type_id, size_t count) const {
-      return allocator_->GetAsArray<T>(ref, type_id, count);
-    }
-
-    // Convert a generic pointer back into a reference. A null reference will
-    // be returned if |memory| is not inside the persistent segment or does not
-    // point to an object of the specified |type_id|.
-    Reference GetAsReference(const void* memory, uint32_t type_id) const {
-      return allocator_->GetAsReference(memory, type_id);
-    }
-
-    // As above but convert an object back into a reference.
-    template <typename T>
-    Reference GetAsReference(const T* obj) const {
-      return allocator_->GetAsReference(obj);
-    }
-
-   private:
-    // Weak-pointer to memory allocator being iterated over.
-    const PersistentMemoryAllocator* allocator_;
-
-    // The last record that was returned.
-    std::atomic<Reference> last_record_;
-
-    // The number of records found; used for detecting loops.
-    std::atomic<uint32_t> record_count_;
-
-    DISALLOW_COPY_AND_ASSIGN(Iterator);
-  };
-
-  // Returned information about the internal state of the heap.
-  struct MemoryInfo {
-    size_t total;
-    size_t free;
-  };
-
-  enum : Reference {
-    // A common "null" reference value.
-    kReferenceNull = 0,
-  };
-
-  enum : uint32_t {
-    // A value that will match any type when doing lookups.
-    kTypeIdAny = 0x00000000,
-
-    // A value indicating that the type is in transition. Work is being done
-    // on the contents to prepare it for a new type to come.
-    kTypeIdTransitioning = 0xFFFFFFFF,
-  };
-
-  enum : size_t {
-    kSizeAny = 1  // Constant indicating that any array size is acceptable.
-  };
-
-  // This is the standard file extension (suitable for being passed to the
-  // AddExtension() method of base::FilePath) for dumps of persistent memory.
-  static const base::FilePath::CharType kFileExtension[];
-
-  // The allocator operates on any arbitrary block of memory. Creation and
-  // persisting or sharing of that block with another process is the
-  // responsibility of the caller. The allocator needs to know only the
-  // block's |base| address, the total |size| of the block, and any internal
-  // |page| size (zero if not paged) across which allocations should not span.
-  // The |id| is an arbitrary value the caller can use to identify a
-  // particular memory segment. It will only be loaded during the initial
-  // creation of the segment and can be checked by the caller for consistency.
-  // The |name|, if provided, is used to distinguish histograms for this
-  // allocator. Only the primary owner of the segment should define this value;
-  // other processes can learn it from the shared state. If the underlying
-  // memory is |readonly| then no changes will be made to it. The resulting
-  // object should be stored as a "const" pointer.
-  //
-  // PersistentMemoryAllocator does NOT take ownership of the memory block.
-  // The caller must manage it and ensure it stays available throughout the
-  // lifetime of this object.
-  //
-  // Memory segments for sharing must have had an allocator attached to them
-  // before actually being shared. If the memory segment was just created, it
-  // should be zeroed before being passed here. If it was an existing segment,
-  // the values here will be compared to copies stored in the shared segment
-  // as a guard against corruption.
-  //
-  // Make sure that the memory segment is acceptable (see IsMemoryAcceptable()
-  // method below) before construction if the definition of the segment can
-  // vary in any way at run-time. Invalid memory segments will cause a crash.
-  PersistentMemoryAllocator(void* base, size_t size, size_t page_size,
-                            uint64_t id, base::StringPiece name,
-                            bool readonly);
-  virtual ~PersistentMemoryAllocator();
-
-  // Check if memory segment is acceptable for creation of an Allocator. This
-  // doesn't do any analysis of the data and so doesn't guarantee that the
-  // contents are valid, just that the paramaters won't cause the program to
-  // abort. The IsCorrupt() method will report detection of data problems
-  // found during construction and general operation.
-  static bool IsMemoryAcceptable(const void* data, size_t size,
-                                 size_t page_size, bool readonly);
-
-  // Get the internal identifier for this persistent memory segment.
-  uint64_t Id() const;
-
-  // Get the internal name of this allocator (possibly an empty string).
-  const char* Name() const;
-
-  // Is this segment open only for read?
-  bool IsReadonly() const { return readonly_; }
-
-  // Manage the saved state of the memory.
-  void SetMemoryState(uint8_t memory_state);
-  uint8_t GetMemoryState() const;
-
-  // Create internal histograms for tracking memory use and allocation sizes
-  // for allocator of |name| (which can simply be the result of Name()). This
-  // is done seperately from construction for situations such as when the
-  // histograms will be backed by memory provided by this very allocator.
-  //
-  // IMPORTANT: Callers must update tools/metrics/histograms/histograms.xml
-  // with the following histograms:
-  //    UMA.PersistentAllocator.name.Errors
-  //    UMA.PersistentAllocator.name.UsedPct
-  void CreateTrackingHistograms(base::StringPiece name);
-
-  // Flushes the persistent memory to any backing store. This typically does
-  // nothing but is used by the FilePersistentMemoryAllocator to inform the
-  // OS that all the data should be sent to the disk immediately. This is
-  // useful in the rare case where something has just been stored that needs
-  // to survive a hard shutdown of the machine like from a power failure.
-  // The |sync| parameter indicates if this call should block until the flush
-  // is complete but is only advisory and may or may not have an effect
-  // depending on the capabilities of the OS. Synchronous flushes are allowed
-  // only from theads that are allowed to do I/O but since |sync| is only
-  // advisory, all flushes should be done on IO-capable threads.
-  void Flush(bool sync);
-
-  // Direct access to underlying memory segment. If the segment is shared
-  // across threads or processes, reading data through these values does
-  // not guarantee consistency. Use with care. Do not write.
-  const void* data() const { return const_cast<const char*>(mem_base_); }
-  size_t length() const { return mem_size_; }
-  size_t size() const { return mem_size_; }
-  size_t used() const;
-
-  // Get an object referenced by a |ref|. For safety reasons, the |type_id|
-  // code and size-of(|T|) are compared to ensure the reference is valid
-  // and cannot return an object outside of the memory segment. A |type_id| of
-  // kTypeIdAny (zero) will match any though the size is still checked. NULL is
-  // returned if any problem is detected, such as corrupted storage or incorrect
-  // parameters. Callers MUST check that the returned value is not-null EVERY
-  // TIME before accessing it or risk crashing! Once dereferenced, the pointer
-  // is safe to reuse forever.
-  //
-  // It is essential that the object be of a fixed size. All fields must be of
-  // a defined type that does not change based on the compiler or the CPU
-  // natural word size. Acceptable are char, float, double, and (u)intXX_t.
-  // Unacceptable are int, bool, and wchar_t which are implementation defined
-  // with regards to their size.
-  //
-  // Alignment must also be consistent. A uint64_t after a uint32_t will pad
-  // differently between 32 and 64 bit architectures. Either put the bigger
-  // elements first, group smaller elements into blocks the size of larger
-  // elements, or manually insert padding fields as appropriate for the
-  // largest architecture, including at the end.
-  //
-  // To protected against mistakes, all objects must have the attribute
-  // |kExpectedInstanceSize| (static constexpr size_t)  that is a hard-coded
-  // numerical value -- NNN, not sizeof(T) -- that can be tested. If the
-  // instance size is not fixed, at least one build will fail.
-  //
-  // If the size of a structure changes, the type-ID used to recognize it
-  // should also change so later versions of the code don't try to read
-  // incompatible structures from earlier versions.
-  //
-  // NOTE: Though this method will guarantee that an object of the specified
-  // type can be accessed without going outside the bounds of the memory
-  // segment, it makes no guarantees of the validity of the data within the
-  // object itself. If it is expected that the contents of the segment could
-  // be compromised with malicious intent, the object must be hardened as well.
-  //
-  // Though the persistent data may be "volatile" if it is shared with
-  // other processes, such is not necessarily the case. The internal
-  // "volatile" designation is discarded so as to not propagate the viral
-  // nature of that keyword to the caller. It can add it back, if necessary,
-  // based on knowledge of how the allocator is being used.
-  template <typename T>
-  T* GetAsObject(Reference ref) {
-    static_assert(std::is_standard_layout<T>::value, "only standard objects");
-    static_assert(!std::is_array<T>::value, "use GetAsArray<>()");
-    static_assert(T::kExpectedInstanceSize == sizeof(T), "inconsistent size");
-    return const_cast<T*>(reinterpret_cast<volatile T*>(
-        GetBlockData(ref, T::kPersistentTypeId, sizeof(T))));
-  }
-  template <typename T>
-  const T* GetAsObject(Reference ref) const {
-    static_assert(std::is_standard_layout<T>::value, "only standard objects");
-    static_assert(!std::is_array<T>::value, "use GetAsArray<>()");
-    static_assert(T::kExpectedInstanceSize == sizeof(T), "inconsistent size");
-    return const_cast<const T*>(reinterpret_cast<const volatile T*>(
-        GetBlockData(ref, T::kPersistentTypeId, sizeof(T))));
-  }
-
-  // Like GetAsObject but get an array of simple, fixed-size types.
-  //
-  // Use a |count| of the required number of array elements, or kSizeAny.
-  // GetAllocSize() can be used to calculate the upper bound but isn't reliable
-  // because padding can make space for extra elements that were not written.
-  //
-  // Remember that an array of char is a string but may not be NUL terminated.
-  //
-  // There are no compile-time or run-time checks to ensure 32/64-bit size
-  // compatibilty when using these accessors. Only use fixed-size types such
-  // as char, float, double, or (u)intXX_t.
-  template <typename T>
-  T* GetAsArray(Reference ref, uint32_t type_id, size_t count) {
-    static_assert(std::is_fundamental<T>::value, "use GetAsObject<>()");
-    return const_cast<T*>(reinterpret_cast<volatile T*>(
-        GetBlockData(ref, type_id, count * sizeof(T))));
-  }
-  template <typename T>
-  const T* GetAsArray(Reference ref, uint32_t type_id, size_t count) const {
-    static_assert(std::is_fundamental<T>::value, "use GetAsObject<>()");
-    return const_cast<const char*>(reinterpret_cast<const volatile T*>(
-        GetBlockData(ref, type_id, count * sizeof(T))));
-  }
-
-  // Get the corresponding reference for an object held in persistent memory.
-  // If the |memory| is not valid or the type does not match, a kReferenceNull
-  // result will be returned.
-  Reference GetAsReference(const void* memory, uint32_t type_id) const;
-
-  // Get the number of bytes allocated to a block. This is useful when storing
-  // arrays in order to validate the ending boundary. The returned value will
-  // include any padding added to achieve the required alignment and so could
-  // be larger than given in the original Allocate() request.
-  size_t GetAllocSize(Reference ref) const;
-
-  // Access the internal "type" of an object. This generally isn't necessary
-  // but can be used to "clear" the type and so effectively mark it as deleted
-  // even though the memory stays valid and allocated. Changing the type is
-  // an atomic compare/exchange and so requires knowing the existing value.
-  // It will return false if the existing type is not what is expected.
-  //
-  // Changing the type doesn't mean the data is compatible with the new type.
-  // Passing true for |clear| will zero the memory after the type has been
-  // changed away from |from_type_id| but before it becomes |to_type_id| meaning
-  // that it is done in a manner that is thread-safe. Memory is guaranteed to
-  // be zeroed atomically by machine-word in a monotonically increasing order.
-  //
-  // It will likely be necessary to reconstruct the type before it can be used.
-  // Changing the type WILL NOT invalidate existing pointers to the data, either
-  // in this process or others, so changing the data structure could have
-  // unpredicatable results. USE WITH CARE!
-  uint32_t GetType(Reference ref) const;
-  bool ChangeType(Reference ref,
-                  uint32_t to_type_id,
-                  uint32_t from_type_id,
-                  bool clear);
-
-  // Allocated objects can be added to an internal list that can then be
-  // iterated over by other processes. If an allocated object can be found
-  // another way, such as by having its reference within a different object
-  // that will be made iterable, then this call is not necessary. This always
-  // succeeds unless corruption is detected; check IsCorrupted() to find out.
-  // Once an object is made iterable, its position in iteration can never
-  // change; new iterable objects will always be added after it in the series.
-  // Changing the type does not alter its "iterable" status.
-  void MakeIterable(Reference ref);
-
-  // Get the information about the amount of free space in the allocator. The
-  // amount of free space should be treated as approximate due to extras from
-  // alignment and metadata. Concurrent allocations from other threads will
-  // also make the true amount less than what is reported.
-  void GetMemoryInfo(MemoryInfo* meminfo) const;
-
-  // If there is some indication that the memory has become corrupted,
-  // calling this will attempt to prevent further damage by indicating to
-  // all processes that something is not as expected.
-  void SetCorrupt() const;
-
-  // This can be called to determine if corruption has been detected in the
-  // segment, possibly my a malicious actor. Once detected, future allocations
-  // will fail and iteration may not locate all objects.
-  bool IsCorrupt() const;
-
-  // Flag set if an allocation has failed because the memory segment was full.
-  bool IsFull() const;
-
-  // Update those "tracking" histograms which do not get updates during regular
-  // operation, such as how much memory is currently used. This should be
-  // called before such information is to be displayed or uploaded.
-  void UpdateTrackingHistograms();
-
-  // While the above works much like malloc & free, these next methods provide
-  // an "object" interface similar to new and delete.
-
-  // Reserve space in the memory segment of the desired |size| and |type_id|.
-  // A return value of zero indicates the allocation failed, otherwise the
-  // returned reference can be used by any process to get a real pointer via
-  // the GetAsObject() or GetAsArray calls. The actual allocated size may be
-  // larger and will always be a multiple of 8 bytes (64 bits).
-  Reference Allocate(size_t size, uint32_t type_id);
-
-  // Allocate and construct an object in persistent memory. The type must have
-  // both (size_t) kExpectedInstanceSize and (uint32_t) kPersistentTypeId
-  // static constexpr fields that are used to ensure compatibility between
-  // software versions. An optional size parameter can be specified to force
-  // the allocation to be bigger than the size of the object; this is useful
-  // when the last field is actually variable length.
-  template <typename T>
-  T* New(size_t size) {
-    if (size < sizeof(T))
-      size = sizeof(T);
-    Reference ref = Allocate(size, T::kPersistentTypeId);
-    void* mem =
-        const_cast<void*>(GetBlockData(ref, T::kPersistentTypeId, size));
-    if (!mem)
-      return nullptr;
-    DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(mem) & (alignof(T) - 1));
-    return new (mem) T();
-  }
-  template <typename T>
-  T* New() {
-    return New<T>(sizeof(T));
-  }
-
-  // Similar to New, above, but construct the object out of an existing memory
-  // block and of an expected type. If |clear| is true, memory will be zeroed
-  // before construction. Though this is not standard object behavior, it
-  // is present to match with new allocations that always come from zeroed
-  // memory. Anything previously present simply ceases to exist; no destructor
-  // is called for it so explicitly Delete() the old object first if need be.
-  // Calling this will not invalidate existing pointers to the object, either
-  // in this process or others, so changing the object could have unpredictable
-  // results. USE WITH CARE!
-  template <typename T>
-  T* New(Reference ref, uint32_t from_type_id, bool clear) {
-    DCHECK_LE(sizeof(T), GetAllocSize(ref)) << "alloc not big enough for obj";
-    // Make sure the memory is appropriate. This won't be used until after
-    // the type is changed but checking first avoids the possibility of having
-    // to change the type back.
-    void* mem = const_cast<void*>(GetBlockData(ref, 0, sizeof(T)));
-    if (!mem)
-      return nullptr;
-    // Ensure the allocator's internal alignment is sufficient for this object.
-    // This protects against coding errors in the allocator.
-    DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(mem) & (alignof(T) - 1));
-    // Change the type, clearing the memory if so desired. The new type is
-    // "transitioning" so that there is no race condition with the construction
-    // of the object should another thread be simultaneously iterating over
-    // data. This will "acquire" the memory so no changes get reordered before
-    // it.
-    if (!ChangeType(ref, kTypeIdTransitioning, from_type_id, clear))
-      return nullptr;
-    // Construct an object of the desired type on this memory, just as if
-    // New() had been called to create it.
-    T* obj = new (mem) T();
-    // Finally change the type to the desired one. This will "release" all of
-    // the changes above and so provide a consistent view to other threads.
-    bool success =
-        ChangeType(ref, T::kPersistentTypeId, kTypeIdTransitioning, false);
-    DCHECK(success);
-    return obj;
-  }
-
-  // Deletes an object by destructing it and then changing the type to a
-  // different value (default 0).
-  template <typename T>
-  void Delete(T* obj, uint32_t new_type) {
-    // Get the reference for the object.
-    Reference ref = GetAsReference<T>(obj);
-    // First change the type to "transitioning" so there is no race condition
-    // where another thread could find the object through iteration while it
-    // is been destructed. This will "acquire" the memory so no changes get
-    // reordered before it. It will fail if |ref| is invalid.
-    if (!ChangeType(ref, kTypeIdTransitioning, T::kPersistentTypeId, false))
-      return;
-    // Destruct the object.
-    obj->~T();
-    // Finally change the type to the desired value. This will "release" all
-    // the changes above.
-    bool success = ChangeType(ref, new_type, kTypeIdTransitioning, false);
-    DCHECK(success);
-  }
-  template <typename T>
-  void Delete(T* obj) {
-    Delete<T>(obj, 0);
-  }
-
-  // As above but works with objects allocated from persistent memory.
-  template <typename T>
-  Reference GetAsReference(const T* obj) const {
-    return GetAsReference(obj, T::kPersistentTypeId);
-  }
-
-  // As above but works with an object allocated from persistent memory.
-  template <typename T>
-  void MakeIterable(const T* obj) {
-    MakeIterable(GetAsReference<T>(obj));
-  }
-
- protected:
-  enum MemoryType {
-    MEM_EXTERNAL,
-    MEM_MALLOC,
-    MEM_VIRTUAL,
-    MEM_SHARED,
-    MEM_FILE,
-  };
-
-  struct Memory {
-    Memory(void* b, MemoryType t) : base(b), type(t) {}
-
-    void* base;
-    MemoryType type;
-  };
-
-  // Constructs the allocator. Everything is the same as the public allocator
-  // except |memory| which is a structure with additional information besides
-  // the base address.
-  PersistentMemoryAllocator(Memory memory, size_t size, size_t page_size,
-                            uint64_t id, base::StringPiece name,
-                            bool readonly);
-
-  // Implementation of Flush that accepts how much to flush.
-  virtual void FlushPartial(size_t length, bool sync);
-
-  volatile char* const mem_base_;  // Memory base. (char so sizeof guaranteed 1)
-  const MemoryType mem_type_;      // Type of memory allocation.
-  const uint32_t mem_size_;        // Size of entire memory segment.
-  const uint32_t mem_page_;        // Page size allocations shouldn't cross.
-
- private:
-  struct SharedMetadata;
-  struct BlockHeader;
-  static const uint32_t kAllocAlignment;
-  static const Reference kReferenceQueue;
-
-  // The shared metadata is always located at the top of the memory segment.
-  // These convenience functions eliminate constant casting of the base
-  // pointer within the code.
-  const SharedMetadata* shared_meta() const {
-    return reinterpret_cast<const SharedMetadata*>(
-        const_cast<const char*>(mem_base_));
-  }
-  SharedMetadata* shared_meta() {
-    return reinterpret_cast<SharedMetadata*>(const_cast<char*>(mem_base_));
-  }
-
-  // Actual method for doing the allocation.
-  Reference AllocateImpl(size_t size, uint32_t type_id);
-
-  // Get the block header associated with a specific reference.
-  const volatile BlockHeader* GetBlock(Reference ref, uint32_t type_id,
-                                       uint32_t size, bool queue_ok,
-                                       bool free_ok) const;
-  volatile BlockHeader* GetBlock(Reference ref, uint32_t type_id, uint32_t size,
-                                 bool queue_ok, bool free_ok) {
-      return const_cast<volatile BlockHeader*>(
-          const_cast<const PersistentMemoryAllocator*>(this)->GetBlock(
-              ref, type_id, size, queue_ok, free_ok));
-  }
-
-  // Get the actual data within a block associated with a specific reference.
-  const volatile void* GetBlockData(Reference ref, uint32_t type_id,
-                                    uint32_t size) const;
-  volatile void* GetBlockData(Reference ref, uint32_t type_id,
-                              uint32_t size) {
-      return const_cast<volatile void*>(
-          const_cast<const PersistentMemoryAllocator*>(this)->GetBlockData(
-              ref, type_id, size));
-  }
-
-  // Record an error in the internal histogram.
-  void RecordError(int error) const;
-
-  const size_t vm_page_size_;          // The page size used by the OS.
-  const bool readonly_;                // Indicates access to read-only memory.
-  mutable std::atomic<bool> corrupt_;  // Local version of "corrupted" flag.
-
-  HistogramBase* allocs_histogram_;  // Histogram recording allocs.
-  HistogramBase* used_histogram_;    // Histogram recording used space.
-  HistogramBase* errors_histogram_;  // Histogram recording errors.
-
-  friend class PersistentMemoryAllocatorTest;
-  FRIEND_TEST_ALL_PREFIXES(PersistentMemoryAllocatorTest, AllocateAndIterate);
-  DISALLOW_COPY_AND_ASSIGN(PersistentMemoryAllocator);
-};
-
-
-// This allocator uses a local memory block it allocates from the general
-// heap. It is generally used when some kind of "death rattle" handler will
-// save the contents to persistent storage during process shutdown. It is
-// also useful for testing.
-class BASE_EXPORT LocalPersistentMemoryAllocator
-    : public PersistentMemoryAllocator {
- public:
-  LocalPersistentMemoryAllocator(size_t size, uint64_t id,
-                                 base::StringPiece name);
-  ~LocalPersistentMemoryAllocator() override;
-
- private:
-  // Allocates a block of local memory of the specified |size|, ensuring that
-  // the memory will not be physically allocated until accessed and will read
-  // as zero when that happens.
-  static Memory AllocateLocalMemory(size_t size);
-
-  // Deallocates a block of local |memory| of the specified |size|.
-  static void DeallocateLocalMemory(void* memory, size_t size, MemoryType type);
-
-  DISALLOW_COPY_AND_ASSIGN(LocalPersistentMemoryAllocator);
-};
-
-
-// This allocator takes a shared-memory object and performs allocation from
-// it. The memory must be previously mapped via Map() or MapAt(). The allocator
-// takes ownership of the memory object.
-class BASE_EXPORT SharedPersistentMemoryAllocator
-    : public PersistentMemoryAllocator {
- public:
-  SharedPersistentMemoryAllocator(std::unique_ptr<SharedMemory> memory,
-                                  uint64_t id,
-                                  base::StringPiece name,
-                                  bool read_only);
-  ~SharedPersistentMemoryAllocator() override;
-
-  SharedMemory* shared_memory() { return shared_memory_.get(); }
-
-  // Ensure that the memory isn't so invalid that it would crash when passing it
-  // to the allocator. This doesn't guarantee the data is valid, just that it
-  // won't cause the program to abort. The existing IsCorrupt() call will handle
-  // the rest.
-  static bool IsSharedMemoryAcceptable(const SharedMemory& memory);
-
- private:
-  std::unique_ptr<SharedMemory> shared_memory_;
-
-  DISALLOW_COPY_AND_ASSIGN(SharedPersistentMemoryAllocator);
-};
-
-
-#if !defined(OS_NACL)  // NACL doesn't support any kind of file access in build.
-// This allocator takes a memory-mapped file object and performs allocation
-// from it. The allocator takes ownership of the file object.
-class BASE_EXPORT FilePersistentMemoryAllocator
-    : public PersistentMemoryAllocator {
- public:
-  // A |max_size| of zero will use the length of the file as the maximum
-  // size. The |file| object must have been already created with sufficient
-  // permissions (read, read/write, or read/write/extend).
-  FilePersistentMemoryAllocator(std::unique_ptr<MemoryMappedFile> file,
-                                size_t max_size,
-                                uint64_t id,
-                                base::StringPiece name,
-                                bool read_only);
-  ~FilePersistentMemoryAllocator() override;
-
-  // Ensure that the file isn't so invalid that it would crash when passing it
-  // to the allocator. This doesn't guarantee the file is valid, just that it
-  // won't cause the program to abort. The existing IsCorrupt() call will handle
-  // the rest.
-  static bool IsFileAcceptable(const MemoryMappedFile& file, bool read_only);
-
- protected:
-  // PersistentMemoryAllocator:
-  void FlushPartial(size_t length, bool sync) override;
-
- private:
-  std::unique_ptr<MemoryMappedFile> mapped_file_;
-
-  DISALLOW_COPY_AND_ASSIGN(FilePersistentMemoryAllocator);
-};
-#endif  // !defined(OS_NACL)
-
-// An allocation that is defined but not executed until required at a later
-// time. This allows for potential users of an allocation to be decoupled
-// from the logic that defines it. In addition, there can be multiple users
-// of the same allocation or any region thereof that are guaranteed to always
-// use the same space. It's okay to copy/move these objects.
-//
-// This is a top-level class instead of an inner class of the PMA so that it
-// can be forward-declared in other header files without the need to include
-// the full contents of this file.
-class BASE_EXPORT DelayedPersistentAllocation {
- public:
-  using Reference = PersistentMemoryAllocator::Reference;
-
-  // Creates a delayed allocation using the specified |allocator|. When
-  // needed, the memory will be allocated using the specified |type| and
-  // |size|. If |offset| is given, the returned pointer will be at that
-  // offset into the segment; this allows combining allocations into a
-  // single persistent segment to reduce overhead and means an "all or
-  // nothing" request. Note that |size| is always the total memory size
-  // and |offset| is just indicating the start of a block within it.  If
-  // |make_iterable| was true, the allocation will made iterable when it
-  // is created; already existing allocations are not changed.
-  //
-  // Once allocated, a reference to the segment will be stored at |ref|.
-  // This shared location must be initialized to zero (0); it is checked
-  // with every Get() request to see if the allocation has already been
-  // done. If reading |ref| outside of this object, be sure to do an
-  // "acquire" load. Don't write to it -- leave that to this object.
-  //
-  // For convenience, methods taking both Atomic32 and std::atomic<Reference>
-  // are defined.
-  DelayedPersistentAllocation(PersistentMemoryAllocator* allocator,
-                              subtle::Atomic32* ref,
-                              uint32_t type,
-                              size_t size,
-                              bool make_iterable);
-  DelayedPersistentAllocation(PersistentMemoryAllocator* allocator,
-                              subtle::Atomic32* ref,
-                              uint32_t type,
-                              size_t size,
-                              size_t offset,
-                              bool make_iterable);
-  DelayedPersistentAllocation(PersistentMemoryAllocator* allocator,
-                              std::atomic<Reference>* ref,
-                              uint32_t type,
-                              size_t size,
-                              bool make_iterable);
-  DelayedPersistentAllocation(PersistentMemoryAllocator* allocator,
-                              std::atomic<Reference>* ref,
-                              uint32_t type,
-                              size_t size,
-                              size_t offset,
-                              bool make_iterable);
-  ~DelayedPersistentAllocation();
-
-  // Gets a pointer to the defined allocation. This will realize the request
-  // and update the reference provided during construction. The memory will
-  // be zeroed the first time it is returned, after that it is shared with
-  // all other Get() requests and so shows any changes made to it elsewhere.
-  //
-  // If the allocation fails for any reason, null will be returned. This works
-  // even on "const" objects because the allocation is already defined, just
-  // delayed.
-  void* Get() const;
-
-  // Gets the internal reference value. If this returns a non-zero value then
-  // a subsequent call to Get() will do nothing but convert that reference into
-  // a memory location -- useful for accessing an existing allocation without
-  // creating one unnecessarily.
-  Reference reference() const {
-    return reference_->load(std::memory_order_relaxed);
-  }
-
- private:
-  // The underlying object that does the actual allocation of memory. Its
-  // lifetime must exceed that of all DelayedPersistentAllocation objects
-  // that use it.
-  PersistentMemoryAllocator* const allocator_;
-
-  // The desired type and size of the allocated segment plus the offset
-  // within it for the defined request.
-  const uint32_t type_;
-  const uint32_t size_;
-  const uint32_t offset_;
-
-  // Flag indicating if allocation should be made iterable when done.
-  const bool make_iterable_;
-
-  // The location at which a reference to the allocated segment is to be
-  // stored once the allocation is complete. If multiple delayed allocations
-  // share the same pointer then an allocation on one will amount to an
-  // allocation for all.
-  volatile std::atomic<Reference>* const reference_;
-
-  // No DISALLOW_COPY_AND_ASSIGN as it's okay to copy/move these objects.
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_PERSISTENT_MEMORY_ALLOCATOR_H_
diff --git a/native/zucchini/vendor/libchrome/base/metrics/sparse_histogram.h b/native/zucchini/vendor/libchrome/base/metrics/sparse_histogram.h
deleted file mode 100644
index 913762c..0000000
--- a/native/zucchini/vendor/libchrome/base/metrics/sparse_histogram.h
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_METRICS_SPARSE_HISTOGRAM_H_
-#define BASE_METRICS_SPARSE_HISTOGRAM_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <memory>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/metrics/histogram_base.h"
-#include "base/metrics/histogram_samples.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-class HistogramSamples;
-class PersistentHistogramAllocator;
-class Pickle;
-class PickleIterator;
-
-class BASE_EXPORT SparseHistogram : public HistogramBase {
- public:
-  // If there's one with same name, return the existing one. If not, create a
-  // new one.
-  static HistogramBase* FactoryGet(const std::string& name, int32_t flags);
-
-  // Create a histogram using data in persistent storage. The allocator must
-  // live longer than the created sparse histogram.
-  static std::unique_ptr<HistogramBase> PersistentCreate(
-      PersistentHistogramAllocator* allocator,
-      const char* name,
-      HistogramSamples::Metadata* meta,
-      HistogramSamples::Metadata* logged_meta);
-
-  ~SparseHistogram() override;
-
-  // HistogramBase implementation:
-  uint64_t name_hash() const override;
-  HistogramType GetHistogramType() const override;
-  bool HasConstructionArguments(Sample expected_minimum,
-                                Sample expected_maximum,
-                                uint32_t expected_bucket_count) const override;
-  void Add(Sample value) override;
-  void AddCount(Sample value, int count) override;
-  void AddSamples(const HistogramSamples& samples) override;
-  bool AddSamplesFromPickle(base::PickleIterator* iter) override;
-  std::unique_ptr<HistogramSamples> SnapshotSamples() const override;
-  std::unique_ptr<HistogramSamples> SnapshotDelta() override;
-  std::unique_ptr<HistogramSamples> SnapshotFinalDelta() const override;
-  void WriteHTMLGraph(std::string* output) const override;
-  void WriteAscii(std::string* output) const override;
-
- protected:
-  // HistogramBase implementation:
-  void SerializeInfoImpl(base::Pickle* pickle) const override;
-
- private:
-  // Clients should always use FactoryGet to create SparseHistogram.
-  explicit SparseHistogram(const char* name);
-
-  SparseHistogram(PersistentHistogramAllocator* allocator,
-                  const char* name,
-                  HistogramSamples::Metadata* meta,
-                  HistogramSamples::Metadata* logged_meta);
-
-  friend BASE_EXPORT HistogramBase* DeserializeHistogramInfo(
-      base::PickleIterator* iter);
-  static HistogramBase* DeserializeInfoImpl(base::PickleIterator* iter);
-
-  void GetParameters(DictionaryValue* params) const override;
-  void GetCountAndBucketData(Count* count,
-                             int64_t* sum,
-                             ListValue* buckets) const override;
-
-  // Helpers for emitting Ascii graphic.  Each method appends data to output.
-  void WriteAsciiImpl(bool graph_it,
-                      const std::string& newline,
-                      std::string* output) const;
-
-  // Write a common header message describing this histogram.
-  void WriteAsciiHeader(const Count total_count,
-                        std::string* output) const;
-
-  // For constuctor calling.
-  friend class SparseHistogramTest;
-
-  // Protects access to |samples_|.
-  mutable base::Lock lock_;
-
-  // Flag to indicate if PrepareFinalDelta has been previously called.
-  mutable bool final_delta_created_ = false;
-
-  std::unique_ptr<HistogramSamples> unlogged_samples_;
-  std::unique_ptr<HistogramSamples> logged_samples_;
-
-  DISALLOW_COPY_AND_ASSIGN(SparseHistogram);
-};
-
-}  // namespace base
-
-#endif  // BASE_METRICS_SPARSE_HISTOGRAM_H_
diff --git a/native/zucchini/vendor/libchrome/base/no_destructor.h b/native/zucchini/vendor/libchrome/base/no_destructor.h
deleted file mode 100644
index aabc6e6..0000000
--- a/native/zucchini/vendor/libchrome/base/no_destructor.h
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_NO_DESTRUCTOR_H_
-#define BASE_NO_DESTRUCTOR_H_
-
-#include <new>
-#include <utility>
-
-namespace base {
-
-// A wrapper that makes it easy to create an object of type T with static
-// storage duration that:
-// - is only constructed on first access
-// - never invokes the destructor
-// in order to satisfy the styleguide ban on global constructors and
-// destructors.
-//
-// Runtime constant example:
-// const std::string& GetLineSeparator() {
-//  // Forwards to std::string(size_t, char, const Allocator&) constructor.
-//   static const base::NoDestructor<std::string> s(5, '-');
-//   return *s;
-// }
-//
-// More complex initialization with a lambda:
-// const std::string& GetSessionNonce() {
-//   static const base::NoDestructor<std::string> nonce([] {
-//     std::string s(16);
-//     crypto::RandString(s.data(), s.size());
-//     return s;
-//   }());
-//   return *nonce;
-// }
-//
-// NoDestructor<T> stores the object inline, so it also avoids a pointer
-// indirection and a malloc. Also note that since C++11 static local variable
-// initialization is thread-safe and so is this pattern. Code should prefer to
-// use NoDestructor<T> over:
-// - The CR_DEFINE_STATIC_LOCAL() helper macro.
-// - A function scoped static T* or T& that is dynamically initialized.
-// - A global base::LazyInstance<T>.
-//
-// Note that since the destructor is never run, this *will* leak memory if used
-// as a stack or member variable. Furthermore, a NoDestructor<T> should never
-// have global scope as that may require a static initializer.
-template <typename T>
-class NoDestructor {
- public:
-  // Not constexpr; just write static constexpr T x = ...; if the value should
-  // be a constexpr.
-  template <typename... Args>
-  explicit NoDestructor(Args&&... args) {
-    new (storage_) T(std::forward<Args>(args)...);
-  }
-
-  // Allows copy and move construction of the contained type, to allow
-  // construction from an initializer list, e.g. for std::vector.
-  explicit NoDestructor(const T& x) { new (storage_) T(x); }
-  explicit NoDestructor(T&& x) { new (storage_) T(std::move(x)); }
-
-  NoDestructor(const NoDestructor&) = delete;
-  NoDestructor& operator=(const NoDestructor&) = delete;
-
-  ~NoDestructor() = default;
-
-  const T& operator*() const { return *get(); }
-  T& operator*() { return *get(); }
-
-  const T* operator->() const { return get(); }
-  T* operator->() { return get(); }
-
-  const T* get() const { return reinterpret_cast<const T*>(storage_); }
-  T* get() { return reinterpret_cast<T*>(storage_); }
-
- private:
-  alignas(T) char storage_[sizeof(T)];
-
-#if defined(LEAK_SANITIZER)
-  // TODO(https://crbug.com/812277): This is a hack to work around the fact
-  // that LSan doesn't seem to treat NoDestructor as a root for reachability
-  // analysis. This means that code like this:
-  //   static base::NoDestructor<std::vector<int>> v({1, 2, 3});
-  // is considered a leak. Using the standard leak sanitizer annotations to
-  // suppress leaks doesn't work: std::vector is implicitly constructed before
-  // calling the base::NoDestructor constructor.
-  //
-  // Unfortunately, I haven't been able to demonstrate this issue in simpler
-  // reproductions: until that's resolved, hold an explicit pointer to the
-  // placement-new'd object in leak sanitizer mode to help LSan realize that
-  // objects allocated by the contained type are still reachable.
-  T* storage_ptr_ = reinterpret_cast<T*>(storage_);
-#endif  // defined(LEAK_SANITIZER)
-};
-
-}  // namespace base
-
-#endif  // BASE_NO_DESTRUCTOR_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/checked_math.h b/native/zucchini/vendor/libchrome/base/numerics/checked_math.h
deleted file mode 100644
index ede3344..0000000
--- a/native/zucchini/vendor/libchrome/base/numerics/checked_math.h
+++ /dev/null
@@ -1,393 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_NUMERICS_CHECKED_MATH_H_
-#define BASE_NUMERICS_CHECKED_MATH_H_
-
-#include <stddef.h>
-
-#include <limits>
-#include <type_traits>
-
-#include "base/numerics/checked_math_impl.h"
-
-namespace base {
-namespace internal {
-
-template <typename T>
-class CheckedNumeric {
-  static_assert(std::is_arithmetic<T>::value,
-                "CheckedNumeric<T>: T must be a numeric type.");
-
- public:
-  using type = T;
-
-  constexpr CheckedNumeric() = default;
-
-  // Copy constructor.
-  template <typename Src>
-  constexpr CheckedNumeric(const CheckedNumeric<Src>& rhs)
-      : state_(rhs.state_.value(), rhs.IsValid()) {}
-
-  template <typename Src>
-  friend class CheckedNumeric;
-
-  // This is not an explicit constructor because we implicitly upgrade regular
-  // numerics to CheckedNumerics to make them easier to use.
-  template <typename Src>
-  constexpr CheckedNumeric(Src value)  // NOLINT(runtime/explicit)
-      : state_(value) {
-    static_assert(std::is_arithmetic<Src>::value, "Argument must be numeric.");
-  }
-
-  // This is not an explicit constructor because we want a seamless conversion
-  // from StrictNumeric types.
-  template <typename Src>
-  constexpr CheckedNumeric(
-      StrictNumeric<Src> value)  // NOLINT(runtime/explicit)
-      : state_(static_cast<Src>(value)) {}
-
-  // IsValid() - The public API to test if a CheckedNumeric is currently valid.
-  // A range checked destination type can be supplied using the Dst template
-  // parameter.
-  template <typename Dst = T>
-  constexpr bool IsValid() const {
-    return state_.is_valid() &&
-           IsValueInRangeForNumericType<Dst>(state_.value());
-  }
-
-  // AssignIfValid(Dst) - Assigns the underlying value if it is currently valid
-  // and is within the range supported by the destination type. Returns true if
-  // successful and false otherwise.
-  template <typename Dst>
-#if defined(__clang__) || defined(__GNUC__)
-  __attribute__((warn_unused_result))
-#elif defined(_MSC_VER)
-  _Check_return_
-#endif
-  constexpr bool
-  AssignIfValid(Dst* result) const {
-    return BASE_NUMERICS_LIKELY(IsValid<Dst>())
-               ? ((*result = static_cast<Dst>(state_.value())), true)
-               : false;
-  }
-
-  // ValueOrDie() - The primary accessor for the underlying value. If the
-  // current state is not valid it will CHECK and crash.
-  // A range checked destination type can be supplied using the Dst template
-  // parameter, which will trigger a CHECK if the value is not in bounds for
-  // the destination.
-  // The CHECK behavior can be overridden by supplying a handler as a
-  // template parameter, for test code, etc. However, the handler cannot access
-  // the underlying value, and it is not available through other means.
-  template <typename Dst = T, class CheckHandler = CheckOnFailure>
-  constexpr StrictNumeric<Dst> ValueOrDie() const {
-    return BASE_NUMERICS_LIKELY(IsValid<Dst>())
-               ? static_cast<Dst>(state_.value())
-               : CheckHandler::template HandleFailure<Dst>();
-  }
-
-  // ValueOrDefault(T default_value) - A convenience method that returns the
-  // current value if the state is valid, and the supplied default_value for
-  // any other state.
-  // A range checked destination type can be supplied using the Dst template
-  // parameter. WARNING: This function may fail to compile or CHECK at runtime
-  // if the supplied default_value is not within range of the destination type.
-  template <typename Dst = T, typename Src>
-  constexpr StrictNumeric<Dst> ValueOrDefault(const Src default_value) const {
-    return BASE_NUMERICS_LIKELY(IsValid<Dst>())
-               ? static_cast<Dst>(state_.value())
-               : checked_cast<Dst>(default_value);
-  }
-
-  // Returns a checked numeric of the specified type, cast from the current
-  // CheckedNumeric. If the current state is invalid or the destination cannot
-  // represent the result then the returned CheckedNumeric will be invalid.
-  template <typename Dst>
-  constexpr CheckedNumeric<typename UnderlyingType<Dst>::type> Cast() const {
-    return *this;
-  }
-
-  // This friend method is available solely for providing more detailed logging
-  // in the the tests. Do not implement it in production code, because the
-  // underlying values may change at any time.
-  template <typename U>
-  friend U GetNumericValueForTest(const CheckedNumeric<U>& src);
-
-  // Prototypes for the supported arithmetic operator overloads.
-  template <typename Src>
-  constexpr CheckedNumeric& operator+=(const Src rhs);
-  template <typename Src>
-  constexpr CheckedNumeric& operator-=(const Src rhs);
-  template <typename Src>
-  constexpr CheckedNumeric& operator*=(const Src rhs);
-  template <typename Src>
-  constexpr CheckedNumeric& operator/=(const Src rhs);
-  template <typename Src>
-  constexpr CheckedNumeric& operator%=(const Src rhs);
-  template <typename Src>
-  constexpr CheckedNumeric& operator<<=(const Src rhs);
-  template <typename Src>
-  constexpr CheckedNumeric& operator>>=(const Src rhs);
-  template <typename Src>
-  constexpr CheckedNumeric& operator&=(const Src rhs);
-  template <typename Src>
-  constexpr CheckedNumeric& operator|=(const Src rhs);
-  template <typename Src>
-  constexpr CheckedNumeric& operator^=(const Src rhs);
-
-  constexpr CheckedNumeric operator-() const {
-    // The negation of two's complement int min is int min, so we simply
-    // check for that in the constexpr case.
-    // We use an optimized code path for a known run-time variable.
-    return MustTreatAsConstexpr(state_.value()) || !std::is_signed<T>::value ||
-                   std::is_floating_point<T>::value
-               ? CheckedNumeric<T>(
-                     NegateWrapper(state_.value()),
-                     IsValid() && (!std::is_signed<T>::value ||
-                                   std::is_floating_point<T>::value ||
-                                   NegateWrapper(state_.value()) !=
-                                       std::numeric_limits<T>::lowest()))
-               : FastRuntimeNegate();
-  }
-
-  constexpr CheckedNumeric operator~() const {
-    return CheckedNumeric<decltype(InvertWrapper(T()))>(
-        InvertWrapper(state_.value()), IsValid());
-  }
-
-  constexpr CheckedNumeric Abs() const {
-    return !IsValueNegative(state_.value()) ? *this : -*this;
-  }
-
-  template <typename U>
-  constexpr CheckedNumeric<typename MathWrapper<CheckedMaxOp, T, U>::type> Max(
-      const U rhs) const {
-    using R = typename UnderlyingType<U>::type;
-    using result_type = typename MathWrapper<CheckedMaxOp, T, U>::type;
-    // TODO(jschuh): This can be converted to the MathOp version and remain
-    // constexpr once we have C++14 support.
-    return CheckedNumeric<result_type>(
-        static_cast<result_type>(
-            IsGreater<T, R>::Test(state_.value(), Wrapper<U>::value(rhs))
-                ? state_.value()
-                : Wrapper<U>::value(rhs)),
-        state_.is_valid() && Wrapper<U>::is_valid(rhs));
-  }
-
-  template <typename U>
-  constexpr CheckedNumeric<typename MathWrapper<CheckedMinOp, T, U>::type> Min(
-      const U rhs) const {
-    using R = typename UnderlyingType<U>::type;
-    using result_type = typename MathWrapper<CheckedMinOp, T, U>::type;
-    // TODO(jschuh): This can be converted to the MathOp version and remain
-    // constexpr once we have C++14 support.
-    return CheckedNumeric<result_type>(
-        static_cast<result_type>(
-            IsLess<T, R>::Test(state_.value(), Wrapper<U>::value(rhs))
-                ? state_.value()
-                : Wrapper<U>::value(rhs)),
-        state_.is_valid() && Wrapper<U>::is_valid(rhs));
-  }
-
-  // This function is available only for integral types. It returns an unsigned
-  // integer of the same width as the source type, containing the absolute value
-  // of the source, and properly handling signed min.
-  constexpr CheckedNumeric<typename UnsignedOrFloatForSize<T>::type>
-  UnsignedAbs() const {
-    return CheckedNumeric<typename UnsignedOrFloatForSize<T>::type>(
-        SafeUnsignedAbs(state_.value()), state_.is_valid());
-  }
-
-  constexpr CheckedNumeric& operator++() {
-    *this += 1;
-    return *this;
-  }
-
-  constexpr CheckedNumeric operator++(int) {
-    CheckedNumeric value = *this;
-    *this += 1;
-    return value;
-  }
-
-  constexpr CheckedNumeric& operator--() {
-    *this -= 1;
-    return *this;
-  }
-
-  constexpr CheckedNumeric operator--(int) {
-    CheckedNumeric value = *this;
-    *this -= 1;
-    return value;
-  }
-
-  // These perform the actual math operations on the CheckedNumerics.
-  // Binary arithmetic operations.
-  template <template <typename, typename, typename> class M,
-            typename L,
-            typename R>
-  static constexpr CheckedNumeric MathOp(const L lhs, const R rhs) {
-    using Math = typename MathWrapper<M, L, R>::math;
-    T result = 0;
-    bool is_valid =
-        Wrapper<L>::is_valid(lhs) && Wrapper<R>::is_valid(rhs) &&
-        Math::Do(Wrapper<L>::value(lhs), Wrapper<R>::value(rhs), &result);
-    return CheckedNumeric<T>(result, is_valid);
-  }
-
-  // Assignment arithmetic operations.
-  template <template <typename, typename, typename> class M, typename R>
-  constexpr CheckedNumeric& MathOp(const R rhs) {
-    using Math = typename MathWrapper<M, T, R>::math;
-    T result = 0;  // Using T as the destination saves a range check.
-    bool is_valid = state_.is_valid() && Wrapper<R>::is_valid(rhs) &&
-                    Math::Do(state_.value(), Wrapper<R>::value(rhs), &result);
-    *this = CheckedNumeric<T>(result, is_valid);
-    return *this;
-  }
-
- private:
-  CheckedNumericState<T> state_;
-
-  CheckedNumeric FastRuntimeNegate() const {
-    T result;
-    bool success = CheckedSubOp<T, T>::Do(T(0), state_.value(), &result);
-    return CheckedNumeric<T>(result, IsValid() && success);
-  }
-
-  template <typename Src>
-  constexpr CheckedNumeric(Src value, bool is_valid)
-      : state_(value, is_valid) {}
-
-  // These wrappers allow us to handle state the same way for both
-  // CheckedNumeric and POD arithmetic types.
-  template <typename Src>
-  struct Wrapper {
-    static constexpr bool is_valid(Src) { return true; }
-    static constexpr Src value(Src value) { return value; }
-  };
-
-  template <typename Src>
-  struct Wrapper<CheckedNumeric<Src>> {
-    static constexpr bool is_valid(const CheckedNumeric<Src> v) {
-      return v.IsValid();
-    }
-    static constexpr Src value(const CheckedNumeric<Src> v) {
-      return v.state_.value();
-    }
-  };
-
-  template <typename Src>
-  struct Wrapper<StrictNumeric<Src>> {
-    static constexpr bool is_valid(const StrictNumeric<Src>) { return true; }
-    static constexpr Src value(const StrictNumeric<Src> v) {
-      return static_cast<Src>(v);
-    }
-  };
-};
-
-// Convenience functions to avoid the ugly template disambiguator syntax.
-template <typename Dst, typename Src>
-constexpr bool IsValidForType(const CheckedNumeric<Src> value) {
-  return value.template IsValid<Dst>();
-}
-
-template <typename Dst, typename Src>
-constexpr StrictNumeric<Dst> ValueOrDieForType(
-    const CheckedNumeric<Src> value) {
-  return value.template ValueOrDie<Dst>();
-}
-
-template <typename Dst, typename Src, typename Default>
-constexpr StrictNumeric<Dst> ValueOrDefaultForType(
-    const CheckedNumeric<Src> value,
-    const Default default_value) {
-  return value.template ValueOrDefault<Dst>(default_value);
-}
-
-// Convience wrapper to return a new CheckedNumeric from the provided arithmetic
-// or CheckedNumericType.
-template <typename T>
-constexpr CheckedNumeric<typename UnderlyingType<T>::type> MakeCheckedNum(
-    const T value) {
-  return value;
-}
-
-// These implement the variadic wrapper for the math operations.
-template <template <typename, typename, typename> class M,
-          typename L,
-          typename R>
-constexpr CheckedNumeric<typename MathWrapper<M, L, R>::type> CheckMathOp(
-    const L lhs,
-    const R rhs) {
-  using Math = typename MathWrapper<M, L, R>::math;
-  return CheckedNumeric<typename Math::result_type>::template MathOp<M>(lhs,
-                                                                        rhs);
-}
-
-// General purpose wrapper template for arithmetic operations.
-template <template <typename, typename, typename> class M,
-          typename L,
-          typename R,
-          typename... Args>
-constexpr CheckedNumeric<typename ResultType<M, L, R, Args...>::type>
-CheckMathOp(const L lhs, const R rhs, const Args... args) {
-  return CheckMathOp<M>(CheckMathOp<M>(lhs, rhs), args...);
-}
-
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Add, +, +=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Sub, -, -=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Mul, *, *=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Div, /, /=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Mod, %, %=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Lsh, <<, <<=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Rsh, >>, >>=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, And, &, &=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Or, |, |=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Checked, Check, Xor, ^, ^=)
-BASE_NUMERIC_ARITHMETIC_VARIADIC(Checked, Check, Max)
-BASE_NUMERIC_ARITHMETIC_VARIADIC(Checked, Check, Min)
-
-// These are some extra StrictNumeric operators to support simple pointer
-// arithmetic with our result types. Since wrapping on a pointer is always
-// bad, we trigger the CHECK condition here.
-template <typename L, typename R>
-L* operator+(L* lhs, const StrictNumeric<R> rhs) {
-  uintptr_t result = CheckAdd(reinterpret_cast<uintptr_t>(lhs),
-                              CheckMul(sizeof(L), static_cast<R>(rhs)))
-                         .template ValueOrDie<uintptr_t>();
-  return reinterpret_cast<L*>(result);
-}
-
-template <typename L, typename R>
-L* operator-(L* lhs, const StrictNumeric<R> rhs) {
-  uintptr_t result = CheckSub(reinterpret_cast<uintptr_t>(lhs),
-                              CheckMul(sizeof(L), static_cast<R>(rhs)))
-                         .template ValueOrDie<uintptr_t>();
-  return reinterpret_cast<L*>(result);
-}
-
-}  // namespace internal
-
-using internal::CheckedNumeric;
-using internal::IsValidForType;
-using internal::ValueOrDieForType;
-using internal::ValueOrDefaultForType;
-using internal::MakeCheckedNum;
-using internal::CheckMax;
-using internal::CheckMin;
-using internal::CheckAdd;
-using internal::CheckSub;
-using internal::CheckMul;
-using internal::CheckDiv;
-using internal::CheckMod;
-using internal::CheckLsh;
-using internal::CheckRsh;
-using internal::CheckAnd;
-using internal::CheckOr;
-using internal::CheckXor;
-
-}  // namespace base
-
-#endif  // BASE_NUMERICS_CHECKED_MATH_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/checked_math_impl.h b/native/zucchini/vendor/libchrome/base/numerics/checked_math_impl.h
deleted file mode 100644
index e083389..0000000
--- a/native/zucchini/vendor/libchrome/base/numerics/checked_math_impl.h
+++ /dev/null
@@ -1,567 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_NUMERICS_CHECKED_MATH_IMPL_H_
-#define BASE_NUMERICS_CHECKED_MATH_IMPL_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <climits>
-#include <cmath>
-#include <cstdlib>
-#include <limits>
-#include <type_traits>
-
-#include "base/numerics/safe_conversions.h"
-#include "base/numerics/safe_math_shared_impl.h"
-
-namespace base {
-namespace internal {
-
-template <typename T>
-constexpr bool CheckedAddImpl(T x, T y, T* result) {
-  static_assert(std::is_integral<T>::value, "Type must be integral");
-  // Since the value of x+y is undefined if we have a signed type, we compute
-  // it using the unsigned type of the same size.
-  using UnsignedDst = typename std::make_unsigned<T>::type;
-  using SignedDst = typename std::make_signed<T>::type;
-  UnsignedDst ux = static_cast<UnsignedDst>(x);
-  UnsignedDst uy = static_cast<UnsignedDst>(y);
-  UnsignedDst uresult = static_cast<UnsignedDst>(ux + uy);
-  *result = static_cast<T>(uresult);
-  // Addition is valid if the sign of (x + y) is equal to either that of x or
-  // that of y.
-  return (std::is_signed<T>::value)
-             ? static_cast<SignedDst>((uresult ^ ux) & (uresult ^ uy)) >= 0
-             : uresult >= uy;  // Unsigned is either valid or underflow.
-}
-
-template <typename T, typename U, class Enable = void>
-struct CheckedAddOp {};
-
-template <typename T, typename U>
-struct CheckedAddOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename MaxExponentPromotion<T, U>::type;
-  template <typename V>
-  static constexpr bool Do(T x, U y, V* result) {
-    // TODO(jschuh) Make this "constexpr if" once we're C++17.
-    if (CheckedAddFastOp<T, U>::is_supported)
-      return CheckedAddFastOp<T, U>::Do(x, y, result);
-
-    // Double the underlying type up to a full machine word.
-    using FastPromotion = typename FastIntegerArithmeticPromotion<T, U>::type;
-    using Promotion =
-        typename std::conditional<(IntegerBitsPlusSign<FastPromotion>::value >
-                                   IntegerBitsPlusSign<intptr_t>::value),
-                                  typename BigEnoughPromotion<T, U>::type,
-                                  FastPromotion>::type;
-    // Fail if either operand is out of range for the promoted type.
-    // TODO(jschuh): This could be made to work for a broader range of values.
-    if (BASE_NUMERICS_UNLIKELY(!IsValueInRangeForNumericType<Promotion>(x) ||
-                               !IsValueInRangeForNumericType<Promotion>(y))) {
-      return false;
-    }
-
-    Promotion presult = {};
-    bool is_valid = true;
-    if (IsIntegerArithmeticSafe<Promotion, T, U>::value) {
-      presult = static_cast<Promotion>(x) + static_cast<Promotion>(y);
-    } else {
-      is_valid = CheckedAddImpl(static_cast<Promotion>(x),
-                                static_cast<Promotion>(y), &presult);
-    }
-    *result = static_cast<V>(presult);
-    return is_valid && IsValueInRangeForNumericType<V>(presult);
-  }
-};
-
-template <typename T>
-constexpr bool CheckedSubImpl(T x, T y, T* result) {
-  static_assert(std::is_integral<T>::value, "Type must be integral");
-  // Since the value of x+y is undefined if we have a signed type, we compute
-  // it using the unsigned type of the same size.
-  using UnsignedDst = typename std::make_unsigned<T>::type;
-  using SignedDst = typename std::make_signed<T>::type;
-  UnsignedDst ux = static_cast<UnsignedDst>(x);
-  UnsignedDst uy = static_cast<UnsignedDst>(y);
-  UnsignedDst uresult = static_cast<UnsignedDst>(ux - uy);
-  *result = static_cast<T>(uresult);
-  // Subtraction is valid if either x and y have same sign, or (x-y) and x have
-  // the same sign.
-  return (std::is_signed<T>::value)
-             ? static_cast<SignedDst>((uresult ^ ux) & (ux ^ uy)) >= 0
-             : x >= y;
-}
-
-template <typename T, typename U, class Enable = void>
-struct CheckedSubOp {};
-
-template <typename T, typename U>
-struct CheckedSubOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename MaxExponentPromotion<T, U>::type;
-  template <typename V>
-  static constexpr bool Do(T x, U y, V* result) {
-    // TODO(jschuh) Make this "constexpr if" once we're C++17.
-    if (CheckedSubFastOp<T, U>::is_supported)
-      return CheckedSubFastOp<T, U>::Do(x, y, result);
-
-    // Double the underlying type up to a full machine word.
-    using FastPromotion = typename FastIntegerArithmeticPromotion<T, U>::type;
-    using Promotion =
-        typename std::conditional<(IntegerBitsPlusSign<FastPromotion>::value >
-                                   IntegerBitsPlusSign<intptr_t>::value),
-                                  typename BigEnoughPromotion<T, U>::type,
-                                  FastPromotion>::type;
-    // Fail if either operand is out of range for the promoted type.
-    // TODO(jschuh): This could be made to work for a broader range of values.
-    if (BASE_NUMERICS_UNLIKELY(!IsValueInRangeForNumericType<Promotion>(x) ||
-                               !IsValueInRangeForNumericType<Promotion>(y))) {
-      return false;
-    }
-
-    Promotion presult = {};
-    bool is_valid = true;
-    if (IsIntegerArithmeticSafe<Promotion, T, U>::value) {
-      presult = static_cast<Promotion>(x) - static_cast<Promotion>(y);
-    } else {
-      is_valid = CheckedSubImpl(static_cast<Promotion>(x),
-                                static_cast<Promotion>(y), &presult);
-    }
-    *result = static_cast<V>(presult);
-    return is_valid && IsValueInRangeForNumericType<V>(presult);
-  }
-};
-
-template <typename T>
-constexpr bool CheckedMulImpl(T x, T y, T* result) {
-  static_assert(std::is_integral<T>::value, "Type must be integral");
-  // Since the value of x*y is potentially undefined if we have a signed type,
-  // we compute it using the unsigned type of the same size.
-  using UnsignedDst = typename std::make_unsigned<T>::type;
-  using SignedDst = typename std::make_signed<T>::type;
-  const UnsignedDst ux = SafeUnsignedAbs(x);
-  const UnsignedDst uy = SafeUnsignedAbs(y);
-  UnsignedDst uresult = static_cast<UnsignedDst>(ux * uy);
-  const bool is_negative =
-      std::is_signed<T>::value && static_cast<SignedDst>(x ^ y) < 0;
-  *result = is_negative ? 0 - uresult : uresult;
-  // We have a fast out for unsigned identity or zero on the second operand.
-  // After that it's an unsigned overflow check on the absolute value, with
-  // a +1 bound for a negative result.
-  return uy <= UnsignedDst(!std::is_signed<T>::value || is_negative) ||
-         ux <= (std::numeric_limits<T>::max() + UnsignedDst(is_negative)) / uy;
-}
-
-template <typename T, typename U, class Enable = void>
-struct CheckedMulOp {};
-
-template <typename T, typename U>
-struct CheckedMulOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename MaxExponentPromotion<T, U>::type;
-  template <typename V>
-  static constexpr bool Do(T x, U y, V* result) {
-    // TODO(jschuh) Make this "constexpr if" once we're C++17.
-    if (CheckedMulFastOp<T, U>::is_supported)
-      return CheckedMulFastOp<T, U>::Do(x, y, result);
-
-    using Promotion = typename FastIntegerArithmeticPromotion<T, U>::type;
-    // Verify the destination type can hold the result (always true for 0).
-    if (BASE_NUMERICS_UNLIKELY((!IsValueInRangeForNumericType<Promotion>(x) ||
-                                !IsValueInRangeForNumericType<Promotion>(y)) &&
-                               x && y)) {
-      return false;
-    }
-
-    Promotion presult = {};
-    bool is_valid = true;
-    if (CheckedMulFastOp<Promotion, Promotion>::is_supported) {
-      // The fast op may be available with the promoted type.
-      is_valid = CheckedMulFastOp<Promotion, Promotion>::Do(x, y, &presult);
-    } else if (IsIntegerArithmeticSafe<Promotion, T, U>::value) {
-      presult = static_cast<Promotion>(x) * static_cast<Promotion>(y);
-    } else {
-      is_valid = CheckedMulImpl(static_cast<Promotion>(x),
-                                static_cast<Promotion>(y), &presult);
-    }
-    *result = static_cast<V>(presult);
-    return is_valid && IsValueInRangeForNumericType<V>(presult);
-  }
-};
-
-// Division just requires a check for a zero denominator or an invalid negation
-// on signed min/-1.
-template <typename T, typename U, class Enable = void>
-struct CheckedDivOp {};
-
-template <typename T, typename U>
-struct CheckedDivOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename MaxExponentPromotion<T, U>::type;
-  template <typename V>
-  static constexpr bool Do(T x, U y, V* result) {
-    if (BASE_NUMERICS_UNLIKELY(!y))
-      return false;
-
-    // The overflow check can be compiled away if we don't have the exact
-    // combination of types needed to trigger this case.
-    using Promotion = typename BigEnoughPromotion<T, U>::type;
-    if (BASE_NUMERICS_UNLIKELY(
-            (std::is_signed<T>::value && std::is_signed<U>::value &&
-             IsTypeInRangeForNumericType<T, Promotion>::value &&
-             static_cast<Promotion>(x) ==
-                 std::numeric_limits<Promotion>::lowest() &&
-             y == static_cast<U>(-1)))) {
-      return false;
-    }
-
-    // This branch always compiles away if the above branch wasn't removed.
-    if (BASE_NUMERICS_UNLIKELY((!IsValueInRangeForNumericType<Promotion>(x) ||
-                                !IsValueInRangeForNumericType<Promotion>(y)) &&
-                               x)) {
-      return false;
-    }
-
-    Promotion presult = Promotion(x) / Promotion(y);
-    *result = static_cast<V>(presult);
-    return IsValueInRangeForNumericType<V>(presult);
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct CheckedModOp {};
-
-template <typename T, typename U>
-struct CheckedModOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename MaxExponentPromotion<T, U>::type;
-  template <typename V>
-  static constexpr bool Do(T x, U y, V* result) {
-    using Promotion = typename BigEnoughPromotion<T, U>::type;
-    if (BASE_NUMERICS_LIKELY(y)) {
-      Promotion presult = static_cast<Promotion>(x) % static_cast<Promotion>(y);
-      *result = static_cast<Promotion>(presult);
-      return IsValueInRangeForNumericType<V>(presult);
-    }
-    return false;
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct CheckedLshOp {};
-
-// Left shift. Shifts less than 0 or greater than or equal to the number
-// of bits in the promoted type are undefined. Shifts of negative values
-// are undefined. Otherwise it is defined when the result fits.
-template <typename T, typename U>
-struct CheckedLshOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = T;
-  template <typename V>
-  static constexpr bool Do(T x, U shift, V* result) {
-    // Disallow negative numbers and verify the shift is in bounds.
-    if (BASE_NUMERICS_LIKELY(!IsValueNegative(x) &&
-                             as_unsigned(shift) <
-                                 as_unsigned(std::numeric_limits<T>::digits))) {
-      // Shift as unsigned to avoid undefined behavior.
-      *result = static_cast<V>(as_unsigned(x) << shift);
-      // If the shift can be reversed, we know it was valid.
-      return *result >> shift == x;
-    }
-
-    // Handle the legal corner-case of a full-width signed shift of zero.
-    return std::is_signed<T>::value && !x &&
-           as_unsigned(shift) == as_unsigned(std::numeric_limits<T>::digits);
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct CheckedRshOp {};
-
-// Right shift. Shifts less than 0 or greater than or equal to the number
-// of bits in the promoted type are undefined. Otherwise, it is always defined,
-// but a right shift of a negative value is implementation-dependent.
-template <typename T, typename U>
-struct CheckedRshOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = T;
-  template <typename V>
-  static bool Do(T x, U shift, V* result) {
-    // Use the type conversion push negative values out of range.
-    if (BASE_NUMERICS_LIKELY(as_unsigned(shift) <
-                             IntegerBitsPlusSign<T>::value)) {
-      T tmp = x >> shift;
-      *result = static_cast<V>(tmp);
-      return IsValueInRangeForNumericType<V>(tmp);
-    }
-    return false;
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct CheckedAndOp {};
-
-// For simplicity we support only unsigned integer results.
-template <typename T, typename U>
-struct CheckedAndOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename std::make_unsigned<
-      typename MaxExponentPromotion<T, U>::type>::type;
-  template <typename V>
-  static constexpr bool Do(T x, U y, V* result) {
-    result_type tmp = static_cast<result_type>(x) & static_cast<result_type>(y);
-    *result = static_cast<V>(tmp);
-    return IsValueInRangeForNumericType<V>(tmp);
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct CheckedOrOp {};
-
-// For simplicity we support only unsigned integers.
-template <typename T, typename U>
-struct CheckedOrOp<T,
-                   U,
-                   typename std::enable_if<std::is_integral<T>::value &&
-                                           std::is_integral<U>::value>::type> {
-  using result_type = typename std::make_unsigned<
-      typename MaxExponentPromotion<T, U>::type>::type;
-  template <typename V>
-  static constexpr bool Do(T x, U y, V* result) {
-    result_type tmp = static_cast<result_type>(x) | static_cast<result_type>(y);
-    *result = static_cast<V>(tmp);
-    return IsValueInRangeForNumericType<V>(tmp);
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct CheckedXorOp {};
-
-// For simplicity we support only unsigned integers.
-template <typename T, typename U>
-struct CheckedXorOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename std::make_unsigned<
-      typename MaxExponentPromotion<T, U>::type>::type;
-  template <typename V>
-  static constexpr bool Do(T x, U y, V* result) {
-    result_type tmp = static_cast<result_type>(x) ^ static_cast<result_type>(y);
-    *result = static_cast<V>(tmp);
-    return IsValueInRangeForNumericType<V>(tmp);
-  }
-};
-
-// Max doesn't really need to be implemented this way because it can't fail,
-// but it makes the code much cleaner to use the MathOp wrappers.
-template <typename T, typename U, class Enable = void>
-struct CheckedMaxOp {};
-
-template <typename T, typename U>
-struct CheckedMaxOp<
-    T,
-    U,
-    typename std::enable_if<std::is_arithmetic<T>::value &&
-                            std::is_arithmetic<U>::value>::type> {
-  using result_type = typename MaxExponentPromotion<T, U>::type;
-  template <typename V>
-  static constexpr bool Do(T x, U y, V* result) {
-    result_type tmp = IsGreater<T, U>::Test(x, y) ? static_cast<result_type>(x)
-                                                  : static_cast<result_type>(y);
-    *result = static_cast<V>(tmp);
-    return IsValueInRangeForNumericType<V>(tmp);
-  }
-};
-
-// Min doesn't really need to be implemented this way because it can't fail,
-// but it makes the code much cleaner to use the MathOp wrappers.
-template <typename T, typename U, class Enable = void>
-struct CheckedMinOp {};
-
-template <typename T, typename U>
-struct CheckedMinOp<
-    T,
-    U,
-    typename std::enable_if<std::is_arithmetic<T>::value &&
-                            std::is_arithmetic<U>::value>::type> {
-  using result_type = typename LowestValuePromotion<T, U>::type;
-  template <typename V>
-  static constexpr bool Do(T x, U y, V* result) {
-    result_type tmp = IsLess<T, U>::Test(x, y) ? static_cast<result_type>(x)
-                                               : static_cast<result_type>(y);
-    *result = static_cast<V>(tmp);
-    return IsValueInRangeForNumericType<V>(tmp);
-  }
-};
-
-// This is just boilerplate that wraps the standard floating point arithmetic.
-// A macro isn't the nicest solution, but it beats rewriting these repeatedly.
-#define BASE_FLOAT_ARITHMETIC_OPS(NAME, OP)                              \
-  template <typename T, typename U>                                      \
-  struct Checked##NAME##Op<                                              \
-      T, U,                                                              \
-      typename std::enable_if<std::is_floating_point<T>::value ||        \
-                              std::is_floating_point<U>::value>::type> { \
-    using result_type = typename MaxExponentPromotion<T, U>::type;       \
-    template <typename V>                                                \
-    static constexpr bool Do(T x, U y, V* result) {                      \
-      using Promotion = typename MaxExponentPromotion<T, U>::type;       \
-      Promotion presult = x OP y;                                        \
-      *result = static_cast<V>(presult);                                 \
-      return IsValueInRangeForNumericType<V>(presult);                   \
-    }                                                                    \
-  };
-
-BASE_FLOAT_ARITHMETIC_OPS(Add, +)
-BASE_FLOAT_ARITHMETIC_OPS(Sub, -)
-BASE_FLOAT_ARITHMETIC_OPS(Mul, *)
-BASE_FLOAT_ARITHMETIC_OPS(Div, /)
-
-#undef BASE_FLOAT_ARITHMETIC_OPS
-
-// Floats carry around their validity state with them, but integers do not. So,
-// we wrap the underlying value in a specialization in order to hide that detail
-// and expose an interface via accessors.
-enum NumericRepresentation {
-  NUMERIC_INTEGER,
-  NUMERIC_FLOATING,
-  NUMERIC_UNKNOWN
-};
-
-template <typename NumericType>
-struct GetNumericRepresentation {
-  static const NumericRepresentation value =
-      std::is_integral<NumericType>::value
-          ? NUMERIC_INTEGER
-          : (std::is_floating_point<NumericType>::value ? NUMERIC_FLOATING
-                                                        : NUMERIC_UNKNOWN);
-};
-
-template <typename T,
-          NumericRepresentation type = GetNumericRepresentation<T>::value>
-class CheckedNumericState {};
-
-// Integrals require quite a bit of additional housekeeping to manage state.
-template <typename T>
-class CheckedNumericState<T, NUMERIC_INTEGER> {
- private:
-  // is_valid_ precedes value_ because member intializers in the constructors
-  // are evaluated in field order, and is_valid_ must be read when initializing
-  // value_.
-  bool is_valid_;
-  T value_;
-
-  // Ensures that a type conversion does not trigger undefined behavior.
-  template <typename Src>
-  static constexpr T WellDefinedConversionOrZero(const Src value,
-                                                 const bool is_valid) {
-    using SrcType = typename internal::UnderlyingType<Src>::type;
-    return (std::is_integral<SrcType>::value || is_valid)
-               ? static_cast<T>(value)
-               : static_cast<T>(0);
-  }
-
- public:
-  template <typename Src, NumericRepresentation type>
-  friend class CheckedNumericState;
-
-  constexpr CheckedNumericState() : is_valid_(true), value_(0) {}
-
-  template <typename Src>
-  constexpr CheckedNumericState(Src value, bool is_valid)
-      : is_valid_(is_valid && IsValueInRangeForNumericType<T>(value)),
-        value_(WellDefinedConversionOrZero(value, is_valid_)) {
-    static_assert(std::is_arithmetic<Src>::value, "Argument must be numeric.");
-  }
-
-  // Copy constructor.
-  template <typename Src>
-  constexpr CheckedNumericState(const CheckedNumericState<Src>& rhs)
-      : is_valid_(rhs.IsValid()),
-        value_(WellDefinedConversionOrZero(rhs.value(), is_valid_)) {}
-
-  template <typename Src>
-  constexpr explicit CheckedNumericState(Src value)
-      : is_valid_(IsValueInRangeForNumericType<T>(value)),
-        value_(WellDefinedConversionOrZero(value, is_valid_)) {}
-
-  constexpr bool is_valid() const { return is_valid_; }
-  constexpr T value() const { return value_; }
-};
-
-// Floating points maintain their own validity, but need translation wrappers.
-template <typename T>
-class CheckedNumericState<T, NUMERIC_FLOATING> {
- private:
-  T value_;
-
-  // Ensures that a type conversion does not trigger undefined behavior.
-  template <typename Src>
-  static constexpr T WellDefinedConversionOrNaN(const Src value,
-                                                const bool is_valid) {
-    using SrcType = typename internal::UnderlyingType<Src>::type;
-    return (StaticDstRangeRelationToSrcRange<T, SrcType>::value ==
-                NUMERIC_RANGE_CONTAINED ||
-            is_valid)
-               ? static_cast<T>(value)
-               : std::numeric_limits<T>::quiet_NaN();
-  }
-
- public:
-  template <typename Src, NumericRepresentation type>
-  friend class CheckedNumericState;
-
-  constexpr CheckedNumericState() : value_(0.0) {}
-
-  template <typename Src>
-  constexpr CheckedNumericState(Src value, bool is_valid)
-      : value_(WellDefinedConversionOrNaN(value, is_valid)) {}
-
-  template <typename Src>
-  constexpr explicit CheckedNumericState(Src value)
-      : value_(WellDefinedConversionOrNaN(
-            value,
-            IsValueInRangeForNumericType<T>(value))) {}
-
-  // Copy constructor.
-  template <typename Src>
-  constexpr CheckedNumericState(const CheckedNumericState<Src>& rhs)
-      : value_(WellDefinedConversionOrNaN(
-            rhs.value(),
-            rhs.is_valid() && IsValueInRangeForNumericType<T>(rhs.value()))) {}
-
-  constexpr bool is_valid() const {
-    // Written this way because std::isfinite is not reliably constexpr.
-    return MustTreatAsConstexpr(value_)
-               ? value_ <= std::numeric_limits<T>::max() &&
-                     value_ >= std::numeric_limits<T>::lowest()
-               : std::isfinite(value_);
-  }
-  constexpr T value() const { return value_; }
-};
-
-}  // namespace internal
-}  // namespace base
-
-#endif  // BASE_NUMERICS_CHECKED_MATH_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/clamped_math.h b/native/zucchini/vendor/libchrome/base/numerics/clamped_math.h
deleted file mode 100644
index b184363..0000000
--- a/native/zucchini/vendor/libchrome/base/numerics/clamped_math.h
+++ /dev/null
@@ -1,262 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_NUMERICS_CLAMPED_MATH_H_
-#define BASE_NUMERICS_CLAMPED_MATH_H_
-
-#include <stddef.h>
-
-#include <limits>
-#include <type_traits>
-
-#include "base/numerics/clamped_math_impl.h"
-
-namespace base {
-namespace internal {
-
-template <typename T>
-class ClampedNumeric {
-  static_assert(std::is_arithmetic<T>::value,
-                "ClampedNumeric<T>: T must be a numeric type.");
-
- public:
-  using type = T;
-
-  constexpr ClampedNumeric() : value_(0) {}
-
-  // Copy constructor.
-  template <typename Src>
-  constexpr ClampedNumeric(const ClampedNumeric<Src>& rhs)
-      : value_(saturated_cast<T>(rhs.value_)) {}
-
-  template <typename Src>
-  friend class ClampedNumeric;
-
-  // This is not an explicit constructor because we implicitly upgrade regular
-  // numerics to ClampedNumerics to make them easier to use.
-  template <typename Src>
-  constexpr ClampedNumeric(Src value)  // NOLINT(runtime/explicit)
-      : value_(saturated_cast<T>(value)) {
-    static_assert(std::is_arithmetic<Src>::value, "Argument must be numeric.");
-  }
-
-  // This is not an explicit constructor because we want a seamless conversion
-  // from StrictNumeric types.
-  template <typename Src>
-  constexpr ClampedNumeric(
-      StrictNumeric<Src> value)  // NOLINT(runtime/explicit)
-      : value_(saturated_cast<T>(static_cast<Src>(value))) {}
-
-  // Returns a ClampedNumeric of the specified type, cast from the current
-  // ClampedNumeric, and saturated to the destination type.
-  template <typename Dst>
-  constexpr ClampedNumeric<typename UnderlyingType<Dst>::type> Cast() const {
-    return *this;
-  }
-
-  // Prototypes for the supported arithmetic operator overloads.
-  template <typename Src>
-  constexpr ClampedNumeric& operator+=(const Src rhs);
-  template <typename Src>
-  constexpr ClampedNumeric& operator-=(const Src rhs);
-  template <typename Src>
-  constexpr ClampedNumeric& operator*=(const Src rhs);
-  template <typename Src>
-  constexpr ClampedNumeric& operator/=(const Src rhs);
-  template <typename Src>
-  constexpr ClampedNumeric& operator%=(const Src rhs);
-  template <typename Src>
-  constexpr ClampedNumeric& operator<<=(const Src rhs);
-  template <typename Src>
-  constexpr ClampedNumeric& operator>>=(const Src rhs);
-  template <typename Src>
-  constexpr ClampedNumeric& operator&=(const Src rhs);
-  template <typename Src>
-  constexpr ClampedNumeric& operator|=(const Src rhs);
-  template <typename Src>
-  constexpr ClampedNumeric& operator^=(const Src rhs);
-
-  constexpr ClampedNumeric operator-() const {
-    // The negation of two's complement int min is int min, so that's the
-    // only overflow case where we will saturate.
-    return ClampedNumeric<T>(SaturatedNegWrapper(value_));
-  }
-
-  constexpr ClampedNumeric operator~() const {
-    return ClampedNumeric<decltype(InvertWrapper(T()))>(InvertWrapper(value_));
-  }
-
-  constexpr ClampedNumeric Abs() const {
-    // The negation of two's complement int min is int min, so that's the
-    // only overflow case where we will saturate.
-    return ClampedNumeric<T>(SaturatedAbsWrapper(value_));
-  }
-
-  template <typename U>
-  constexpr ClampedNumeric<typename MathWrapper<ClampedMaxOp, T, U>::type> Max(
-      const U rhs) const {
-    using result_type = typename MathWrapper<ClampedMaxOp, T, U>::type;
-    return ClampedNumeric<result_type>(
-        ClampedMaxOp<T, U>::Do(value_, Wrapper<U>::value(rhs)));
-  }
-
-  template <typename U>
-  constexpr ClampedNumeric<typename MathWrapper<ClampedMinOp, T, U>::type> Min(
-      const U rhs) const {
-    using result_type = typename MathWrapper<ClampedMinOp, T, U>::type;
-    return ClampedNumeric<result_type>(
-        ClampedMinOp<T, U>::Do(value_, Wrapper<U>::value(rhs)));
-  }
-
-  // This function is available only for integral types. It returns an unsigned
-  // integer of the same width as the source type, containing the absolute value
-  // of the source, and properly handling signed min.
-  constexpr ClampedNumeric<typename UnsignedOrFloatForSize<T>::type>
-  UnsignedAbs() const {
-    return ClampedNumeric<typename UnsignedOrFloatForSize<T>::type>(
-        SafeUnsignedAbs(value_));
-  }
-
-  constexpr ClampedNumeric& operator++() {
-    *this += 1;
-    return *this;
-  }
-
-  constexpr ClampedNumeric operator++(int) {
-    ClampedNumeric value = *this;
-    *this += 1;
-    return value;
-  }
-
-  constexpr ClampedNumeric& operator--() {
-    *this -= 1;
-    return *this;
-  }
-
-  constexpr ClampedNumeric operator--(int) {
-    ClampedNumeric value = *this;
-    *this -= 1;
-    return value;
-  }
-
-  // These perform the actual math operations on the ClampedNumerics.
-  // Binary arithmetic operations.
-  template <template <typename, typename, typename> class M,
-            typename L,
-            typename R>
-  static constexpr ClampedNumeric MathOp(const L lhs, const R rhs) {
-    using Math = typename MathWrapper<M, L, R>::math;
-    return ClampedNumeric<T>(
-        Math::template Do<T>(Wrapper<L>::value(lhs), Wrapper<R>::value(rhs)));
-  }
-
-  // Assignment arithmetic operations.
-  template <template <typename, typename, typename> class M, typename R>
-  constexpr ClampedNumeric& MathOp(const R rhs) {
-    using Math = typename MathWrapper<M, T, R>::math;
-    *this =
-        ClampedNumeric<T>(Math::template Do<T>(value_, Wrapper<R>::value(rhs)));
-    return *this;
-  }
-
-  template <typename Dst>
-  constexpr operator Dst() const {
-    return saturated_cast<typename ArithmeticOrUnderlyingEnum<Dst>::type>(
-        value_);
-  }
-
-  // This method extracts the raw integer value without saturating it to the
-  // destination type as the conversion operator does. This is useful when
-  // e.g. assigning to an auto type or passing as a deduced template parameter.
-  constexpr T RawValue() const { return value_; }
-
- private:
-  T value_;
-
-  // These wrappers allow us to handle state the same way for both
-  // ClampedNumeric and POD arithmetic types.
-  template <typename Src>
-  struct Wrapper {
-    static constexpr Src value(Src value) {
-      return static_cast<typename UnderlyingType<Src>::type>(value);
-    }
-  };
-};
-
-// Convience wrapper to return a new ClampedNumeric from the provided arithmetic
-// or ClampedNumericType.
-template <typename T>
-constexpr ClampedNumeric<typename UnderlyingType<T>::type> MakeClampedNum(
-    const T value) {
-  return value;
-}
-
-// Overload the ostream output operator to make logging work nicely.
-template <typename T>
-std::ostream& operator<<(std::ostream& os, const ClampedNumeric<T>& value) {
-  os << static_cast<T>(value);
-  return os;
-}
-
-// These implement the variadic wrapper for the math operations.
-template <template <typename, typename, typename> class M,
-          typename L,
-          typename R>
-constexpr ClampedNumeric<typename MathWrapper<M, L, R>::type> ClampMathOp(
-    const L lhs,
-    const R rhs) {
-  using Math = typename MathWrapper<M, L, R>::math;
-  return ClampedNumeric<typename Math::result_type>::template MathOp<M>(lhs,
-                                                                        rhs);
-}
-
-// General purpose wrapper template for arithmetic operations.
-template <template <typename, typename, typename> class M,
-          typename L,
-          typename R,
-          typename... Args>
-constexpr ClampedNumeric<typename ResultType<M, L, R, Args...>::type>
-ClampMathOp(const L lhs, const R rhs, const Args... args) {
-  return ClampMathOp<M>(ClampMathOp<M>(lhs, rhs), args...);
-}
-
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Add, +, +=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Sub, -, -=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Mul, *, *=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Div, /, /=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Mod, %, %=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Lsh, <<, <<=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Rsh, >>, >>=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, And, &, &=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Or, |, |=)
-BASE_NUMERIC_ARITHMETIC_OPERATORS(Clamped, Clamp, Xor, ^, ^=)
-BASE_NUMERIC_ARITHMETIC_VARIADIC(Clamped, Clamp, Max)
-BASE_NUMERIC_ARITHMETIC_VARIADIC(Clamped, Clamp, Min)
-BASE_NUMERIC_COMPARISON_OPERATORS(Clamped, IsLess, <);
-BASE_NUMERIC_COMPARISON_OPERATORS(Clamped, IsLessOrEqual, <=);
-BASE_NUMERIC_COMPARISON_OPERATORS(Clamped, IsGreater, >);
-BASE_NUMERIC_COMPARISON_OPERATORS(Clamped, IsGreaterOrEqual, >=);
-BASE_NUMERIC_COMPARISON_OPERATORS(Clamped, IsEqual, ==);
-BASE_NUMERIC_COMPARISON_OPERATORS(Clamped, IsNotEqual, !=);
-
-}  // namespace internal
-
-using internal::ClampedNumeric;
-using internal::MakeClampedNum;
-using internal::ClampMax;
-using internal::ClampMin;
-using internal::ClampAdd;
-using internal::ClampSub;
-using internal::ClampMul;
-using internal::ClampDiv;
-using internal::ClampMod;
-using internal::ClampLsh;
-using internal::ClampRsh;
-using internal::ClampAnd;
-using internal::ClampOr;
-using internal::ClampXor;
-
-}  // namespace base
-
-#endif  // BASE_NUMERICS_CLAMPED_MATH_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/clamped_math_impl.h b/native/zucchini/vendor/libchrome/base/numerics/clamped_math_impl.h
deleted file mode 100644
index 303a7e9..0000000
--- a/native/zucchini/vendor/libchrome/base/numerics/clamped_math_impl.h
+++ /dev/null
@@ -1,341 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_NUMERICS_CLAMPED_MATH_IMPL_H_
-#define BASE_NUMERICS_CLAMPED_MATH_IMPL_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <climits>
-#include <cmath>
-#include <cstdlib>
-#include <limits>
-#include <type_traits>
-
-#include "base/numerics/checked_math.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/numerics/safe_math_shared_impl.h"
-
-namespace base {
-namespace internal {
-
-template <typename T,
-          typename std::enable_if<std::is_integral<T>::value &&
-                                  std::is_signed<T>::value>::type* = nullptr>
-constexpr T SaturatedNegWrapper(T value) {
-  return MustTreatAsConstexpr(value) || !ClampedNegFastOp<T>::is_supported
-             ? (NegateWrapper(value) != std::numeric_limits<T>::lowest()
-                    ? NegateWrapper(value)
-                    : std::numeric_limits<T>::max())
-             : ClampedNegFastOp<T>::Do(value);
-}
-
-template <typename T,
-          typename std::enable_if<std::is_integral<T>::value &&
-                                  !std::is_signed<T>::value>::type* = nullptr>
-constexpr T SaturatedNegWrapper(T value) {
-  return T(0);
-}
-
-template <
-    typename T,
-    typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
-constexpr T SaturatedNegWrapper(T value) {
-  return -value;
-}
-
-template <typename T,
-          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
-constexpr T SaturatedAbsWrapper(T value) {
-  // The calculation below is a static identity for unsigned types, but for
-  // signed integer types it provides a non-branching, saturated absolute value.
-  // This works because SafeUnsignedAbs() returns an unsigned type, which can
-  // represent the absolute value of all negative numbers of an equal-width
-  // integer type. The call to IsValueNegative() then detects overflow in the
-  // special case of numeric_limits<T>::min(), by evaluating the bit pattern as
-  // a signed integer value. If it is the overflow case, we end up subtracting
-  // one from the unsigned result, thus saturating to numeric_limits<T>::max().
-  return static_cast<T>(SafeUnsignedAbs(value) -
-                        IsValueNegative<T>(SafeUnsignedAbs(value)));
-}
-
-template <
-    typename T,
-    typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
-constexpr T SaturatedAbsWrapper(T value) {
-  return value < 0 ? -value : value;
-}
-
-template <typename T, typename U, class Enable = void>
-struct ClampedAddOp {};
-
-template <typename T, typename U>
-struct ClampedAddOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename MaxExponentPromotion<T, U>::type;
-  template <typename V = result_type>
-  static constexpr V Do(T x, U y) {
-    if (ClampedAddFastOp<T, U>::is_supported)
-      return ClampedAddFastOp<T, U>::template Do<V>(x, y);
-
-    static_assert(std::is_same<V, result_type>::value ||
-                      IsTypeInRangeForNumericType<U, V>::value,
-                  "The saturation result cannot be determined from the "
-                  "provided types.");
-    const V saturated = CommonMaxOrMin<V>(IsValueNegative(y));
-    V result = {};
-    return BASE_NUMERICS_LIKELY((CheckedAddOp<T, U>::Do(x, y, &result)))
-               ? result
-               : saturated;
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct ClampedSubOp {};
-
-template <typename T, typename U>
-struct ClampedSubOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename MaxExponentPromotion<T, U>::type;
-  template <typename V = result_type>
-  static constexpr V Do(T x, U y) {
-    // TODO(jschuh) Make this "constexpr if" once we're C++17.
-    if (ClampedSubFastOp<T, U>::is_supported)
-      return ClampedSubFastOp<T, U>::template Do<V>(x, y);
-
-    static_assert(std::is_same<V, result_type>::value ||
-                      IsTypeInRangeForNumericType<U, V>::value,
-                  "The saturation result cannot be determined from the "
-                  "provided types.");
-    const V saturated = CommonMaxOrMin<V>(!IsValueNegative(y));
-    V result = {};
-    return BASE_NUMERICS_LIKELY((CheckedSubOp<T, U>::Do(x, y, &result)))
-               ? result
-               : saturated;
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct ClampedMulOp {};
-
-template <typename T, typename U>
-struct ClampedMulOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename MaxExponentPromotion<T, U>::type;
-  template <typename V = result_type>
-  static constexpr V Do(T x, U y) {
-    // TODO(jschuh) Make this "constexpr if" once we're C++17.
-    if (ClampedMulFastOp<T, U>::is_supported)
-      return ClampedMulFastOp<T, U>::template Do<V>(x, y);
-
-    V result = {};
-    const V saturated =
-        CommonMaxOrMin<V>(IsValueNegative(x) ^ IsValueNegative(y));
-    return BASE_NUMERICS_LIKELY((CheckedMulOp<T, U>::Do(x, y, &result)))
-               ? result
-               : saturated;
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct ClampedDivOp {};
-
-template <typename T, typename U>
-struct ClampedDivOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename MaxExponentPromotion<T, U>::type;
-  template <typename V = result_type>
-  static constexpr V Do(T x, U y) {
-    V result = {};
-    if (BASE_NUMERICS_LIKELY((CheckedDivOp<T, U>::Do(x, y, &result))))
-      return result;
-    // Saturation goes to max, min, or NaN (if x is zero).
-    return x ? CommonMaxOrMin<V>(IsValueNegative(x) ^ IsValueNegative(y))
-             : SaturationDefaultLimits<V>::NaN();
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct ClampedModOp {};
-
-template <typename T, typename U>
-struct ClampedModOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename MaxExponentPromotion<T, U>::type;
-  template <typename V = result_type>
-  static constexpr V Do(T x, U y) {
-    V result = {};
-    return BASE_NUMERICS_LIKELY((CheckedModOp<T, U>::Do(x, y, &result)))
-               ? result
-               : x;
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct ClampedLshOp {};
-
-// Left shift. Non-zero values saturate in the direction of the sign. A zero
-// shifted by any value always results in zero.
-template <typename T, typename U>
-struct ClampedLshOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = T;
-  template <typename V = result_type>
-  static constexpr V Do(T x, U shift) {
-    static_assert(!std::is_signed<U>::value, "Shift value must be unsigned.");
-    if (BASE_NUMERICS_LIKELY(shift < std::numeric_limits<T>::digits)) {
-      // Shift as unsigned to avoid undefined behavior.
-      V result = static_cast<V>(as_unsigned(x) << shift);
-      // If the shift can be reversed, we know it was valid.
-      if (BASE_NUMERICS_LIKELY(result >> shift == x))
-        return result;
-    }
-    return x ? CommonMaxOrMin<V>(IsValueNegative(x)) : 0;
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct ClampedRshOp {};
-
-// Right shift. Negative values saturate to -1. Positive or 0 saturates to 0.
-template <typename T, typename U>
-struct ClampedRshOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = T;
-  template <typename V = result_type>
-  static constexpr V Do(T x, U shift) {
-    static_assert(!std::is_signed<U>::value, "Shift value must be unsigned.");
-    // Signed right shift is odd, because it saturates to -1 or 0.
-    const V saturated = as_unsigned(V(0)) - IsValueNegative(x);
-    return BASE_NUMERICS_LIKELY(shift < IntegerBitsPlusSign<T>::value)
-               ? saturated_cast<V>(x >> shift)
-               : saturated;
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct ClampedAndOp {};
-
-template <typename T, typename U>
-struct ClampedAndOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename std::make_unsigned<
-      typename MaxExponentPromotion<T, U>::type>::type;
-  template <typename V>
-  static constexpr V Do(T x, U y) {
-    return static_cast<result_type>(x) & static_cast<result_type>(y);
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct ClampedOrOp {};
-
-// For simplicity we promote to unsigned integers.
-template <typename T, typename U>
-struct ClampedOrOp<T,
-                   U,
-                   typename std::enable_if<std::is_integral<T>::value &&
-                                           std::is_integral<U>::value>::type> {
-  using result_type = typename std::make_unsigned<
-      typename MaxExponentPromotion<T, U>::type>::type;
-  template <typename V>
-  static constexpr V Do(T x, U y) {
-    return static_cast<result_type>(x) | static_cast<result_type>(y);
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct ClampedXorOp {};
-
-// For simplicity we support only unsigned integers.
-template <typename T, typename U>
-struct ClampedXorOp<T,
-                    U,
-                    typename std::enable_if<std::is_integral<T>::value &&
-                                            std::is_integral<U>::value>::type> {
-  using result_type = typename std::make_unsigned<
-      typename MaxExponentPromotion<T, U>::type>::type;
-  template <typename V>
-  static constexpr V Do(T x, U y) {
-    return static_cast<result_type>(x) ^ static_cast<result_type>(y);
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct ClampedMaxOp {};
-
-template <typename T, typename U>
-struct ClampedMaxOp<
-    T,
-    U,
-    typename std::enable_if<std::is_arithmetic<T>::value &&
-                            std::is_arithmetic<U>::value>::type> {
-  using result_type = typename MaxExponentPromotion<T, U>::type;
-  template <typename V = result_type>
-  static constexpr V Do(T x, U y) {
-    return IsGreater<T, U>::Test(x, y) ? saturated_cast<V>(x)
-                                       : saturated_cast<V>(y);
-  }
-};
-
-template <typename T, typename U, class Enable = void>
-struct ClampedMinOp {};
-
-template <typename T, typename U>
-struct ClampedMinOp<
-    T,
-    U,
-    typename std::enable_if<std::is_arithmetic<T>::value &&
-                            std::is_arithmetic<U>::value>::type> {
-  using result_type = typename LowestValuePromotion<T, U>::type;
-  template <typename V = result_type>
-  static constexpr V Do(T x, U y) {
-    return IsLess<T, U>::Test(x, y) ? saturated_cast<V>(x)
-                                    : saturated_cast<V>(y);
-  }
-};
-
-// This is just boilerplate that wraps the standard floating point arithmetic.
-// A macro isn't the nicest solution, but it beats rewriting these repeatedly.
-#define BASE_FLOAT_ARITHMETIC_OPS(NAME, OP)                              \
-  template <typename T, typename U>                                      \
-  struct Clamped##NAME##Op<                                              \
-      T, U,                                                              \
-      typename std::enable_if<std::is_floating_point<T>::value ||        \
-                              std::is_floating_point<U>::value>::type> { \
-    using result_type = typename MaxExponentPromotion<T, U>::type;       \
-    template <typename V = result_type>                                  \
-    static constexpr V Do(T x, U y) {                                    \
-      return saturated_cast<V>(x OP y);                                  \
-    }                                                                    \
-  };
-
-BASE_FLOAT_ARITHMETIC_OPS(Add, +)
-BASE_FLOAT_ARITHMETIC_OPS(Sub, -)
-BASE_FLOAT_ARITHMETIC_OPS(Mul, *)
-BASE_FLOAT_ARITHMETIC_OPS(Div, /)
-
-#undef BASE_FLOAT_ARITHMETIC_OPS
-
-}  // namespace internal
-}  // namespace base
-
-#endif  // BASE_NUMERICS_CLAMPED_MATH_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/safe_conversions.h b/native/zucchini/vendor/libchrome/base/numerics/safe_conversions.h
deleted file mode 100644
index 9284f8f..0000000
--- a/native/zucchini/vendor/libchrome/base/numerics/safe_conversions.h
+++ /dev/null
@@ -1,344 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_NUMERICS_SAFE_CONVERSIONS_H_
-#define BASE_NUMERICS_SAFE_CONVERSIONS_H_
-
-#include <stddef.h>
-
-#include <limits>
-#include <ostream>
-#include <type_traits>
-
-#include "base/numerics/safe_conversions_impl.h"
-
-#if !defined(__native_client__) && (defined(__ARMEL__) || defined(__arch64__))
-#include "base/numerics/safe_conversions_arm_impl.h"
-#define BASE_HAS_OPTIMIZED_SAFE_CONVERSIONS (1)
-#else
-#define BASE_HAS_OPTIMIZED_SAFE_CONVERSIONS (0)
-#endif
-
-namespace base {
-namespace internal {
-
-#if !BASE_HAS_OPTIMIZED_SAFE_CONVERSIONS
-template <typename Dst, typename Src>
-struct SaturateFastAsmOp {
-  static const bool is_supported = false;
-  static constexpr Dst Do(Src) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<Dst>();
-  }
-};
-#endif  // BASE_HAS_OPTIMIZED_SAFE_CONVERSIONS
-#undef BASE_HAS_OPTIMIZED_SAFE_CONVERSIONS
-
-// The following special case a few specific integer conversions where we can
-// eke out better performance than range checking.
-template <typename Dst, typename Src, typename Enable = void>
-struct IsValueInRangeFastOp {
-  static const bool is_supported = false;
-  static constexpr bool Do(Src value) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<bool>();
-  }
-};
-
-// Signed to signed range comparison.
-template <typename Dst, typename Src>
-struct IsValueInRangeFastOp<
-    Dst,
-    Src,
-    typename std::enable_if<
-        std::is_integral<Dst>::value && std::is_integral<Src>::value &&
-        std::is_signed<Dst>::value && std::is_signed<Src>::value &&
-        !IsTypeInRangeForNumericType<Dst, Src>::value>::type> {
-  static const bool is_supported = true;
-
-  static constexpr bool Do(Src value) {
-    // Just downcast to the smaller type, sign extend it back to the original
-    // type, and then see if it matches the original value.
-    return value == static_cast<Dst>(value);
-  }
-};
-
-// Signed to unsigned range comparison.
-template <typename Dst, typename Src>
-struct IsValueInRangeFastOp<
-    Dst,
-    Src,
-    typename std::enable_if<
-        std::is_integral<Dst>::value && std::is_integral<Src>::value &&
-        !std::is_signed<Dst>::value && std::is_signed<Src>::value &&
-        !IsTypeInRangeForNumericType<Dst, Src>::value>::type> {
-  static const bool is_supported = true;
-
-  static constexpr bool Do(Src value) {
-    // We cast a signed as unsigned to overflow negative values to the top,
-    // then compare against whichever maximum is smaller, as our upper bound.
-    return as_unsigned(value) <= as_unsigned(CommonMax<Src, Dst>());
-  }
-};
-
-// Convenience function that returns true if the supplied value is in range
-// for the destination type.
-template <typename Dst, typename Src>
-constexpr bool IsValueInRangeForNumericType(Src value) {
-  using SrcType = typename internal::UnderlyingType<Src>::type;
-  return internal::IsValueInRangeFastOp<Dst, SrcType>::is_supported
-             ? internal::IsValueInRangeFastOp<Dst, SrcType>::Do(
-                   static_cast<SrcType>(value))
-             : internal::DstRangeRelationToSrcRange<Dst>(
-                   static_cast<SrcType>(value))
-                   .IsValid();
-}
-
-// checked_cast<> is analogous to static_cast<> for numeric types,
-// except that it CHECKs that the specified numeric conversion will not
-// overflow or underflow. NaN source will always trigger a CHECK.
-template <typename Dst,
-          class CheckHandler = internal::CheckOnFailure,
-          typename Src>
-constexpr Dst checked_cast(Src value) {
-  // This throws a compile-time error on evaluating the constexpr if it can be
-  // determined at compile-time as failing, otherwise it will CHECK at runtime.
-  using SrcType = typename internal::UnderlyingType<Src>::type;
-  return BASE_NUMERICS_LIKELY((IsValueInRangeForNumericType<Dst>(value)))
-             ? static_cast<Dst>(static_cast<SrcType>(value))
-             : CheckHandler::template HandleFailure<Dst>();
-}
-
-// Default boundaries for integral/float: max/infinity, lowest/-infinity, 0/NaN.
-// You may provide your own limits (e.g. to saturated_cast) so long as you
-// implement all of the static constexpr member functions in the class below.
-template <typename T>
-struct SaturationDefaultLimits : public std::numeric_limits<T> {
-  static constexpr T NaN() {
-    return std::numeric_limits<T>::has_quiet_NaN
-               ? std::numeric_limits<T>::quiet_NaN()
-               : T();
-  }
-  using std::numeric_limits<T>::max;
-  static constexpr T Overflow() {
-    return std::numeric_limits<T>::has_infinity
-               ? std::numeric_limits<T>::infinity()
-               : std::numeric_limits<T>::max();
-  }
-  using std::numeric_limits<T>::lowest;
-  static constexpr T Underflow() {
-    return std::numeric_limits<T>::has_infinity
-               ? std::numeric_limits<T>::infinity() * -1
-               : std::numeric_limits<T>::lowest();
-  }
-};
-
-template <typename Dst, template <typename> class S, typename Src>
-constexpr Dst saturated_cast_impl(Src value, RangeCheck constraint) {
-  // For some reason clang generates much better code when the branch is
-  // structured exactly this way, rather than a sequence of checks.
-  return !constraint.IsOverflowFlagSet()
-             ? (!constraint.IsUnderflowFlagSet() ? static_cast<Dst>(value)
-                                                 : S<Dst>::Underflow())
-             // Skip this check for integral Src, which cannot be NaN.
-             : (std::is_integral<Src>::value || !constraint.IsUnderflowFlagSet()
-                    ? S<Dst>::Overflow()
-                    : S<Dst>::NaN());
-}
-
-// We can reduce the number of conditions and get slightly better performance
-// for normal signed and unsigned integer ranges. And in the specific case of
-// Arm, we can use the optimized saturation instructions.
-template <typename Dst, typename Src, typename Enable = void>
-struct SaturateFastOp {
-  static const bool is_supported = false;
-  static constexpr Dst Do(Src value) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<Dst>();
-  }
-};
-
-template <typename Dst, typename Src>
-struct SaturateFastOp<
-    Dst,
-    Src,
-    typename std::enable_if<std::is_integral<Src>::value &&
-                            std::is_integral<Dst>::value>::type> {
-  static const bool is_supported = true;
-  static Dst Do(Src value) {
-    if (SaturateFastAsmOp<Dst, Src>::is_supported)
-      return SaturateFastAsmOp<Dst, Src>::Do(value);
-
-    // The exact order of the following is structured to hit the correct
-    // optimization heuristics across compilers. Do not change without
-    // checking the emitted code.
-    Dst saturated = CommonMaxOrMin<Dst, Src>(
-        IsMaxInRangeForNumericType<Dst, Src>() ||
-        (!IsMinInRangeForNumericType<Dst, Src>() && IsValueNegative(value)));
-    return BASE_NUMERICS_LIKELY(IsValueInRangeForNumericType<Dst>(value))
-               ? static_cast<Dst>(value)
-               : saturated;
-  }
-};
-
-// saturated_cast<> is analogous to static_cast<> for numeric types, except
-// that the specified numeric conversion will saturate by default rather than
-// overflow or underflow, and NaN assignment to an integral will return 0.
-// All boundary condition behaviors can be overriden with a custom handler.
-template <typename Dst,
-          template <typename> class SaturationHandler = SaturationDefaultLimits,
-          typename Src>
-constexpr Dst saturated_cast(Src value) {
-  using SrcType = typename UnderlyingType<Src>::type;
-  return !IsCompileTimeConstant(value) &&
-                 SaturateFastOp<Dst, SrcType>::is_supported &&
-                 std::is_same<SaturationHandler<Dst>,
-                              SaturationDefaultLimits<Dst>>::value
-             ? SaturateFastOp<Dst, SrcType>::Do(static_cast<SrcType>(value))
-             : saturated_cast_impl<Dst, SaturationHandler, SrcType>(
-                   static_cast<SrcType>(value),
-                   DstRangeRelationToSrcRange<Dst, SaturationHandler, SrcType>(
-                       static_cast<SrcType>(value)));
-}
-
-// strict_cast<> is analogous to static_cast<> for numeric types, except that
-// it will cause a compile failure if the destination type is not large enough
-// to contain any value in the source type. It performs no runtime checking.
-template <typename Dst, typename Src>
-constexpr Dst strict_cast(Src value) {
-  using SrcType = typename UnderlyingType<Src>::type;
-  static_assert(UnderlyingType<Src>::is_numeric, "Argument must be numeric.");
-  static_assert(std::is_arithmetic<Dst>::value, "Result must be numeric.");
-
-  // If you got here from a compiler error, it's because you tried to assign
-  // from a source type to a destination type that has insufficient range.
-  // The solution may be to change the destination type you're assigning to,
-  // and use one large enough to represent the source.
-  // Alternatively, you may be better served with the checked_cast<> or
-  // saturated_cast<> template functions for your particular use case.
-  static_assert(StaticDstRangeRelationToSrcRange<Dst, SrcType>::value ==
-                    NUMERIC_RANGE_CONTAINED,
-                "The source type is out of range for the destination type. "
-                "Please see strict_cast<> comments for more information.");
-
-  return static_cast<Dst>(static_cast<SrcType>(value));
-}
-
-// Some wrappers to statically check that a type is in range.
-template <typename Dst, typename Src, class Enable = void>
-struct IsNumericRangeContained {
-  static const bool value = false;
-};
-
-template <typename Dst, typename Src>
-struct IsNumericRangeContained<
-    Dst,
-    Src,
-    typename std::enable_if<ArithmeticOrUnderlyingEnum<Dst>::value &&
-                            ArithmeticOrUnderlyingEnum<Src>::value>::type> {
-  static const bool value = StaticDstRangeRelationToSrcRange<Dst, Src>::value ==
-                            NUMERIC_RANGE_CONTAINED;
-};
-
-// StrictNumeric implements compile time range checking between numeric types by
-// wrapping assignment operations in a strict_cast. This class is intended to be
-// used for function arguments and return types, to ensure the destination type
-// can always contain the source type. This is essentially the same as enforcing
-// -Wconversion in gcc and C4302 warnings on MSVC, but it can be applied
-// incrementally at API boundaries, making it easier to convert code so that it
-// compiles cleanly with truncation warnings enabled.
-// This template should introduce no runtime overhead, but it also provides no
-// runtime checking of any of the associated mathematical operations. Use
-// CheckedNumeric for runtime range checks of the actual value being assigned.
-template <typename T>
-class StrictNumeric {
- public:
-  using type = T;
-
-  constexpr StrictNumeric() : value_(0) {}
-
-  // Copy constructor.
-  template <typename Src>
-  constexpr StrictNumeric(const StrictNumeric<Src>& rhs)
-      : value_(strict_cast<T>(rhs.value_)) {}
-
-  // This is not an explicit constructor because we implicitly upgrade regular
-  // numerics to StrictNumerics to make them easier to use.
-  template <typename Src>
-  constexpr StrictNumeric(Src value)  // NOLINT(runtime/explicit)
-      : value_(strict_cast<T>(value)) {}
-
-  // If you got here from a compiler error, it's because you tried to assign
-  // from a source type to a destination type that has insufficient range.
-  // The solution may be to change the destination type you're assigning to,
-  // and use one large enough to represent the source.
-  // If you're assigning from a CheckedNumeric<> class, you may be able to use
-  // the AssignIfValid() member function, specify a narrower destination type to
-  // the member value functions (e.g. val.template ValueOrDie<Dst>()), use one
-  // of the value helper functions (e.g. ValueOrDieForType<Dst>(val)).
-  // If you've encountered an _ambiguous overload_ you can use a static_cast<>
-  // to explicitly cast the result to the destination type.
-  // If none of that works, you may be better served with the checked_cast<> or
-  // saturated_cast<> template functions for your particular use case.
-  template <typename Dst,
-            typename std::enable_if<
-                IsNumericRangeContained<Dst, T>::value>::type* = nullptr>
-  constexpr operator Dst() const {
-    return static_cast<typename ArithmeticOrUnderlyingEnum<Dst>::type>(value_);
-  }
-
- private:
-  const T value_;
-};
-
-// Convience wrapper returns a StrictNumeric from the provided arithmetic type.
-template <typename T>
-constexpr StrictNumeric<typename UnderlyingType<T>::type> MakeStrictNum(
-    const T value) {
-  return value;
-}
-
-// Overload the ostream output operator to make logging work nicely.
-template <typename T>
-std::ostream& operator<<(std::ostream& os, const StrictNumeric<T>& value) {
-  os << static_cast<T>(value);
-  return os;
-}
-
-#define BASE_NUMERIC_COMPARISON_OPERATORS(CLASS, NAME, OP)              \
-  template <typename L, typename R,                                     \
-            typename std::enable_if<                                    \
-                internal::Is##CLASS##Op<L, R>::value>::type* = nullptr> \
-  constexpr bool operator OP(const L lhs, const R rhs) {                \
-    return SafeCompare<NAME, typename UnderlyingType<L>::type,          \
-                       typename UnderlyingType<R>::type>(lhs, rhs);     \
-  }
-
-BASE_NUMERIC_COMPARISON_OPERATORS(Strict, IsLess, <);
-BASE_NUMERIC_COMPARISON_OPERATORS(Strict, IsLessOrEqual, <=);
-BASE_NUMERIC_COMPARISON_OPERATORS(Strict, IsGreater, >);
-BASE_NUMERIC_COMPARISON_OPERATORS(Strict, IsGreaterOrEqual, >=);
-BASE_NUMERIC_COMPARISON_OPERATORS(Strict, IsEqual, ==);
-BASE_NUMERIC_COMPARISON_OPERATORS(Strict, IsNotEqual, !=);
-
-};  // namespace internal
-
-using internal::as_signed;
-using internal::as_unsigned;
-using internal::checked_cast;
-using internal::strict_cast;
-using internal::saturated_cast;
-using internal::SafeUnsignedAbs;
-using internal::StrictNumeric;
-using internal::MakeStrictNum;
-using internal::IsValueInRangeForNumericType;
-using internal::IsTypeInRangeForNumericType;
-using internal::IsValueNegative;
-
-// Explicitly make a shorter size_t alias for convenience.
-using SizeT = StrictNumeric<size_t>;
-
-}  // namespace base
-
-#endif  // BASE_NUMERICS_SAFE_CONVERSIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/safe_conversions_impl.h b/native/zucchini/vendor/libchrome/base/numerics/safe_conversions_impl.h
deleted file mode 100644
index 2516204..0000000
--- a/native/zucchini/vendor/libchrome/base/numerics/safe_conversions_impl.h
+++ /dev/null
@@ -1,850 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_
-#define BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_
-
-#include <stdint.h>
-
-#include <limits>
-#include <type_traits>
-
-#if defined(__GNUC__) || defined(__clang__)
-#define BASE_NUMERICS_LIKELY(x) __builtin_expect(!!(x), 1)
-#define BASE_NUMERICS_UNLIKELY(x) __builtin_expect(!!(x), 0)
-#else
-#define BASE_NUMERICS_LIKELY(x) (x)
-#define BASE_NUMERICS_UNLIKELY(x) (x)
-#endif
-
-namespace base {
-namespace internal {
-
-// The std library doesn't provide a binary max_exponent for integers, however
-// we can compute an analog using std::numeric_limits<>::digits.
-template <typename NumericType>
-struct MaxExponent {
-  static const int value = std::is_floating_point<NumericType>::value
-                               ? std::numeric_limits<NumericType>::max_exponent
-                               : std::numeric_limits<NumericType>::digits + 1;
-};
-
-// The number of bits (including the sign) in an integer. Eliminates sizeof
-// hacks.
-template <typename NumericType>
-struct IntegerBitsPlusSign {
-  static const int value = std::numeric_limits<NumericType>::digits +
-                           std::is_signed<NumericType>::value;
-};
-
-// Helper templates for integer manipulations.
-
-template <typename Integer>
-struct PositionOfSignBit {
-  static const size_t value = IntegerBitsPlusSign<Integer>::value - 1;
-};
-
-// Determines if a numeric value is negative without throwing compiler
-// warnings on: unsigned(value) < 0.
-template <typename T,
-          typename std::enable_if<std::is_signed<T>::value>::type* = nullptr>
-constexpr bool IsValueNegative(T value) {
-  static_assert(std::is_arithmetic<T>::value, "Argument must be numeric.");
-  return value < 0;
-}
-
-template <typename T,
-          typename std::enable_if<!std::is_signed<T>::value>::type* = nullptr>
-constexpr bool IsValueNegative(T) {
-  static_assert(std::is_arithmetic<T>::value, "Argument must be numeric.");
-  return false;
-}
-
-// This performs a fast negation, returning a signed value. It works on unsigned
-// arguments, but probably doesn't do what you want for any unsigned value
-// larger than max / 2 + 1 (i.e. signed min cast to unsigned).
-template <typename T>
-constexpr typename std::make_signed<T>::type ConditionalNegate(
-    T x,
-    bool is_negative) {
-  static_assert(std::is_integral<T>::value, "Type must be integral");
-  using SignedT = typename std::make_signed<T>::type;
-  using UnsignedT = typename std::make_unsigned<T>::type;
-  return static_cast<SignedT>(
-      (static_cast<UnsignedT>(x) ^ -SignedT(is_negative)) + is_negative);
-}
-
-// This performs a safe, absolute value via unsigned overflow.
-template <typename T>
-constexpr typename std::make_unsigned<T>::type SafeUnsignedAbs(T value) {
-  static_assert(std::is_integral<T>::value, "Type must be integral");
-  using UnsignedT = typename std::make_unsigned<T>::type;
-  return IsValueNegative(value) ? 0 - static_cast<UnsignedT>(value)
-                                : static_cast<UnsignedT>(value);
-}
-
-// This allows us to switch paths on known compile-time constants.
-#if defined(__clang__) || defined(__GNUC__)
-constexpr bool CanDetectCompileTimeConstant() {
-  return true;
-}
-template <typename T>
-constexpr bool IsCompileTimeConstant(const T v) {
-  return __builtin_constant_p(v);
-}
-#else
-constexpr bool CanDetectCompileTimeConstant() {
-  return false;
-}
-template <typename T>
-constexpr bool IsCompileTimeConstant(const T) {
-  return false;
-}
-#endif
-template <typename T>
-constexpr bool MustTreatAsConstexpr(const T v) {
-  // Either we can't detect a compile-time constant, and must always use the
-  // constexpr path, or we know we have a compile-time constant.
-  return !CanDetectCompileTimeConstant() || IsCompileTimeConstant(v);
-}
-
-// Forces a crash, like a CHECK(false). Used for numeric boundary errors.
-// Also used in a constexpr template to trigger a compilation failure on
-// an error condition.
-struct CheckOnFailure {
-  template <typename T>
-  static T HandleFailure() {
-#if defined(_MSC_VER)
-    __debugbreak();
-#elif defined(__GNUC__) || defined(__clang__)
-    __builtin_trap();
-#else
-    ((void)(*(volatile char*)0 = 0));
-#endif
-    return T();
-  }
-};
-
-enum IntegerRepresentation {
-  INTEGER_REPRESENTATION_UNSIGNED,
-  INTEGER_REPRESENTATION_SIGNED
-};
-
-// A range for a given nunmeric Src type is contained for a given numeric Dst
-// type if both numeric_limits<Src>::max() <= numeric_limits<Dst>::max() and
-// numeric_limits<Src>::lowest() >= numeric_limits<Dst>::lowest() are true.
-// We implement this as template specializations rather than simple static
-// comparisons to ensure type correctness in our comparisons.
-enum NumericRangeRepresentation {
-  NUMERIC_RANGE_NOT_CONTAINED,
-  NUMERIC_RANGE_CONTAINED
-};
-
-// Helper templates to statically determine if our destination type can contain
-// maximum and minimum values represented by the source type.
-
-template <typename Dst,
-          typename Src,
-          IntegerRepresentation DstSign = std::is_signed<Dst>::value
-                                              ? INTEGER_REPRESENTATION_SIGNED
-                                              : INTEGER_REPRESENTATION_UNSIGNED,
-          IntegerRepresentation SrcSign = std::is_signed<Src>::value
-                                              ? INTEGER_REPRESENTATION_SIGNED
-                                              : INTEGER_REPRESENTATION_UNSIGNED>
-struct StaticDstRangeRelationToSrcRange;
-
-// Same sign: Dst is guaranteed to contain Src only if its range is equal or
-// larger.
-template <typename Dst, typename Src, IntegerRepresentation Sign>
-struct StaticDstRangeRelationToSrcRange<Dst, Src, Sign, Sign> {
-  static const NumericRangeRepresentation value =
-      MaxExponent<Dst>::value >= MaxExponent<Src>::value
-          ? NUMERIC_RANGE_CONTAINED
-          : NUMERIC_RANGE_NOT_CONTAINED;
-};
-
-// Unsigned to signed: Dst is guaranteed to contain source only if its range is
-// larger.
-template <typename Dst, typename Src>
-struct StaticDstRangeRelationToSrcRange<Dst,
-                                        Src,
-                                        INTEGER_REPRESENTATION_SIGNED,
-                                        INTEGER_REPRESENTATION_UNSIGNED> {
-  static const NumericRangeRepresentation value =
-      MaxExponent<Dst>::value > MaxExponent<Src>::value
-          ? NUMERIC_RANGE_CONTAINED
-          : NUMERIC_RANGE_NOT_CONTAINED;
-};
-
-// Signed to unsigned: Dst cannot be statically determined to contain Src.
-template <typename Dst, typename Src>
-struct StaticDstRangeRelationToSrcRange<Dst,
-                                        Src,
-                                        INTEGER_REPRESENTATION_UNSIGNED,
-                                        INTEGER_REPRESENTATION_SIGNED> {
-  static const NumericRangeRepresentation value = NUMERIC_RANGE_NOT_CONTAINED;
-};
-
-// This class wraps the range constraints as separate booleans so the compiler
-// can identify constants and eliminate unused code paths.
-class RangeCheck {
- public:
-  constexpr RangeCheck(bool is_in_lower_bound, bool is_in_upper_bound)
-      : is_underflow_(!is_in_lower_bound), is_overflow_(!is_in_upper_bound) {}
-  constexpr RangeCheck() : is_underflow_(0), is_overflow_(0) {}
-  constexpr bool IsValid() const { return !is_overflow_ && !is_underflow_; }
-  constexpr bool IsInvalid() const { return is_overflow_ && is_underflow_; }
-  constexpr bool IsOverflow() const { return is_overflow_ && !is_underflow_; }
-  constexpr bool IsUnderflow() const { return !is_overflow_ && is_underflow_; }
-  constexpr bool IsOverflowFlagSet() const { return is_overflow_; }
-  constexpr bool IsUnderflowFlagSet() const { return is_underflow_; }
-  constexpr bool operator==(const RangeCheck rhs) const {
-    return is_underflow_ == rhs.is_underflow_ &&
-           is_overflow_ == rhs.is_overflow_;
-  }
-  constexpr bool operator!=(const RangeCheck rhs) const {
-    return !(*this == rhs);
-  }
-
- private:
-  // Do not change the order of these member variables. The integral conversion
-  // optimization depends on this exact order.
-  const bool is_underflow_;
-  const bool is_overflow_;
-};
-
-// The following helper template addresses a corner case in range checks for
-// conversion from a floating-point type to an integral type of smaller range
-// but larger precision (e.g. float -> unsigned). The problem is as follows:
-//   1. Integral maximum is always one less than a power of two, so it must be
-//      truncated to fit the mantissa of the floating point. The direction of
-//      rounding is implementation defined, but by default it's always IEEE
-//      floats, which round to nearest and thus result in a value of larger
-//      magnitude than the integral value.
-//      Example: float f = UINT_MAX; // f is 4294967296f but UINT_MAX
-//                                   // is 4294967295u.
-//   2. If the floating point value is equal to the promoted integral maximum
-//      value, a range check will erroneously pass.
-//      Example: (4294967296f <= 4294967295u) // This is true due to a precision
-//                                            // loss in rounding up to float.
-//   3. When the floating point value is then converted to an integral, the
-//      resulting value is out of range for the target integral type and
-//      thus is implementation defined.
-//      Example: unsigned u = (float)INT_MAX; // u will typically overflow to 0.
-// To fix this bug we manually truncate the maximum value when the destination
-// type is an integral of larger precision than the source floating-point type,
-// such that the resulting maximum is represented exactly as a floating point.
-template <typename Dst, typename Src, template <typename> class Bounds>
-struct NarrowingRange {
-  using SrcLimits = std::numeric_limits<Src>;
-  using DstLimits = typename std::numeric_limits<Dst>;
-
-  // Computes the mask required to make an accurate comparison between types.
-  static const int kShift =
-      (MaxExponent<Src>::value > MaxExponent<Dst>::value &&
-       SrcLimits::digits < DstLimits::digits)
-          ? (DstLimits::digits - SrcLimits::digits)
-          : 0;
-  template <
-      typename T,
-      typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
-
-  // Masks out the integer bits that are beyond the precision of the
-  // intermediate type used for comparison.
-  static constexpr T Adjust(T value) {
-    static_assert(std::is_same<T, Dst>::value, "");
-    static_assert(kShift < DstLimits::digits, "");
-    return static_cast<T>(
-        ConditionalNegate(SafeUnsignedAbs(value) & ~((T(1) << kShift) - T(1)),
-                          IsValueNegative(value)));
-  }
-
-  template <typename T,
-            typename std::enable_if<std::is_floating_point<T>::value>::type* =
-                nullptr>
-  static constexpr T Adjust(T value) {
-    static_assert(std::is_same<T, Dst>::value, "");
-    static_assert(kShift == 0, "");
-    return value;
-  }
-
-  static constexpr Dst max() { return Adjust(Bounds<Dst>::max()); }
-  static constexpr Dst lowest() { return Adjust(Bounds<Dst>::lowest()); }
-};
-
-template <typename Dst,
-          typename Src,
-          template <typename> class Bounds,
-          IntegerRepresentation DstSign = std::is_signed<Dst>::value
-                                              ? INTEGER_REPRESENTATION_SIGNED
-                                              : INTEGER_REPRESENTATION_UNSIGNED,
-          IntegerRepresentation SrcSign = std::is_signed<Src>::value
-                                              ? INTEGER_REPRESENTATION_SIGNED
-                                              : INTEGER_REPRESENTATION_UNSIGNED,
-          NumericRangeRepresentation DstRange =
-              StaticDstRangeRelationToSrcRange<Dst, Src>::value>
-struct DstRangeRelationToSrcRangeImpl;
-
-// The following templates are for ranges that must be verified at runtime. We
-// split it into checks based on signedness to avoid confusing casts and
-// compiler warnings on signed an unsigned comparisons.
-
-// Same sign narrowing: The range is contained for normal limits.
-template <typename Dst,
-          typename Src,
-          template <typename> class Bounds,
-          IntegerRepresentation DstSign,
-          IntegerRepresentation SrcSign>
-struct DstRangeRelationToSrcRangeImpl<Dst,
-                                      Src,
-                                      Bounds,
-                                      DstSign,
-                                      SrcSign,
-                                      NUMERIC_RANGE_CONTAINED> {
-  static constexpr RangeCheck Check(Src value) {
-    using SrcLimits = std::numeric_limits<Src>;
-    using DstLimits = NarrowingRange<Dst, Src, Bounds>;
-    return RangeCheck(
-        static_cast<Dst>(SrcLimits::lowest()) >= DstLimits::lowest() ||
-            static_cast<Dst>(value) >= DstLimits::lowest(),
-        static_cast<Dst>(SrcLimits::max()) <= DstLimits::max() ||
-            static_cast<Dst>(value) <= DstLimits::max());
-  }
-};
-
-// Signed to signed narrowing: Both the upper and lower boundaries may be
-// exceeded for standard limits.
-template <typename Dst, typename Src, template <typename> class Bounds>
-struct DstRangeRelationToSrcRangeImpl<Dst,
-                                      Src,
-                                      Bounds,
-                                      INTEGER_REPRESENTATION_SIGNED,
-                                      INTEGER_REPRESENTATION_SIGNED,
-                                      NUMERIC_RANGE_NOT_CONTAINED> {
-  static constexpr RangeCheck Check(Src value) {
-    using DstLimits = NarrowingRange<Dst, Src, Bounds>;
-    return RangeCheck(value >= DstLimits::lowest(), value <= DstLimits::max());
-  }
-};
-
-// Unsigned to unsigned narrowing: Only the upper bound can be exceeded for
-// standard limits.
-template <typename Dst, typename Src, template <typename> class Bounds>
-struct DstRangeRelationToSrcRangeImpl<Dst,
-                                      Src,
-                                      Bounds,
-                                      INTEGER_REPRESENTATION_UNSIGNED,
-                                      INTEGER_REPRESENTATION_UNSIGNED,
-                                      NUMERIC_RANGE_NOT_CONTAINED> {
-  static constexpr RangeCheck Check(Src value) {
-    using DstLimits = NarrowingRange<Dst, Src, Bounds>;
-    return RangeCheck(
-        DstLimits::lowest() == Dst(0) || value >= DstLimits::lowest(),
-        value <= DstLimits::max());
-  }
-};
-
-// Unsigned to signed: Only the upper bound can be exceeded for standard limits.
-template <typename Dst, typename Src, template <typename> class Bounds>
-struct DstRangeRelationToSrcRangeImpl<Dst,
-                                      Src,
-                                      Bounds,
-                                      INTEGER_REPRESENTATION_SIGNED,
-                                      INTEGER_REPRESENTATION_UNSIGNED,
-                                      NUMERIC_RANGE_NOT_CONTAINED> {
-  static constexpr RangeCheck Check(Src value) {
-    using DstLimits = NarrowingRange<Dst, Src, Bounds>;
-    using Promotion = decltype(Src() + Dst());
-    return RangeCheck(DstLimits::lowest() <= Dst(0) ||
-                          static_cast<Promotion>(value) >=
-                              static_cast<Promotion>(DstLimits::lowest()),
-                      static_cast<Promotion>(value) <=
-                          static_cast<Promotion>(DstLimits::max()));
-  }
-};
-
-// Signed to unsigned: The upper boundary may be exceeded for a narrower Dst,
-// and any negative value exceeds the lower boundary for standard limits.
-template <typename Dst, typename Src, template <typename> class Bounds>
-struct DstRangeRelationToSrcRangeImpl<Dst,
-                                      Src,
-                                      Bounds,
-                                      INTEGER_REPRESENTATION_UNSIGNED,
-                                      INTEGER_REPRESENTATION_SIGNED,
-                                      NUMERIC_RANGE_NOT_CONTAINED> {
-  static constexpr RangeCheck Check(Src value) {
-    using SrcLimits = std::numeric_limits<Src>;
-    using DstLimits = NarrowingRange<Dst, Src, Bounds>;
-    using Promotion = decltype(Src() + Dst());
-    return RangeCheck(
-        value >= Src(0) && (DstLimits::lowest() == 0 ||
-                            static_cast<Dst>(value) >= DstLimits::lowest()),
-        static_cast<Promotion>(SrcLimits::max()) <=
-                static_cast<Promotion>(DstLimits::max()) ||
-            static_cast<Promotion>(value) <=
-                static_cast<Promotion>(DstLimits::max()));
-  }
-};
-
-// Simple wrapper for statically checking if a type's range is contained.
-template <typename Dst, typename Src>
-struct IsTypeInRangeForNumericType {
-  static const bool value = StaticDstRangeRelationToSrcRange<Dst, Src>::value ==
-                            NUMERIC_RANGE_CONTAINED;
-};
-
-template <typename Dst,
-          template <typename> class Bounds = std::numeric_limits,
-          typename Src>
-constexpr RangeCheck DstRangeRelationToSrcRange(Src value) {
-  static_assert(std::is_arithmetic<Src>::value, "Argument must be numeric.");
-  static_assert(std::is_arithmetic<Dst>::value, "Result must be numeric.");
-  static_assert(Bounds<Dst>::lowest() < Bounds<Dst>::max(), "");
-  return DstRangeRelationToSrcRangeImpl<Dst, Src, Bounds>::Check(value);
-}
-
-// Integer promotion templates used by the portable checked integer arithmetic.
-template <size_t Size, bool IsSigned>
-struct IntegerForDigitsAndSign;
-
-#define INTEGER_FOR_DIGITS_AND_SIGN(I)                          \
-  template <>                                                   \
-  struct IntegerForDigitsAndSign<IntegerBitsPlusSign<I>::value, \
-                                 std::is_signed<I>::value> {    \
-    using type = I;                                             \
-  }
-
-INTEGER_FOR_DIGITS_AND_SIGN(int8_t);
-INTEGER_FOR_DIGITS_AND_SIGN(uint8_t);
-INTEGER_FOR_DIGITS_AND_SIGN(int16_t);
-INTEGER_FOR_DIGITS_AND_SIGN(uint16_t);
-INTEGER_FOR_DIGITS_AND_SIGN(int32_t);
-INTEGER_FOR_DIGITS_AND_SIGN(uint32_t);
-INTEGER_FOR_DIGITS_AND_SIGN(int64_t);
-INTEGER_FOR_DIGITS_AND_SIGN(uint64_t);
-#undef INTEGER_FOR_DIGITS_AND_SIGN
-
-// WARNING: We have no IntegerForSizeAndSign<16, *>. If we ever add one to
-// support 128-bit math, then the ArithmeticPromotion template below will need
-// to be updated (or more likely replaced with a decltype expression).
-static_assert(IntegerBitsPlusSign<intmax_t>::value == 64,
-              "Max integer size not supported for this toolchain.");
-
-template <typename Integer, bool IsSigned = std::is_signed<Integer>::value>
-struct TwiceWiderInteger {
-  using type =
-      typename IntegerForDigitsAndSign<IntegerBitsPlusSign<Integer>::value * 2,
-                                       IsSigned>::type;
-};
-
-enum ArithmeticPromotionCategory {
-  LEFT_PROMOTION,  // Use the type of the left-hand argument.
-  RIGHT_PROMOTION  // Use the type of the right-hand argument.
-};
-
-// Determines the type that can represent the largest positive value.
-template <typename Lhs,
-          typename Rhs,
-          ArithmeticPromotionCategory Promotion =
-              (MaxExponent<Lhs>::value > MaxExponent<Rhs>::value)
-                  ? LEFT_PROMOTION
-                  : RIGHT_PROMOTION>
-struct MaxExponentPromotion;
-
-template <typename Lhs, typename Rhs>
-struct MaxExponentPromotion<Lhs, Rhs, LEFT_PROMOTION> {
-  using type = Lhs;
-};
-
-template <typename Lhs, typename Rhs>
-struct MaxExponentPromotion<Lhs, Rhs, RIGHT_PROMOTION> {
-  using type = Rhs;
-};
-
-// Determines the type that can represent the lowest arithmetic value.
-template <typename Lhs,
-          typename Rhs,
-          ArithmeticPromotionCategory Promotion =
-              std::is_signed<Lhs>::value
-                  ? (std::is_signed<Rhs>::value
-                         ? (MaxExponent<Lhs>::value > MaxExponent<Rhs>::value
-                                ? LEFT_PROMOTION
-                                : RIGHT_PROMOTION)
-                         : LEFT_PROMOTION)
-                  : (std::is_signed<Rhs>::value
-                         ? RIGHT_PROMOTION
-                         : (MaxExponent<Lhs>::value < MaxExponent<Rhs>::value
-                                ? LEFT_PROMOTION
-                                : RIGHT_PROMOTION))>
-struct LowestValuePromotion;
-
-template <typename Lhs, typename Rhs>
-struct LowestValuePromotion<Lhs, Rhs, LEFT_PROMOTION> {
-  using type = Lhs;
-};
-
-template <typename Lhs, typename Rhs>
-struct LowestValuePromotion<Lhs, Rhs, RIGHT_PROMOTION> {
-  using type = Rhs;
-};
-
-// Determines the type that is best able to represent an arithmetic result.
-template <
-    typename Lhs,
-    typename Rhs = Lhs,
-    bool is_intmax_type =
-        std::is_integral<typename MaxExponentPromotion<Lhs, Rhs>::type>::value&&
-            IntegerBitsPlusSign<typename MaxExponentPromotion<Lhs, Rhs>::type>::
-                value == IntegerBitsPlusSign<intmax_t>::value,
-    bool is_max_exponent =
-        StaticDstRangeRelationToSrcRange<
-            typename MaxExponentPromotion<Lhs, Rhs>::type,
-            Lhs>::value ==
-        NUMERIC_RANGE_CONTAINED&& StaticDstRangeRelationToSrcRange<
-            typename MaxExponentPromotion<Lhs, Rhs>::type,
-            Rhs>::value == NUMERIC_RANGE_CONTAINED>
-struct BigEnoughPromotion;
-
-// The side with the max exponent is big enough.
-template <typename Lhs, typename Rhs, bool is_intmax_type>
-struct BigEnoughPromotion<Lhs, Rhs, is_intmax_type, true> {
-  using type = typename MaxExponentPromotion<Lhs, Rhs>::type;
-  static const bool is_contained = true;
-};
-
-// We can use a twice wider type to fit.
-template <typename Lhs, typename Rhs>
-struct BigEnoughPromotion<Lhs, Rhs, false, false> {
-  using type =
-      typename TwiceWiderInteger<typename MaxExponentPromotion<Lhs, Rhs>::type,
-                                 std::is_signed<Lhs>::value ||
-                                     std::is_signed<Rhs>::value>::type;
-  static const bool is_contained = true;
-};
-
-// No type is large enough.
-template <typename Lhs, typename Rhs>
-struct BigEnoughPromotion<Lhs, Rhs, true, false> {
-  using type = typename MaxExponentPromotion<Lhs, Rhs>::type;
-  static const bool is_contained = false;
-};
-
-// We can statically check if operations on the provided types can wrap, so we
-// can skip the checked operations if they're not needed. So, for an integer we
-// care if the destination type preserves the sign and is twice the width of
-// the source.
-template <typename T, typename Lhs, typename Rhs = Lhs>
-struct IsIntegerArithmeticSafe {
-  static const bool value =
-      !std::is_floating_point<T>::value &&
-      !std::is_floating_point<Lhs>::value &&
-      !std::is_floating_point<Rhs>::value &&
-      std::is_signed<T>::value >= std::is_signed<Lhs>::value &&
-      IntegerBitsPlusSign<T>::value >= (2 * IntegerBitsPlusSign<Lhs>::value) &&
-      std::is_signed<T>::value >= std::is_signed<Rhs>::value &&
-      IntegerBitsPlusSign<T>::value >= (2 * IntegerBitsPlusSign<Rhs>::value);
-};
-
-// Promotes to a type that can represent any possible result of a binary
-// arithmetic operation with the source types.
-template <typename Lhs,
-          typename Rhs,
-          bool is_promotion_possible = IsIntegerArithmeticSafe<
-              typename std::conditional<std::is_signed<Lhs>::value ||
-                                            std::is_signed<Rhs>::value,
-                                        intmax_t,
-                                        uintmax_t>::type,
-              typename MaxExponentPromotion<Lhs, Rhs>::type>::value>
-struct FastIntegerArithmeticPromotion;
-
-template <typename Lhs, typename Rhs>
-struct FastIntegerArithmeticPromotion<Lhs, Rhs, true> {
-  using type =
-      typename TwiceWiderInteger<typename MaxExponentPromotion<Lhs, Rhs>::type,
-                                 std::is_signed<Lhs>::value ||
-                                     std::is_signed<Rhs>::value>::type;
-  static_assert(IsIntegerArithmeticSafe<type, Lhs, Rhs>::value, "");
-  static const bool is_contained = true;
-};
-
-template <typename Lhs, typename Rhs>
-struct FastIntegerArithmeticPromotion<Lhs, Rhs, false> {
-  using type = typename BigEnoughPromotion<Lhs, Rhs>::type;
-  static const bool is_contained = false;
-};
-
-// Extracts the underlying type from an enum.
-template <typename T, bool is_enum = std::is_enum<T>::value>
-struct ArithmeticOrUnderlyingEnum;
-
-template <typename T>
-struct ArithmeticOrUnderlyingEnum<T, true> {
-  using type = typename std::underlying_type<T>::type;
-  static const bool value = std::is_arithmetic<type>::value;
-};
-
-template <typename T>
-struct ArithmeticOrUnderlyingEnum<T, false> {
-  using type = T;
-  static const bool value = std::is_arithmetic<type>::value;
-};
-
-// The following are helper templates used in the CheckedNumeric class.
-template <typename T>
-class CheckedNumeric;
-
-template <typename T>
-class ClampedNumeric;
-
-template <typename T>
-class StrictNumeric;
-
-// Used to treat CheckedNumeric and arithmetic underlying types the same.
-template <typename T>
-struct UnderlyingType {
-  using type = typename ArithmeticOrUnderlyingEnum<T>::type;
-  static const bool is_numeric = std::is_arithmetic<type>::value;
-  static const bool is_checked = false;
-  static const bool is_clamped = false;
-  static const bool is_strict = false;
-};
-
-template <typename T>
-struct UnderlyingType<CheckedNumeric<T>> {
-  using type = T;
-  static const bool is_numeric = true;
-  static const bool is_checked = true;
-  static const bool is_clamped = false;
-  static const bool is_strict = false;
-};
-
-template <typename T>
-struct UnderlyingType<ClampedNumeric<T>> {
-  using type = T;
-  static const bool is_numeric = true;
-  static const bool is_checked = false;
-  static const bool is_clamped = true;
-  static const bool is_strict = false;
-};
-
-template <typename T>
-struct UnderlyingType<StrictNumeric<T>> {
-  using type = T;
-  static const bool is_numeric = true;
-  static const bool is_checked = false;
-  static const bool is_clamped = false;
-  static const bool is_strict = true;
-};
-
-template <typename L, typename R>
-struct IsCheckedOp {
-  static const bool value =
-      UnderlyingType<L>::is_numeric && UnderlyingType<R>::is_numeric &&
-      (UnderlyingType<L>::is_checked || UnderlyingType<R>::is_checked);
-};
-
-template <typename L, typename R>
-struct IsClampedOp {
-  static const bool value =
-      UnderlyingType<L>::is_numeric && UnderlyingType<R>::is_numeric &&
-      (UnderlyingType<L>::is_clamped || UnderlyingType<R>::is_clamped) &&
-      !(UnderlyingType<L>::is_checked || UnderlyingType<R>::is_checked);
-};
-
-template <typename L, typename R>
-struct IsStrictOp {
-  static const bool value =
-      UnderlyingType<L>::is_numeric && UnderlyingType<R>::is_numeric &&
-      (UnderlyingType<L>::is_strict || UnderlyingType<R>::is_strict) &&
-      !(UnderlyingType<L>::is_checked || UnderlyingType<R>::is_checked) &&
-      !(UnderlyingType<L>::is_clamped || UnderlyingType<R>::is_clamped);
-};
-
-// as_signed<> returns the supplied integral value (or integral castable
-// Numeric template) cast as a signed integral of equivalent precision.
-// I.e. it's mostly an alias for: static_cast<std::make_signed<T>::type>(t)
-template <typename Src>
-constexpr typename std::make_signed<
-    typename base::internal::UnderlyingType<Src>::type>::type
-as_signed(const Src value) {
-  static_assert(std::is_integral<decltype(as_signed(value))>::value,
-                "Argument must be a signed or unsigned integer type.");
-  return static_cast<decltype(as_signed(value))>(value);
-}
-
-// as_unsigned<> returns the supplied integral value (or integral castable
-// Numeric template) cast as an unsigned integral of equivalent precision.
-// I.e. it's mostly an alias for: static_cast<std::make_unsigned<T>::type>(t)
-template <typename Src>
-constexpr typename std::make_unsigned<
-    typename base::internal::UnderlyingType<Src>::type>::type
-as_unsigned(const Src value) {
-  static_assert(std::is_integral<decltype(as_unsigned(value))>::value,
-                "Argument must be a signed or unsigned integer type.");
-  return static_cast<decltype(as_unsigned(value))>(value);
-}
-
-template <typename L, typename R>
-constexpr bool IsLessImpl(const L lhs,
-                          const R rhs,
-                          const RangeCheck l_range,
-                          const RangeCheck r_range) {
-  return l_range.IsUnderflow() || r_range.IsOverflow() ||
-         (l_range == r_range &&
-          static_cast<decltype(lhs + rhs)>(lhs) <
-              static_cast<decltype(lhs + rhs)>(rhs));
-}
-
-template <typename L, typename R>
-struct IsLess {
-  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
-                "Types must be numeric.");
-  static constexpr bool Test(const L lhs, const R rhs) {
-    return IsLessImpl(lhs, rhs, DstRangeRelationToSrcRange<R>(lhs),
-                      DstRangeRelationToSrcRange<L>(rhs));
-  }
-};
-
-template <typename L, typename R>
-constexpr bool IsLessOrEqualImpl(const L lhs,
-                                 const R rhs,
-                                 const RangeCheck l_range,
-                                 const RangeCheck r_range) {
-  return l_range.IsUnderflow() || r_range.IsOverflow() ||
-         (l_range == r_range &&
-          static_cast<decltype(lhs + rhs)>(lhs) <=
-              static_cast<decltype(lhs + rhs)>(rhs));
-}
-
-template <typename L, typename R>
-struct IsLessOrEqual {
-  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
-                "Types must be numeric.");
-  static constexpr bool Test(const L lhs, const R rhs) {
-    return IsLessOrEqualImpl(lhs, rhs, DstRangeRelationToSrcRange<R>(lhs),
-                             DstRangeRelationToSrcRange<L>(rhs));
-  }
-};
-
-template <typename L, typename R>
-constexpr bool IsGreaterImpl(const L lhs,
-                             const R rhs,
-                             const RangeCheck l_range,
-                             const RangeCheck r_range) {
-  return l_range.IsOverflow() || r_range.IsUnderflow() ||
-         (l_range == r_range &&
-          static_cast<decltype(lhs + rhs)>(lhs) >
-              static_cast<decltype(lhs + rhs)>(rhs));
-}
-
-template <typename L, typename R>
-struct IsGreater {
-  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
-                "Types must be numeric.");
-  static constexpr bool Test(const L lhs, const R rhs) {
-    return IsGreaterImpl(lhs, rhs, DstRangeRelationToSrcRange<R>(lhs),
-                         DstRangeRelationToSrcRange<L>(rhs));
-  }
-};
-
-template <typename L, typename R>
-constexpr bool IsGreaterOrEqualImpl(const L lhs,
-                                    const R rhs,
-                                    const RangeCheck l_range,
-                                    const RangeCheck r_range) {
-  return l_range.IsOverflow() || r_range.IsUnderflow() ||
-         (l_range == r_range &&
-          static_cast<decltype(lhs + rhs)>(lhs) >=
-              static_cast<decltype(lhs + rhs)>(rhs));
-}
-
-template <typename L, typename R>
-struct IsGreaterOrEqual {
-  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
-                "Types must be numeric.");
-  static constexpr bool Test(const L lhs, const R rhs) {
-    return IsGreaterOrEqualImpl(lhs, rhs, DstRangeRelationToSrcRange<R>(lhs),
-                                DstRangeRelationToSrcRange<L>(rhs));
-  }
-};
-
-template <typename L, typename R>
-struct IsEqual {
-  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
-                "Types must be numeric.");
-  static constexpr bool Test(const L lhs, const R rhs) {
-    return DstRangeRelationToSrcRange<R>(lhs) ==
-               DstRangeRelationToSrcRange<L>(rhs) &&
-           static_cast<decltype(lhs + rhs)>(lhs) ==
-               static_cast<decltype(lhs + rhs)>(rhs);
-  }
-};
-
-template <typename L, typename R>
-struct IsNotEqual {
-  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
-                "Types must be numeric.");
-  static constexpr bool Test(const L lhs, const R rhs) {
-    return DstRangeRelationToSrcRange<R>(lhs) !=
-               DstRangeRelationToSrcRange<L>(rhs) ||
-           static_cast<decltype(lhs + rhs)>(lhs) !=
-               static_cast<decltype(lhs + rhs)>(rhs);
-  }
-};
-
-// These perform the actual math operations on the CheckedNumerics.
-// Binary arithmetic operations.
-template <template <typename, typename> class C, typename L, typename R>
-constexpr bool SafeCompare(const L lhs, const R rhs) {
-  static_assert(std::is_arithmetic<L>::value && std::is_arithmetic<R>::value,
-                "Types must be numeric.");
-  using Promotion = BigEnoughPromotion<L, R>;
-  using BigType = typename Promotion::type;
-  return Promotion::is_contained
-             // Force to a larger type for speed if both are contained.
-             ? C<BigType, BigType>::Test(
-                   static_cast<BigType>(static_cast<L>(lhs)),
-                   static_cast<BigType>(static_cast<R>(rhs)))
-             // Let the template functions figure it out for mixed types.
-             : C<L, R>::Test(lhs, rhs);
-}
-
-template <typename Dst, typename Src>
-constexpr bool IsMaxInRangeForNumericType() {
-  return IsGreaterOrEqual<Dst, Src>::Test(std::numeric_limits<Dst>::max(),
-                                          std::numeric_limits<Src>::max());
-}
-
-template <typename Dst, typename Src>
-constexpr bool IsMinInRangeForNumericType() {
-  return IsLessOrEqual<Dst, Src>::Test(std::numeric_limits<Dst>::lowest(),
-                                       std::numeric_limits<Src>::lowest());
-}
-
-template <typename Dst, typename Src>
-constexpr Dst CommonMax() {
-  return !IsMaxInRangeForNumericType<Dst, Src>()
-             ? Dst(std::numeric_limits<Dst>::max())
-             : Dst(std::numeric_limits<Src>::max());
-}
-
-template <typename Dst, typename Src>
-constexpr Dst CommonMin() {
-  return !IsMinInRangeForNumericType<Dst, Src>()
-             ? Dst(std::numeric_limits<Dst>::lowest())
-             : Dst(std::numeric_limits<Src>::lowest());
-}
-
-// This is a wrapper to generate return the max or min for a supplied type.
-// If the argument is false, the returned value is the maximum. If true the
-// returned value is the minimum.
-template <typename Dst, typename Src = Dst>
-constexpr Dst CommonMaxOrMin(bool is_min) {
-  return is_min ? CommonMin<Dst, Src>() : CommonMax<Dst, Src>();
-}
-
-}  // namespace internal
-}  // namespace base
-
-#endif  // BASE_NUMERICS_SAFE_CONVERSIONS_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/safe_math.h b/native/zucchini/vendor/libchrome/base/numerics/safe_math.h
deleted file mode 100644
index e30be90..0000000
--- a/native/zucchini/vendor/libchrome/base/numerics/safe_math.h
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_NUMERICS_SAFE_MATH_H_
-#define BASE_NUMERICS_SAFE_MATH_H_
-
-#include "base/numerics/checked_math.h"
-#include "base/numerics/clamped_math.h"
-#include "base/numerics/safe_conversions.h"
-
-#endif  // BASE_NUMERICS_SAFE_MATH_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/safe_math_clang_gcc_impl.h b/native/zucchini/vendor/libchrome/base/numerics/safe_math_clang_gcc_impl.h
deleted file mode 100644
index 1760338..0000000
--- a/native/zucchini/vendor/libchrome/base/numerics/safe_math_clang_gcc_impl.h
+++ /dev/null
@@ -1,157 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_NUMERICS_SAFE_MATH_CLANG_GCC_IMPL_H_
-#define BASE_NUMERICS_SAFE_MATH_CLANG_GCC_IMPL_H_
-
-#include <cassert>
-#include <limits>
-#include <type_traits>
-
-#include "base/numerics/safe_conversions.h"
-
-#if !defined(__native_client__) && (defined(__ARMEL__) || defined(__arch64__))
-#include "base/numerics/safe_math_arm_impl.h"
-#define BASE_HAS_ASSEMBLER_SAFE_MATH (1)
-#else
-#define BASE_HAS_ASSEMBLER_SAFE_MATH (0)
-#endif
-
-namespace base {
-namespace internal {
-
-// These are the non-functioning boilerplate implementations of the optimized
-// safe math routines.
-#if !BASE_HAS_ASSEMBLER_SAFE_MATH
-template <typename T, typename U>
-struct CheckedMulFastAsmOp {
-  static const bool is_supported = false;
-  template <typename V>
-  static constexpr bool Do(T, U, V*) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<bool>();
-  }
-};
-
-template <typename T, typename U>
-struct ClampedAddFastAsmOp {
-  static const bool is_supported = false;
-  template <typename V>
-  static constexpr V Do(T, U) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<V>();
-  }
-};
-
-template <typename T, typename U>
-struct ClampedSubFastAsmOp {
-  static const bool is_supported = false;
-  template <typename V>
-  static constexpr V Do(T, U) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<V>();
-  }
-};
-
-template <typename T, typename U>
-struct ClampedMulFastAsmOp {
-  static const bool is_supported = false;
-  template <typename V>
-  static constexpr V Do(T, U) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<V>();
-  }
-};
-#endif  // BASE_HAS_ASSEMBLER_SAFE_MATH
-#undef BASE_HAS_ASSEMBLER_SAFE_MATH
-
-template <typename T, typename U>
-struct CheckedAddFastOp {
-  static const bool is_supported = true;
-  template <typename V>
-  __attribute__((always_inline)) static constexpr bool Do(T x, U y, V* result) {
-    return !__builtin_add_overflow(x, y, result);
-  }
-};
-
-template <typename T, typename U>
-struct CheckedSubFastOp {
-  static const bool is_supported = true;
-  template <typename V>
-  __attribute__((always_inline)) static constexpr bool Do(T x, U y, V* result) {
-    return !__builtin_sub_overflow(x, y, result);
-  }
-};
-
-template <typename T, typename U>
-struct CheckedMulFastOp {
-#if defined(__clang__)
-  // TODO(jschuh): Get the Clang runtime library issues sorted out so we can
-  // support full-width, mixed-sign multiply builtins.
-  // https://crbug.com/613003
-  // We can support intptr_t, uintptr_t, or a smaller common type.
-  static const bool is_supported =
-      (IsTypeInRangeForNumericType<intptr_t, T>::value &&
-       IsTypeInRangeForNumericType<intptr_t, U>::value) ||
-      (IsTypeInRangeForNumericType<uintptr_t, T>::value &&
-       IsTypeInRangeForNumericType<uintptr_t, U>::value);
-#else
-  static const bool is_supported = true;
-#endif
-  template <typename V>
-  __attribute__((always_inline)) static constexpr bool Do(T x, U y, V* result) {
-    return CheckedMulFastAsmOp<T, U>::is_supported
-               ? CheckedMulFastAsmOp<T, U>::Do(x, y, result)
-               : !__builtin_mul_overflow(x, y, result);
-  }
-};
-
-template <typename T, typename U>
-struct ClampedAddFastOp {
-  static const bool is_supported = ClampedAddFastAsmOp<T, U>::is_supported;
-  template <typename V>
-  __attribute__((always_inline)) static V Do(T x, U y) {
-    return ClampedAddFastAsmOp<T, U>::template Do<V>(x, y);
-  }
-};
-
-template <typename T, typename U>
-struct ClampedSubFastOp {
-  static const bool is_supported = ClampedSubFastAsmOp<T, U>::is_supported;
-  template <typename V>
-  __attribute__((always_inline)) static V Do(T x, U y) {
-    return ClampedSubFastAsmOp<T, U>::template Do<V>(x, y);
-  }
-};
-
-template <typename T, typename U>
-struct ClampedMulFastOp {
-  static const bool is_supported = ClampedMulFastAsmOp<T, U>::is_supported;
-  template <typename V>
-  __attribute__((always_inline)) static V Do(T x, U y) {
-    return ClampedMulFastAsmOp<T, U>::template Do<V>(x, y);
-  }
-};
-
-template <typename T>
-struct ClampedNegFastOp {
-  static const bool is_supported = std::is_signed<T>::value;
-  __attribute__((always_inline)) static T Do(T value) {
-    // Use this when there is no assembler path available.
-    if (!ClampedSubFastAsmOp<T, T>::is_supported) {
-      T result;
-      return !__builtin_sub_overflow(T(0), value, &result)
-                 ? result
-                 : std::numeric_limits<T>::max();
-    }
-
-    // Fallback to the normal subtraction path.
-    return ClampedSubFastOp<T, T>::template Do<T>(T(0), value);
-  }
-};
-
-}  // namespace internal
-}  // namespace base
-
-#endif  // BASE_NUMERICS_SAFE_MATH_CLANG_GCC_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/numerics/safe_math_shared_impl.h b/native/zucchini/vendor/libchrome/base/numerics/safe_math_shared_impl.h
deleted file mode 100644
index 583c487..0000000
--- a/native/zucchini/vendor/libchrome/base/numerics/safe_math_shared_impl.h
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_NUMERICS_SAFE_MATH_SHARED_IMPL_H_
-#define BASE_NUMERICS_SAFE_MATH_SHARED_IMPL_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <cassert>
-#include <climits>
-#include <cmath>
-#include <cstdlib>
-#include <limits>
-#include <type_traits>
-
-#include "base/numerics/safe_conversions.h"
-
-// Where available use builtin math overflow support on Clang and GCC.
-#if !defined(__native_client__) &&                         \
-    ((defined(__clang__) &&                                \
-      ((__clang_major__ > 3) ||                            \
-       (__clang_major__ == 3 && __clang_minor__ >= 4))) || \
-     (defined(__GNUC__) && __GNUC__ >= 5))
-#include "base/numerics/safe_math_clang_gcc_impl.h"
-#define BASE_HAS_OPTIMIZED_SAFE_MATH (1)
-#else
-#define BASE_HAS_OPTIMIZED_SAFE_MATH (0)
-#endif
-
-namespace base {
-namespace internal {
-
-// These are the non-functioning boilerplate implementations of the optimized
-// safe math routines.
-#if !BASE_HAS_OPTIMIZED_SAFE_MATH
-template <typename T, typename U>
-struct CheckedAddFastOp {
-  static const bool is_supported = false;
-  template <typename V>
-  static constexpr bool Do(T, U, V*) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<bool>();
-  }
-};
-
-template <typename T, typename U>
-struct CheckedSubFastOp {
-  static const bool is_supported = false;
-  template <typename V>
-  static constexpr bool Do(T, U, V*) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<bool>();
-  }
-};
-
-template <typename T, typename U>
-struct CheckedMulFastOp {
-  static const bool is_supported = false;
-  template <typename V>
-  static constexpr bool Do(T, U, V*) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<bool>();
-  }
-};
-
-template <typename T, typename U>
-struct ClampedAddFastOp {
-  static const bool is_supported = false;
-  template <typename V>
-  static constexpr V Do(T, U) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<V>();
-  }
-};
-
-template <typename T, typename U>
-struct ClampedSubFastOp {
-  static const bool is_supported = false;
-  template <typename V>
-  static constexpr V Do(T, U) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<V>();
-  }
-};
-
-template <typename T, typename U>
-struct ClampedMulFastOp {
-  static const bool is_supported = false;
-  template <typename V>
-  static constexpr V Do(T, U) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<V>();
-  }
-};
-
-template <typename T>
-struct ClampedNegFastOp {
-  static const bool is_supported = false;
-  static constexpr T Do(T) {
-    // Force a compile failure if instantiated.
-    return CheckOnFailure::template HandleFailure<T>();
-  }
-};
-#endif  // BASE_HAS_OPTIMIZED_SAFE_MATH
-#undef BASE_HAS_OPTIMIZED_SAFE_MATH
-
-// This is used for UnsignedAbs, where we need to support floating-point
-// template instantiations even though we don't actually support the operations.
-// However, there is no corresponding implementation of e.g. SafeUnsignedAbs,
-// so the float versions will not compile.
-template <typename Numeric,
-          bool IsInteger = std::is_integral<Numeric>::value,
-          bool IsFloat = std::is_floating_point<Numeric>::value>
-struct UnsignedOrFloatForSize;
-
-template <typename Numeric>
-struct UnsignedOrFloatForSize<Numeric, true, false> {
-  using type = typename std::make_unsigned<Numeric>::type;
-};
-
-template <typename Numeric>
-struct UnsignedOrFloatForSize<Numeric, false, true> {
-  using type = Numeric;
-};
-
-// Wrap the unary operations to allow SFINAE when instantiating integrals versus
-// floating points. These don't perform any overflow checking. Rather, they
-// exhibit well-defined overflow semantics and rely on the caller to detect
-// if an overflow occured.
-
-template <typename T,
-          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
-constexpr T NegateWrapper(T value) {
-  using UnsignedT = typename std::make_unsigned<T>::type;
-  // This will compile to a NEG on Intel, and is normal negation on ARM.
-  return static_cast<T>(UnsignedT(0) - static_cast<UnsignedT>(value));
-}
-
-template <
-    typename T,
-    typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
-constexpr T NegateWrapper(T value) {
-  return -value;
-}
-
-template <typename T,
-          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
-constexpr typename std::make_unsigned<T>::type InvertWrapper(T value) {
-  return ~value;
-}
-
-template <typename T,
-          typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
-constexpr T AbsWrapper(T value) {
-  return static_cast<T>(SafeUnsignedAbs(value));
-}
-
-template <
-    typename T,
-    typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
-constexpr T AbsWrapper(T value) {
-  return value < 0 ? -value : value;
-}
-
-template <template <typename, typename, typename> class M,
-          typename L,
-          typename R>
-struct MathWrapper {
-  using math = M<typename UnderlyingType<L>::type,
-                 typename UnderlyingType<R>::type,
-                 void>;
-  using type = typename math::result_type;
-};
-
-// These variadic templates work out the return types.
-// TODO(jschuh): Rip all this out once we have C++14 non-trailing auto support.
-template <template <typename, typename, typename> class M,
-          typename L,
-          typename R,
-          typename... Args>
-struct ResultType;
-
-template <template <typename, typename, typename> class M,
-          typename L,
-          typename R>
-struct ResultType<M, L, R> {
-  using type = typename MathWrapper<M, L, R>::type;
-};
-
-template <template <typename, typename, typename> class M,
-          typename L,
-          typename R,
-          typename... Args>
-struct ResultType {
-  using type =
-      typename ResultType<M, typename ResultType<M, L, R>::type, Args...>::type;
-};
-
-// The following macros are just boilerplate for the standard arithmetic
-// operator overloads and variadic function templates. A macro isn't the nicest
-// solution, but it beats rewriting these over and over again.
-#define BASE_NUMERIC_ARITHMETIC_VARIADIC(CLASS, CL_ABBR, OP_NAME)       \
-  template <typename L, typename R, typename... Args>                   \
-  constexpr CLASS##Numeric<                                             \
-      typename ResultType<CLASS##OP_NAME##Op, L, R, Args...>::type>     \
-      CL_ABBR##OP_NAME(const L lhs, const R rhs, const Args... args) {  \
-    return CL_ABBR##MathOp<CLASS##OP_NAME##Op, L, R, Args...>(lhs, rhs, \
-                                                              args...); \
-  }
-
-#define BASE_NUMERIC_ARITHMETIC_OPERATORS(CLASS, CL_ABBR, OP_NAME, OP, CMP_OP) \
-  /* Binary arithmetic operator for all CLASS##Numeric operations. */          \
-  template <typename L, typename R,                                            \
-            typename std::enable_if<Is##CLASS##Op<L, R>::value>::type* =       \
-                nullptr>                                                       \
-  constexpr CLASS##Numeric<                                                    \
-      typename MathWrapper<CLASS##OP_NAME##Op, L, R>::type>                    \
-  operator OP(const L lhs, const R rhs) {                                      \
-    return decltype(lhs OP rhs)::template MathOp<CLASS##OP_NAME##Op>(lhs,      \
-                                                                     rhs);     \
-  }                                                                            \
-  /* Assignment arithmetic operator implementation from CLASS##Numeric. */     \
-  template <typename L>                                                        \
-  template <typename R>                                                        \
-  constexpr CLASS##Numeric<L>& CLASS##Numeric<L>::operator CMP_OP(             \
-      const R rhs) {                                                           \
-    return MathOp<CLASS##OP_NAME##Op>(rhs);                                    \
-  }                                                                            \
-  /* Variadic arithmetic functions that return CLASS##Numeric. */              \
-  BASE_NUMERIC_ARITHMETIC_VARIADIC(CLASS, CL_ABBR, OP_NAME)
-
-}  // namespace internal
-}  // namespace base
-
-#endif  // BASE_NUMERICS_SAFE_MATH_SHARED_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/observer_list.h b/native/zucchini/vendor/libchrome/base/observer_list.h
deleted file mode 100644
index e900e43..0000000
--- a/native/zucchini/vendor/libchrome/base/observer_list.h
+++ /dev/null
@@ -1,307 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_OBSERVER_LIST_H_
-#define BASE_OBSERVER_LIST_H_
-
-#include <stddef.h>
-
-#include <algorithm>
-#include <iterator>
-#include <limits>
-#include <utility>
-#include <vector>
-
-#include "base/gtest_prod_util.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/weak_ptr.h"
-#include "base/stl_util.h"
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// OVERVIEW:
-//
-//   A list of observers. Unlike a standard vector or list, this container can
-//   be modified during iteration without invalidating the iterator. So, it
-//   safely handles the case of an observer removing itself or other observers
-//   from the list while observers are being notified.
-//
-//
-// WARNING:
-//
-//   ObserverList is not thread-compatible. Iterating on the same ObserverList
-//   simultaneously in different threads is not safe, even when the ObserverList
-//   itself is not modified.
-//
-//   For a thread-safe observer list, see ObserverListThreadSafe.
-//
-//
-// TYPICAL USAGE:
-//
-//   class MyWidget {
-//    public:
-//     ...
-//
-//     class Observer {
-//      public:
-//       virtual void OnFoo(MyWidget* w) = 0;
-//       virtual void OnBar(MyWidget* w, int x, int y) = 0;
-//     };
-//
-//     void AddObserver(Observer* obs) {
-//       observers_.AddObserver(obs);
-//     }
-//
-//     void RemoveObserver(const Observer* obs) {
-//       observers_.RemoveObserver(obs);
-//     }
-//
-//     void NotifyFoo() {
-//       for (Observer& obs : observers_)
-//         obs.OnFoo(this);
-//     }
-//
-//     void NotifyBar(int x, int y) {
-//       for (Observer& obs : observers_)
-//         obs.OnBar(this, x, y);
-//     }
-//
-//    private:
-//     base::ObserverList<Observer> observers_;
-//   };
-//
-//
-///////////////////////////////////////////////////////////////////////////////
-
-namespace base {
-
-// Enumeration of which observers are notified by ObserverList.
-enum class ObserverListPolicy {
-  // Specifies that any observers added during notification are notified.
-  // This is the default policy if no policy is provided to the constructor.
-  ALL,
-
-  // Specifies that observers added while sending out notification are not
-  // notified.
-  EXISTING_ONLY,
-};
-
-// When check_empty is true, assert that the list is empty on destruction.
-// When allow_reentrancy is false, iterating throught the list while already in
-// the iteration loop will result in DCHECK failure.
-// TODO(oshima): Change the default to non reentrant. https://crbug.com/812109
-template <class ObserverType,
-          bool check_empty = false,
-          bool allow_reentrancy = true>
-class ObserverList
-    : public SupportsWeakPtr<
-          ObserverList<ObserverType, check_empty, allow_reentrancy>> {
- public:
-  // An iterator class that can be used to access the list of observers.
-  class Iter {
-   public:
-    using iterator_category = std::forward_iterator_tag;
-    using value_type = ObserverType;
-    using difference_type = ptrdiff_t;
-    using pointer = ObserverType*;
-    using reference = ObserverType&;
-
-    Iter() : index_(0), max_index_(0) {}
-
-    explicit Iter(const ObserverList* list)
-        : list_(const_cast<ObserverList*>(list)->AsWeakPtr()),
-          index_(0),
-          max_index_(list->policy_ == ObserverListPolicy::ALL
-                         ? std::numeric_limits<size_t>::max()
-                         : list->observers_.size()) {
-      DCHECK(list_);
-      DCHECK(allow_reentrancy || !list_->live_iterator_count_);
-      EnsureValidIndex();
-      ++list_->live_iterator_count_;
-    }
-
-    ~Iter() {
-      if (!list_)
-        return;
-
-      DCHECK_GT(list_->live_iterator_count_, 0);
-      if (--list_->live_iterator_count_ == 0)
-        list_->Compact();
-    }
-
-    Iter(const Iter& other)
-        : list_(other.list_),
-          index_(other.index_),
-          max_index_(other.max_index_) {
-      if (list_)
-        ++list_->live_iterator_count_;
-    }
-
-    Iter& operator=(Iter other) {
-      using std::swap;
-      swap(list_, other.list_);
-      swap(index_, other.index_);
-      swap(max_index_, other.max_index_);
-      return *this;
-    }
-
-    bool operator==(const Iter& other) const {
-      return (is_end() && other.is_end()) ||
-             (list_.get() == other.list_.get() && index_ == other.index_);
-    }
-
-    bool operator!=(const Iter& other) const { return !(*this == other); }
-
-    Iter& operator++() {
-      if (list_) {
-        ++index_;
-        EnsureValidIndex();
-      }
-      return *this;
-    }
-
-    Iter operator++(int) {
-      Iter it(*this);
-      ++(*this);
-      return it;
-    }
-
-    ObserverType* operator->() const {
-      ObserverType* const current = GetCurrent();
-      DCHECK(current);
-      return current;
-    }
-
-    ObserverType& operator*() const {
-      ObserverType* const current = GetCurrent();
-      DCHECK(current);
-      return *current;
-    }
-
-   private:
-    FRIEND_TEST_ALL_PREFIXES(ObserverListTest, BasicStdIterator);
-    FRIEND_TEST_ALL_PREFIXES(ObserverListTest, StdIteratorRemoveFront);
-
-    ObserverType* GetCurrent() const {
-      DCHECK(list_);
-      DCHECK_LT(index_, clamped_max_index());
-      return list_->observers_[index_];
-    }
-
-    void EnsureValidIndex() {
-      DCHECK(list_);
-      const size_t max_index = clamped_max_index();
-      while (index_ < max_index && !list_->observers_[index_])
-        ++index_;
-    }
-
-    size_t clamped_max_index() const {
-      return std::min(max_index_, list_->observers_.size());
-    }
-
-    bool is_end() const { return !list_ || index_ == clamped_max_index(); }
-
-    WeakPtr<ObserverList> list_;
-
-    // When initially constructed and each time the iterator is incremented,
-    // |index_| is guaranteed to point to a non-null index if the iterator
-    // has not reached the end of the ObserverList.
-    size_t index_;
-    size_t max_index_;
-  };
-
-  using iterator = Iter;
-  using const_iterator = Iter;
-
-  const_iterator begin() const {
-    // An optimization: do not involve weak pointers for empty list.
-    return observers_.empty() ? const_iterator() : const_iterator(this);
-  }
-
-  const_iterator end() const { return const_iterator(); }
-
-  ObserverList() = default;
-  explicit ObserverList(ObserverListPolicy policy) : policy_(policy) {}
-
-  ~ObserverList() {
-    if (check_empty) {
-      Compact();
-      DCHECK(observers_.empty());
-    }
-  }
-
-  // Add an observer to this list. An observer should not be added to the same
-  // list more than once.
-  //
-  // Precondition: obs != nullptr
-  // Precondition: !HasObserver(obs)
-  void AddObserver(ObserverType* obs) {
-    DCHECK(obs);
-    if (HasObserver(obs)) {
-      NOTREACHED() << "Observers can only be added once!";
-      return;
-    }
-    observers_.push_back(obs);
-  }
-
-  // Removes the given observer from this list. Does nothing if this observer is
-  // not in this list.
-  void RemoveObserver(const ObserverType* obs) {
-    DCHECK(obs);
-    const auto it = std::find(observers_.begin(), observers_.end(), obs);
-    if (it == observers_.end())
-      return;
-
-    DCHECK_GE(live_iterator_count_, 0);
-    if (live_iterator_count_) {
-      *it = nullptr;
-    } else {
-      observers_.erase(it);
-    }
-  }
-
-  // Determine whether a particular observer is in the list.
-  bool HasObserver(const ObserverType* obs) const {
-    return ContainsValue(observers_, obs);
-  }
-
-  // Removes all the observers from this list.
-  void Clear() {
-    DCHECK_GE(live_iterator_count_, 0);
-    if (live_iterator_count_) {
-      std::fill(observers_.begin(), observers_.end(), nullptr);
-    } else {
-      observers_.clear();
-    }
-  }
-
-  bool might_have_observers() const { return !observers_.empty(); }
-
- private:
-  // Compacts list of observers by removing null pointers.
-  void Compact() {
-    observers_.erase(std::remove(observers_.begin(), observers_.end(), nullptr),
-                     observers_.end());
-  }
-
-  std::vector<ObserverType*> observers_;
-
-  // Number of active iterators referencing this ObserverList.
-  //
-  // This counter is not synchronized although it is modified by const
-  // iterators.
-  int live_iterator_count_ = 0;
-
-  const ObserverListPolicy policy_ = ObserverListPolicy::ALL;
-
-  DISALLOW_COPY_AND_ASSIGN(ObserverList);
-};
-
-template <class ObserverType, bool check_empty = false>
-using ReentrantObserverList = ObserverList<ObserverType, check_empty, true>;
-
-}  // namespace base
-
-#endif  // BASE_OBSERVER_LIST_H_
diff --git a/native/zucchini/vendor/libchrome/base/observer_list_threadsafe.h b/native/zucchini/vendor/libchrome/base/observer_list_threadsafe.h
deleted file mode 100644
index bd349f3..0000000
--- a/native/zucchini/vendor/libchrome/base/observer_list_threadsafe.h
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_OBSERVER_LIST_THREADSAFE_H_
-#define BASE_OBSERVER_LIST_THREADSAFE_H_
-
-#include <unordered_map>
-
-#include "base/base_export.h"
-#include "base/bind.h"
-#include "base/lazy_instance.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/observer_list.h"
-#include "base/sequenced_task_runner.h"
-#include "base/stl_util.h"
-#include "base/synchronization/lock.h"
-#include "base/threading/sequenced_task_runner_handle.h"
-#include "base/threading/thread_local.h"
-#include "build/build_config.h"
-
-// TODO(fdoray): Removing these includes causes IWYU failures in other headers,
-// remove them in a follow- up CL.
-#include "base/memory/ptr_util.h"
-#include "base/single_thread_task_runner.h"
-#include "base/threading/thread_task_runner_handle.h"
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// OVERVIEW:
-//
-//   A thread-safe container for a list of observers. This is similar to the
-//   observer_list (see observer_list.h), but it is more robust for multi-
-//   threaded situations.
-//
-//   The following use cases are supported:
-//    * Observers can register for notifications from any sequence. They are
-//      always notified on the sequence from which they were registered.
-//    * Any sequence may trigger a notification via Notify().
-//    * Observers can remove themselves from the observer list inside of a
-//      callback.
-//    * If one sequence is notifying observers concurrently with an observer
-//      removing itself from the observer list, the notifications will be
-//      silently dropped.
-//
-//   The drawback of the threadsafe observer list is that notifications are not
-//   as real-time as the non-threadsafe version of this class. Notifications
-//   will always be done via PostTask() to another sequence, whereas with the
-//   non-thread-safe observer_list, notifications happen synchronously.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-namespace base {
-namespace internal {
-
-class BASE_EXPORT ObserverListThreadSafeBase
-    : public RefCountedThreadSafe<ObserverListThreadSafeBase> {
- public:
-  ObserverListThreadSafeBase() = default;
-
- protected:
-  template <typename ObserverType, typename Method>
-  struct Dispatcher;
-
-  template <typename ObserverType, typename ReceiverType, typename... Params>
-  struct Dispatcher<ObserverType, void (ReceiverType::*)(Params...)> {
-    static void Run(void (ReceiverType::*m)(Params...),
-                    Params... params,
-                    ObserverType* obj) {
-      (obj->*m)(std::forward<Params>(params)...);
-    }
-  };
-
-  struct NotificationDataBase {
-    NotificationDataBase(void* observer_list_in, const Location& from_here_in)
-        : observer_list(observer_list_in), from_here(from_here_in) {}
-
-    void* observer_list;
-    Location from_here;
-  };
-
-  virtual ~ObserverListThreadSafeBase() = default;
-
-  static LazyInstance<ThreadLocalPointer<const NotificationDataBase>>::Leaky
-      tls_current_notification_;
-
- private:
-  friend class RefCountedThreadSafe<ObserverListThreadSafeBase>;
-
-  DISALLOW_COPY_AND_ASSIGN(ObserverListThreadSafeBase);
-};
-
-}  // namespace internal
-
-template <class ObserverType>
-class ObserverListThreadSafe : public internal::ObserverListThreadSafeBase {
- public:
-  ObserverListThreadSafe() = default;
-  explicit ObserverListThreadSafe(ObserverListPolicy policy)
-      : policy_(policy) {}
-
-  // Adds |observer| to the list. |observer| must not already be in the list.
-  void AddObserver(ObserverType* observer) {
-    // TODO(fdoray): Change this to a DCHECK once all call sites have a
-    // SequencedTaskRunnerHandle.
-    if (!SequencedTaskRunnerHandle::IsSet())
-      return;
-
-    AutoLock auto_lock(lock_);
-
-    // Add |observer| to the list of observers.
-    DCHECK(!ContainsKey(observers_, observer));
-    const scoped_refptr<SequencedTaskRunner> task_runner =
-        SequencedTaskRunnerHandle::Get();
-    observers_[observer] = task_runner;
-
-    // If this is called while a notification is being dispatched on this thread
-    // and |policy_| is ALL, |observer| must be notified (if a notification is
-    // being dispatched on another thread in parallel, the notification may or
-    // may not make it to |observer| depending on the outcome of the race to
-    // |lock_|).
-    if (policy_ == ObserverListPolicy::ALL) {
-      const NotificationDataBase* current_notification =
-          tls_current_notification_.Get().Get();
-      if (current_notification && current_notification->observer_list == this) {
-        task_runner->PostTask(
-            current_notification->from_here,
-            BindOnce(
-                &ObserverListThreadSafe<ObserverType>::NotifyWrapper, this,
-                observer,
-                *static_cast<const NotificationData*>(current_notification)));
-      }
-    }
-  }
-
-  // Remove an observer from the list if it is in the list.
-  //
-  // If a notification was sent to the observer but hasn't started to run yet,
-  // it will be aborted. If a notification has started to run, removing the
-  // observer won't stop it.
-  void RemoveObserver(ObserverType* observer) {
-    AutoLock auto_lock(lock_);
-    observers_.erase(observer);
-  }
-
-  // Verifies that the list is currently empty (i.e. there are no observers).
-  void AssertEmpty() const {
-#if DCHECK_IS_ON()
-    AutoLock auto_lock(lock_);
-    DCHECK(observers_.empty());
-#endif
-  }
-
-  // Asynchronously invokes a callback on all observers, on their registration
-  // sequence. You cannot assume that at the completion of the Notify call that
-  // all Observers have been Notified. The notification may still be pending
-  // delivery.
-  template <typename Method, typename... Params>
-  void Notify(const Location& from_here, Method m, Params&&... params) {
-    Callback<void(ObserverType*)> method =
-        Bind(&Dispatcher<ObserverType, Method>::Run, m,
-             std::forward<Params>(params)...);
-
-    AutoLock lock(lock_);
-    for (const auto& observer : observers_) {
-      observer.second->PostTask(
-          from_here,
-          BindOnce(&ObserverListThreadSafe<ObserverType>::NotifyWrapper, this,
-                   observer.first, NotificationData(this, from_here, method)));
-    }
-  }
-
- private:
-  friend class RefCountedThreadSafe<ObserverListThreadSafeBase>;
-
-  struct NotificationData : public NotificationDataBase {
-    NotificationData(ObserverListThreadSafe* observer_list_in,
-                     const Location& from_here_in,
-                     const Callback<void(ObserverType*)>& method_in)
-        : NotificationDataBase(observer_list_in, from_here_in),
-          method(method_in) {}
-
-    Callback<void(ObserverType*)> method;
-  };
-
-  ~ObserverListThreadSafe() override = default;
-
-  void NotifyWrapper(ObserverType* observer,
-                     const NotificationData& notification) {
-    {
-      AutoLock auto_lock(lock_);
-
-      // Check whether the observer still needs a notification.
-      auto it = observers_.find(observer);
-      if (it == observers_.end())
-        return;
-      DCHECK(it->second->RunsTasksInCurrentSequence());
-    }
-
-    // Keep track of the notification being dispatched on the current thread.
-    // This will be used if the callback below calls AddObserver().
-    //
-    // Note: |tls_current_notification_| may not be nullptr if this runs in a
-    // nested loop started by a notification callback. In that case, it is
-    // important to save the previous value to restore it later.
-    auto& tls_current_notification = tls_current_notification_.Get();
-    const NotificationDataBase* const previous_notification =
-        tls_current_notification.Get();
-    tls_current_notification.Set(&notification);
-
-    // Invoke the callback.
-    notification.method.Run(observer);
-
-    // Reset the notification being dispatched on the current thread to its
-    // previous value.
-    tls_current_notification.Set(previous_notification);
-  }
-
-  const ObserverListPolicy policy_ = ObserverListPolicy::ALL;
-
-  // Synchronizes access to |observers_|.
-  mutable Lock lock_;
-
-  // Keys are observers. Values are the SequencedTaskRunners on which they must
-  // be notified.
-  std::unordered_map<ObserverType*, scoped_refptr<SequencedTaskRunner>>
-      observers_;
-
-  DISALLOW_COPY_AND_ASSIGN(ObserverListThreadSafe);
-};
-
-}  // namespace base
-
-#endif  // BASE_OBSERVER_LIST_THREADSAFE_H_
diff --git a/native/zucchini/vendor/libchrome/base/optional.h b/native/zucchini/vendor/libchrome/base/optional.h
deleted file mode 100644
index f6263b8..0000000
--- a/native/zucchini/vendor/libchrome/base/optional.h
+++ /dev/null
@@ -1,922 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_OPTIONAL_H_
-#define BASE_OPTIONAL_H_
-
-#include <type_traits>
-#include <utility>
-
-#include "base/logging.h"
-#include "base/template_util.h"
-
-namespace base {
-
-// Specification:
-// http://en.cppreference.com/w/cpp/utility/optional/in_place_t
-struct in_place_t {};
-
-// Specification:
-// http://en.cppreference.com/w/cpp/utility/optional/nullopt_t
-struct nullopt_t {
-  constexpr explicit nullopt_t(int) {}
-};
-
-// Specification:
-// http://en.cppreference.com/w/cpp/utility/optional/in_place
-constexpr in_place_t in_place = {};
-
-// Specification:
-// http://en.cppreference.com/w/cpp/utility/optional/nullopt
-constexpr nullopt_t nullopt(0);
-
-// Forward declaration, which is refered by following helpers.
-template <typename T>
-class Optional;
-
-namespace internal {
-
-template <typename T, bool = std::is_trivially_destructible<T>::value>
-struct OptionalStorageBase {
-  // Initializing |empty_| here instead of using default member initializing
-  // to avoid errors in g++ 4.8.
-  constexpr OptionalStorageBase() : empty_('\0') {}
-
-  template <class... Args>
-  constexpr explicit OptionalStorageBase(in_place_t, Args&&... args)
-      : is_populated_(true), value_(std::forward<Args>(args)...) {}
-
-  // When T is not trivially destructible we must call its
-  // destructor before deallocating its memory.
-  // Note that this hides the (implicitly declared) move constructor, which
-  // would be used for constexpr move constructor in OptionalStorage<T>.
-  // It is needed iff T is trivially move constructible. However, the current
-  // is_trivially_{copy,move}_constructible implementation requires
-  // is_trivially_destructible (which looks a bug, cf:
-  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452 and
-  // http://cplusplus.github.io/LWG/lwg-active.html#2116), so it is not
-  // necessary for this case at the moment. Please see also the destructor
-  // comment in "is_trivially_destructible = true" specialization below.
-  ~OptionalStorageBase() {
-    if (is_populated_)
-      value_.~T();
-  }
-
-  template <class... Args>
-  void Init(Args&&... args) {
-    DCHECK(!is_populated_);
-    ::new (&value_) T(std::forward<Args>(args)...);
-    is_populated_ = true;
-  }
-
-  bool is_populated_ = false;
-  union {
-    // |empty_| exists so that the union will always be initialized, even when
-    // it doesn't contain a value. Union members must be initialized for the
-    // constructor to be 'constexpr'.
-    char empty_;
-    T value_;
-  };
-};
-
-template <typename T>
-struct OptionalStorageBase<T, true /* trivially destructible */> {
-  // Initializing |empty_| here instead of using default member initializing
-  // to avoid errors in g++ 4.8.
-  constexpr OptionalStorageBase() : empty_('\0') {}
-
-  template <class... Args>
-  constexpr explicit OptionalStorageBase(in_place_t, Args&&... args)
-      : is_populated_(true), value_(std::forward<Args>(args)...) {}
-
-  // When T is trivially destructible (i.e. its destructor does nothing) there
-  // is no need to call it. Implicitly defined destructor is trivial, because
-  // both members (bool and union containing only variants which are trivially
-  // destructible) are trivially destructible.
-  // Explicitly-defaulted destructor is also trivial, but do not use it here,
-  // because it hides the implicit move constructor. It is needed to implement
-  // constexpr move constructor in OptionalStorage iff T is trivially move
-  // constructible. Note that, if T is trivially move constructible, the move
-  // constructor of OptionalStorageBase<T> is also implicitly defined and it is
-  // trivially move constructor. If T is not trivially move constructible,
-  // "not declaring move constructor without destructor declaration" here means
-  // "delete move constructor", which works because any move constructor of
-  // OptionalStorage will not refer to it in that case.
-
-  template <class... Args>
-  void Init(Args&&... args) {
-    DCHECK(!is_populated_);
-    ::new (&value_) T(std::forward<Args>(args)...);
-    is_populated_ = true;
-  }
-
-  bool is_populated_ = false;
-  union {
-    // |empty_| exists so that the union will always be initialized, even when
-    // it doesn't contain a value. Union members must be initialized for the
-    // constructor to be 'constexpr'.
-    char empty_;
-    T value_;
-  };
-};
-
-// Implement conditional constexpr copy and move constructors. These are
-// constexpr if is_trivially_{copy,move}_constructible<T>::value is true
-// respectively. If each is true, the corresponding constructor is defined as
-// "= default;", which generates a constexpr constructor (In this case,
-// the condition of constexpr-ness is satisfied because the base class also has
-// compiler generated constexpr {copy,move} constructors). Note that
-// placement-new is prohibited in constexpr.
-template <typename T,
-          bool = is_trivially_copy_constructible<T>::value,
-          bool = std::is_trivially_move_constructible<T>::value>
-struct OptionalStorage : OptionalStorageBase<T> {
-  // This is no trivially {copy,move} constructible case. Other cases are
-  // defined below as specializations.
-
-  // Accessing the members of template base class requires explicit
-  // declaration.
-  using OptionalStorageBase<T>::is_populated_;
-  using OptionalStorageBase<T>::value_;
-  using OptionalStorageBase<T>::Init;
-
-  // Inherit constructors (specifically, the in_place constructor).
-  using OptionalStorageBase<T>::OptionalStorageBase;
-
-  // User defined constructor deletes the default constructor.
-  // Define it explicitly.
-  OptionalStorage() = default;
-
-  OptionalStorage(const OptionalStorage& other) {
-    if (other.is_populated_)
-      Init(other.value_);
-  }
-
-  OptionalStorage(OptionalStorage&& other) noexcept(
-      std::is_nothrow_move_constructible<T>::value) {
-    if (other.is_populated_)
-      Init(std::move(other.value_));
-  }
-};
-
-template <typename T>
-struct OptionalStorage<T,
-                       true /* trivially copy constructible */,
-                       false /* trivially move constructible */>
-    : OptionalStorageBase<T> {
-  using OptionalStorageBase<T>::is_populated_;
-  using OptionalStorageBase<T>::value_;
-  using OptionalStorageBase<T>::Init;
-  using OptionalStorageBase<T>::OptionalStorageBase;
-
-  OptionalStorage() = default;
-  OptionalStorage(const OptionalStorage& other) = default;
-
-  OptionalStorage(OptionalStorage&& other) noexcept(
-      std::is_nothrow_move_constructible<T>::value) {
-    if (other.is_populated_)
-      Init(std::move(other.value_));
-  }
-};
-
-template <typename T>
-struct OptionalStorage<T,
-                       false /* trivially copy constructible */,
-                       true /* trivially move constructible */>
-    : OptionalStorageBase<T> {
-  using OptionalStorageBase<T>::is_populated_;
-  using OptionalStorageBase<T>::value_;
-  using OptionalStorageBase<T>::Init;
-  using OptionalStorageBase<T>::OptionalStorageBase;
-
-  OptionalStorage() = default;
-  OptionalStorage(OptionalStorage&& other) = default;
-
-  OptionalStorage(const OptionalStorage& other) {
-    if (other.is_populated_)
-      Init(other.value_);
-  }
-};
-
-template <typename T>
-struct OptionalStorage<T,
-                       true /* trivially copy constructible */,
-                       true /* trivially move constructible */>
-    : OptionalStorageBase<T> {
-  // If both trivially {copy,move} constructible are true, it is not necessary
-  // to use user-defined constructors. So, just inheriting constructors
-  // from the base class works.
-  using OptionalStorageBase<T>::OptionalStorageBase;
-};
-
-// Base class to support conditionally usable copy-/move- constructors
-// and assign operators.
-template <typename T>
-class OptionalBase {
-  // This class provides implementation rather than public API, so everything
-  // should be hidden. Often we use composition, but we cannot in this case
-  // because of C++ language restriction.
- protected:
-  constexpr OptionalBase() = default;
-  constexpr OptionalBase(const OptionalBase& other) = default;
-  constexpr OptionalBase(OptionalBase&& other) = default;
-
-  template <class... Args>
-  constexpr explicit OptionalBase(in_place_t, Args&&... args)
-      : storage_(in_place, std::forward<Args>(args)...) {}
-
-  // Implementation of converting constructors.
-  template <typename U>
-  explicit OptionalBase(const OptionalBase<U>& other) {
-    if (other.storage_.is_populated_)
-      storage_.Init(other.storage_.value_);
-  }
-
-  template <typename U>
-  explicit OptionalBase(OptionalBase<U>&& other) {
-    if (other.storage_.is_populated_)
-      storage_.Init(std::move(other.storage_.value_));
-  }
-
-  ~OptionalBase() = default;
-
-  OptionalBase& operator=(const OptionalBase& other) {
-    CopyAssign(other);
-    return *this;
-  }
-
-  OptionalBase& operator=(OptionalBase&& other) noexcept(
-      std::is_nothrow_move_assignable<T>::value&&
-          std::is_nothrow_move_constructible<T>::value) {
-    MoveAssign(std::move(other));
-    return *this;
-  }
-
-  template <typename U>
-  void CopyAssign(const OptionalBase<U>& other) {
-    if (other.storage_.is_populated_)
-      InitOrAssign(other.storage_.value_);
-    else
-      FreeIfNeeded();
-  }
-
-  template <typename U>
-  void MoveAssign(OptionalBase<U>&& other) {
-    if (other.storage_.is_populated_)
-      InitOrAssign(std::move(other.storage_.value_));
-    else
-      FreeIfNeeded();
-  }
-
-  template <typename U>
-  void InitOrAssign(U&& value) {
-    if (storage_.is_populated_)
-      storage_.value_ = std::forward<U>(value);
-    else
-      storage_.Init(std::forward<U>(value));
-  }
-
-  void FreeIfNeeded() {
-    if (!storage_.is_populated_)
-      return;
-    storage_.value_.~T();
-    storage_.is_populated_ = false;
-  }
-
-  // For implementing conversion, allow access to other typed OptionalBase
-  // class.
-  template <typename U>
-  friend class OptionalBase;
-
-  OptionalStorage<T> storage_;
-};
-
-// The following {Copy,Move}{Constructible,Assignable} structs are helpers to
-// implement constructor/assign-operator overloading. Specifically, if T is
-// is not movable but copyable, Optional<T>'s move constructor should not
-// participate in overload resolution. This inheritance trick implements that.
-template <bool is_copy_constructible>
-struct CopyConstructible {};
-
-template <>
-struct CopyConstructible<false> {
-  constexpr CopyConstructible() = default;
-  constexpr CopyConstructible(const CopyConstructible&) = delete;
-  constexpr CopyConstructible(CopyConstructible&&) = default;
-  CopyConstructible& operator=(const CopyConstructible&) = default;
-  CopyConstructible& operator=(CopyConstructible&&) = default;
-};
-
-template <bool is_move_constructible>
-struct MoveConstructible {};
-
-template <>
-struct MoveConstructible<false> {
-  constexpr MoveConstructible() = default;
-  constexpr MoveConstructible(const MoveConstructible&) = default;
-  constexpr MoveConstructible(MoveConstructible&&) = delete;
-  MoveConstructible& operator=(const MoveConstructible&) = default;
-  MoveConstructible& operator=(MoveConstructible&&) = default;
-};
-
-template <bool is_copy_assignable>
-struct CopyAssignable {};
-
-template <>
-struct CopyAssignable<false> {
-  constexpr CopyAssignable() = default;
-  constexpr CopyAssignable(const CopyAssignable&) = default;
-  constexpr CopyAssignable(CopyAssignable&&) = default;
-  CopyAssignable& operator=(const CopyAssignable&) = delete;
-  CopyAssignable& operator=(CopyAssignable&&) = default;
-};
-
-template <bool is_move_assignable>
-struct MoveAssignable {};
-
-template <>
-struct MoveAssignable<false> {
-  constexpr MoveAssignable() = default;
-  constexpr MoveAssignable(const MoveAssignable&) = default;
-  constexpr MoveAssignable(MoveAssignable&&) = default;
-  MoveAssignable& operator=(const MoveAssignable&) = default;
-  MoveAssignable& operator=(MoveAssignable&&) = delete;
-};
-
-// Helper to conditionally enable converting constructors and assign operators.
-template <typename T, typename U>
-struct IsConvertibleFromOptional
-    : std::integral_constant<
-          bool,
-          std::is_constructible<T, Optional<U>&>::value ||
-              std::is_constructible<T, const Optional<U>&>::value ||
-              std::is_constructible<T, Optional<U>&&>::value ||
-              std::is_constructible<T, const Optional<U>&&>::value ||
-              std::is_convertible<Optional<U>&, T>::value ||
-              std::is_convertible<const Optional<U>&, T>::value ||
-              std::is_convertible<Optional<U>&&, T>::value ||
-              std::is_convertible<const Optional<U>&&, T>::value> {};
-
-template <typename T, typename U>
-struct IsAssignableFromOptional
-    : std::integral_constant<
-          bool,
-          IsConvertibleFromOptional<T, U>::value ||
-              std::is_assignable<T&, Optional<U>&>::value ||
-              std::is_assignable<T&, const Optional<U>&>::value ||
-              std::is_assignable<T&, Optional<U>&&>::value ||
-              std::is_assignable<T&, const Optional<U>&&>::value> {};
-
-// Forward compatibility for C++17.
-// Introduce one more deeper nested namespace to avoid leaking using std::swap.
-namespace swappable_impl {
-using std::swap;
-
-struct IsSwappableImpl {
-  // Tests if swap can be called. Check<T&>(0) returns true_type iff swap
-  // is available for T. Otherwise, Check's overload resolution falls back
-  // to Check(...) declared below thanks to SFINAE, so returns false_type.
-  template <typename T>
-  static auto Check(int)
-      -> decltype(swap(std::declval<T>(), std::declval<T>()), std::true_type());
-
-  template <typename T>
-  static std::false_type Check(...);
-};
-}  // namespace swappable_impl
-
-template <typename T>
-struct IsSwappable : decltype(swappable_impl::IsSwappableImpl::Check<T&>(0)) {};
-
-// Forward compatibility for C++20.
-template <typename T>
-using RemoveCvRefT = std::remove_cv_t<std::remove_reference_t<T>>;
-
-}  // namespace internal
-
-// On Windows, by default, empty-base class optimization does not work,
-// which means even if the base class is empty struct, it still consumes one
-// byte for its body. __declspec(empty_bases) enables the optimization.
-// cf)
-// https://blogs.msdn.microsoft.com/vcblog/2016/03/30/optimizing-the-layout-of-empty-base-classes-in-vs2015-update-2-3/
-#ifdef OS_WIN
-#define OPTIONAL_DECLSPEC_EMPTY_BASES __declspec(empty_bases)
-#else
-#define OPTIONAL_DECLSPEC_EMPTY_BASES
-#endif
-
-// base::Optional is a Chromium version of the C++17 optional class:
-// std::optional documentation:
-// http://en.cppreference.com/w/cpp/utility/optional
-// Chromium documentation:
-// https://chromium.googlesource.com/chromium/src/+/master/docs/optional.md
-//
-// These are the differences between the specification and the implementation:
-// - Constructors do not use 'constexpr' as it is a C++14 extension.
-// - 'constexpr' might be missing in some places for reasons specified locally.
-// - No exceptions are thrown, because they are banned from Chromium.
-//   Marked noexcept for only move constructor and move assign operators.
-// - All the non-members are in the 'base' namespace instead of 'std'.
-//
-// Note that T cannot have a constructor T(Optional<T>) etc. Optional<T> checks
-// T's constructor (specifically via IsConvertibleFromOptional), and in the
-// check whether T can be constructible from Optional<T>, which is recursive
-// so it does not work. As of Feb 2018, std::optional C++17 implementation in
-// both clang and gcc has same limitation. MSVC SFINAE looks to have different
-// behavior, but anyway it reports an error, too.
-template <typename T>
-class OPTIONAL_DECLSPEC_EMPTY_BASES Optional
-    : public internal::OptionalBase<T>,
-      public internal::CopyConstructible<std::is_copy_constructible<T>::value>,
-      public internal::MoveConstructible<std::is_move_constructible<T>::value>,
-      public internal::CopyAssignable<std::is_copy_constructible<T>::value &&
-                                      std::is_copy_assignable<T>::value>,
-      public internal::MoveAssignable<std::is_move_constructible<T>::value &&
-                                      std::is_move_assignable<T>::value> {
- public:
-#undef OPTIONAL_DECLSPEC_EMPTY_BASES
-  using value_type = T;
-
-  // Defer default/copy/move constructor implementation to OptionalBase.
-  constexpr Optional() = default;
-  constexpr Optional(const Optional& other) = default;
-  constexpr Optional(Optional&& other) noexcept(
-      std::is_nothrow_move_constructible<T>::value) = default;
-
-  constexpr Optional(nullopt_t) {}  // NOLINT(runtime/explicit)
-
-  // Converting copy constructor. "explicit" only if
-  // std::is_convertible<const U&, T>::value is false. It is implemented by
-  // declaring two almost same constructors, but that condition in enable_if_t
-  // is different, so that either one is chosen, thanks to SFINAE.
-  template <
-      typename U,
-      std::enable_if_t<std::is_constructible<T, const U&>::value &&
-                           !internal::IsConvertibleFromOptional<T, U>::value &&
-                           std::is_convertible<const U&, T>::value,
-                       bool> = false>
-  Optional(const Optional<U>& other) : internal::OptionalBase<T>(other) {}
-
-  template <
-      typename U,
-      std::enable_if_t<std::is_constructible<T, const U&>::value &&
-                           !internal::IsConvertibleFromOptional<T, U>::value &&
-                           !std::is_convertible<const U&, T>::value,
-                       bool> = false>
-  explicit Optional(const Optional<U>& other)
-      : internal::OptionalBase<T>(other) {}
-
-  // Converting move constructor. Similar to converting copy constructor,
-  // declaring two (explicit and non-explicit) constructors.
-  template <
-      typename U,
-      std::enable_if_t<std::is_constructible<T, U&&>::value &&
-                           !internal::IsConvertibleFromOptional<T, U>::value &&
-                           std::is_convertible<U&&, T>::value,
-                       bool> = false>
-  Optional(Optional<U>&& other) : internal::OptionalBase<T>(std::move(other)) {}
-
-  template <
-      typename U,
-      std::enable_if_t<std::is_constructible<T, U&&>::value &&
-                           !internal::IsConvertibleFromOptional<T, U>::value &&
-                           !std::is_convertible<U&&, T>::value,
-                       bool> = false>
-  explicit Optional(Optional<U>&& other)
-      : internal::OptionalBase<T>(std::move(other)) {}
-
-  template <class... Args>
-  constexpr explicit Optional(in_place_t, Args&&... args)
-      : internal::OptionalBase<T>(in_place, std::forward<Args>(args)...) {}
-
-  template <
-      class U,
-      class... Args,
-      class = std::enable_if_t<std::is_constructible<value_type,
-                                                     std::initializer_list<U>&,
-                                                     Args...>::value>>
-  constexpr explicit Optional(in_place_t,
-                              std::initializer_list<U> il,
-                              Args&&... args)
-      : internal::OptionalBase<T>(in_place, il, std::forward<Args>(args)...) {}
-
-  // Forward value constructor. Similar to converting constructors,
-  // conditionally explicit.
-  template <
-      typename U = value_type,
-      std::enable_if_t<
-          std::is_constructible<T, U&&>::value &&
-              !std::is_same<internal::RemoveCvRefT<U>, in_place_t>::value &&
-              !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value &&
-              std::is_convertible<U&&, T>::value,
-          bool> = false>
-  constexpr Optional(U&& value)
-      : internal::OptionalBase<T>(in_place, std::forward<U>(value)) {}
-
-  template <
-      typename U = value_type,
-      std::enable_if_t<
-          std::is_constructible<T, U&&>::value &&
-              !std::is_same<internal::RemoveCvRefT<U>, in_place_t>::value &&
-              !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value &&
-              !std::is_convertible<U&&, T>::value,
-          bool> = false>
-  constexpr explicit Optional(U&& value)
-      : internal::OptionalBase<T>(in_place, std::forward<U>(value)) {}
-
-  ~Optional() = default;
-
-  // Defer copy-/move- assign operator implementation to OptionalBase.
-  Optional& operator=(const Optional& other) = default;
-  Optional& operator=(Optional&& other) noexcept(
-      std::is_nothrow_move_assignable<T>::value&&
-          std::is_nothrow_move_constructible<T>::value) = default;
-
-  Optional& operator=(nullopt_t) {
-    FreeIfNeeded();
-    return *this;
-  }
-
-  // Perfect-forwarded assignment.
-  template <typename U>
-  std::enable_if_t<
-      !std::is_same<internal::RemoveCvRefT<U>, Optional<T>>::value &&
-          std::is_constructible<T, U>::value &&
-          std::is_assignable<T&, U>::value &&
-          (!std::is_scalar<T>::value ||
-           !std::is_same<std::decay_t<U>, T>::value),
-      Optional&>
-  operator=(U&& value) {
-    InitOrAssign(std::forward<U>(value));
-    return *this;
-  }
-
-  // Copy assign the state of other.
-  template <typename U>
-  std::enable_if_t<!internal::IsAssignableFromOptional<T, U>::value &&
-                       std::is_constructible<T, const U&>::value &&
-                       std::is_assignable<T&, const U&>::value,
-                   Optional&>
-  operator=(const Optional<U>& other) {
-    CopyAssign(other);
-    return *this;
-  }
-
-  // Move assign the state of other.
-  template <typename U>
-  std::enable_if_t<!internal::IsAssignableFromOptional<T, U>::value &&
-                       std::is_constructible<T, U>::value &&
-                       std::is_assignable<T&, U>::value,
-                   Optional&>
-  operator=(Optional<U>&& other) {
-    MoveAssign(std::move(other));
-    return *this;
-  }
-
-  constexpr const T* operator->() const {
-    DCHECK(storage_.is_populated_);
-    return &storage_.value_;
-  }
-
-  constexpr T* operator->() {
-    DCHECK(storage_.is_populated_);
-    return &storage_.value_;
-  }
-
-  constexpr const T& operator*() const & {
-    DCHECK(storage_.is_populated_);
-    return storage_.value_;
-  }
-
-  constexpr T& operator*() & {
-    DCHECK(storage_.is_populated_);
-    return storage_.value_;
-  }
-
-  constexpr const T&& operator*() const && {
-    DCHECK(storage_.is_populated_);
-    return std::move(storage_.value_);
-  }
-
-  constexpr T&& operator*() && {
-    DCHECK(storage_.is_populated_);
-    return std::move(storage_.value_);
-  }
-
-  constexpr explicit operator bool() const { return storage_.is_populated_; }
-
-  constexpr bool has_value() const { return storage_.is_populated_; }
-
-  constexpr T& value() & {
-    CHECK(storage_.is_populated_);
-    return storage_.value_;
-  }
-
-  constexpr const T& value() const & {
-    CHECK(storage_.is_populated_);
-    return storage_.value_;
-  }
-
-  constexpr T&& value() && {
-    CHECK(storage_.is_populated_);
-    return std::move(storage_.value_);
-  }
-
-  constexpr const T&& value() const && {
-    CHECK(storage_.is_populated_);
-    return std::move(storage_.value_);
-  }
-
-  template <class U>
-  constexpr T value_or(U&& default_value) const& {
-    // TODO(mlamouri): add the following assert when possible:
-    // static_assert(std::is_copy_constructible<T>::value,
-    //               "T must be copy constructible");
-    static_assert(std::is_convertible<U, T>::value,
-                  "U must be convertible to T");
-    return storage_.is_populated_
-               ? storage_.value_
-               : static_cast<T>(std::forward<U>(default_value));
-  }
-
-  template <class U>
-  constexpr T value_or(U&& default_value) && {
-    // TODO(mlamouri): add the following assert when possible:
-    // static_assert(std::is_move_constructible<T>::value,
-    //               "T must be move constructible");
-    static_assert(std::is_convertible<U, T>::value,
-                  "U must be convertible to T");
-    return storage_.is_populated_
-               ? std::move(storage_.value_)
-               : static_cast<T>(std::forward<U>(default_value));
-  }
-
-  void swap(Optional& other) {
-    if (!storage_.is_populated_ && !other.storage_.is_populated_)
-      return;
-
-    if (storage_.is_populated_ != other.storage_.is_populated_) {
-      if (storage_.is_populated_) {
-        other.storage_.Init(std::move(storage_.value_));
-        FreeIfNeeded();
-      } else {
-        storage_.Init(std::move(other.storage_.value_));
-        other.FreeIfNeeded();
-      }
-      return;
-    }
-
-    DCHECK(storage_.is_populated_ && other.storage_.is_populated_);
-    using std::swap;
-    swap(**this, *other);
-  }
-
-  void reset() { FreeIfNeeded(); }
-
-  template <class... Args>
-  T& emplace(Args&&... args) {
-    FreeIfNeeded();
-    storage_.Init(std::forward<Args>(args)...);
-    return storage_.value_;
-  }
-
-  template <class U, class... Args>
-  std::enable_if_t<
-      std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value,
-      T&>
-  emplace(std::initializer_list<U> il, Args&&... args) {
-    FreeIfNeeded();
-    storage_.Init(il, std::forward<Args>(args)...);
-    return storage_.value_;
-  }
-
- private:
-  // Accessing template base class's protected member needs explicit
-  // declaration to do so.
-  using internal::OptionalBase<T>::CopyAssign;
-  using internal::OptionalBase<T>::FreeIfNeeded;
-  using internal::OptionalBase<T>::InitOrAssign;
-  using internal::OptionalBase<T>::MoveAssign;
-  using internal::OptionalBase<T>::storage_;
-};
-
-// Here after defines comparation operators. The definition follows
-// http://en.cppreference.com/w/cpp/utility/optional/operator_cmp
-// while bool() casting is replaced by has_value() to meet the chromium
-// style guide.
-template <class T, class U>
-constexpr bool operator==(const Optional<T>& lhs, const Optional<U>& rhs) {
-  if (lhs.has_value() != rhs.has_value())
-    return false;
-  if (!lhs.has_value())
-    return true;
-  return *lhs == *rhs;
-}
-
-template <class T, class U>
-constexpr bool operator!=(const Optional<T>& lhs, const Optional<U>& rhs) {
-  if (lhs.has_value() != rhs.has_value())
-    return true;
-  if (!lhs.has_value())
-    return false;
-  return *lhs != *rhs;
-}
-
-template <class T, class U>
-constexpr bool operator<(const Optional<T>& lhs, const Optional<U>& rhs) {
-  if (!rhs.has_value())
-    return false;
-  if (!lhs.has_value())
-    return true;
-  return *lhs < *rhs;
-}
-
-template <class T, class U>
-constexpr bool operator<=(const Optional<T>& lhs, const Optional<U>& rhs) {
-  if (!lhs.has_value())
-    return true;
-  if (!rhs.has_value())
-    return false;
-  return *lhs <= *rhs;
-}
-
-template <class T, class U>
-constexpr bool operator>(const Optional<T>& lhs, const Optional<U>& rhs) {
-  if (!lhs.has_value())
-    return false;
-  if (!rhs.has_value())
-    return true;
-  return *lhs > *rhs;
-}
-
-template <class T, class U>
-constexpr bool operator>=(const Optional<T>& lhs, const Optional<U>& rhs) {
-  if (!rhs.has_value())
-    return true;
-  if (!lhs.has_value())
-    return false;
-  return *lhs >= *rhs;
-}
-
-template <class T>
-constexpr bool operator==(const Optional<T>& opt, nullopt_t) {
-  return !opt;
-}
-
-template <class T>
-constexpr bool operator==(nullopt_t, const Optional<T>& opt) {
-  return !opt;
-}
-
-template <class T>
-constexpr bool operator!=(const Optional<T>& opt, nullopt_t) {
-  return opt.has_value();
-}
-
-template <class T>
-constexpr bool operator!=(nullopt_t, const Optional<T>& opt) {
-  return opt.has_value();
-}
-
-template <class T>
-constexpr bool operator<(const Optional<T>& opt, nullopt_t) {
-  return false;
-}
-
-template <class T>
-constexpr bool operator<(nullopt_t, const Optional<T>& opt) {
-  return opt.has_value();
-}
-
-template <class T>
-constexpr bool operator<=(const Optional<T>& opt, nullopt_t) {
-  return !opt;
-}
-
-template <class T>
-constexpr bool operator<=(nullopt_t, const Optional<T>& opt) {
-  return true;
-}
-
-template <class T>
-constexpr bool operator>(const Optional<T>& opt, nullopt_t) {
-  return opt.has_value();
-}
-
-template <class T>
-constexpr bool operator>(nullopt_t, const Optional<T>& opt) {
-  return false;
-}
-
-template <class T>
-constexpr bool operator>=(const Optional<T>& opt, nullopt_t) {
-  return true;
-}
-
-template <class T>
-constexpr bool operator>=(nullopt_t, const Optional<T>& opt) {
-  return !opt;
-}
-
-template <class T, class U>
-constexpr bool operator==(const Optional<T>& opt, const U& value) {
-  return opt.has_value() ? *opt == value : false;
-}
-
-template <class T, class U>
-constexpr bool operator==(const U& value, const Optional<T>& opt) {
-  return opt.has_value() ? value == *opt : false;
-}
-
-template <class T, class U>
-constexpr bool operator!=(const Optional<T>& opt, const U& value) {
-  return opt.has_value() ? *opt != value : true;
-}
-
-template <class T, class U>
-constexpr bool operator!=(const U& value, const Optional<T>& opt) {
-  return opt.has_value() ? value != *opt : true;
-}
-
-template <class T, class U>
-constexpr bool operator<(const Optional<T>& opt, const U& value) {
-  return opt.has_value() ? *opt < value : true;
-}
-
-template <class T, class U>
-constexpr bool operator<(const U& value, const Optional<T>& opt) {
-  return opt.has_value() ? value < *opt : false;
-}
-
-template <class T, class U>
-constexpr bool operator<=(const Optional<T>& opt, const U& value) {
-  return opt.has_value() ? *opt <= value : true;
-}
-
-template <class T, class U>
-constexpr bool operator<=(const U& value, const Optional<T>& opt) {
-  return opt.has_value() ? value <= *opt : false;
-}
-
-template <class T, class U>
-constexpr bool operator>(const Optional<T>& opt, const U& value) {
-  return opt.has_value() ? *opt > value : false;
-}
-
-template <class T, class U>
-constexpr bool operator>(const U& value, const Optional<T>& opt) {
-  return opt.has_value() ? value > *opt : true;
-}
-
-template <class T, class U>
-constexpr bool operator>=(const Optional<T>& opt, const U& value) {
-  return opt.has_value() ? *opt >= value : false;
-}
-
-template <class T, class U>
-constexpr bool operator>=(const U& value, const Optional<T>& opt) {
-  return opt.has_value() ? value >= *opt : true;
-}
-
-template <class T>
-constexpr Optional<std::decay_t<T>> make_optional(T&& value) {
-  return Optional<std::decay_t<T>>(std::forward<T>(value));
-}
-
-template <class T, class... Args>
-constexpr Optional<T> make_optional(Args&&... args) {
-  return Optional<T>(in_place, std::forward<Args>(args)...);
-}
-
-template <class T, class U, class... Args>
-constexpr Optional<T> make_optional(std::initializer_list<U> il,
-                                    Args&&... args) {
-  return Optional<T>(in_place, il, std::forward<Args>(args)...);
-}
-
-// Partial specialization for a function template is not allowed. Also, it is
-// not allowed to add overload function to std namespace, while it is allowed
-// to specialize the template in std. Thus, swap() (kind of) overloading is
-// defined in base namespace, instead.
-template <class T>
-std::enable_if_t<std::is_move_constructible<T>::value &&
-                 internal::IsSwappable<T>::value>
-swap(Optional<T>& lhs, Optional<T>& rhs) {
-  lhs.swap(rhs);
-}
-
-}  // namespace base
-
-namespace std {
-
-template <class T>
-struct hash<base::Optional<T>> {
-  size_t operator()(const base::Optional<T>& opt) const {
-    return opt == base::nullopt ? 0 : std::hash<T>()(*opt);
-  }
-};
-
-}  // namespace std
-
-#endif  // BASE_OPTIONAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/pending_task.h b/native/zucchini/vendor/libchrome/base/pending_task.h
deleted file mode 100644
index b71a371..0000000
--- a/native/zucchini/vendor/libchrome/base/pending_task.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_PENDING_TASK_H_
-#define BASE_PENDING_TASK_H_
-
-#include <array>
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/containers/queue.h"
-#include "base/location.h"
-#include "base/time/time.h"
-
-namespace base {
-
-enum class Nestable {
-  kNonNestable,
-  kNestable,
-};
-
-// Contains data about a pending task. Stored in TaskQueue and DelayedTaskQueue
-// for use by classes that queue and execute tasks.
-struct BASE_EXPORT PendingTask {
-  PendingTask(const Location& posted_from,
-              OnceClosure task,
-              TimeTicks delayed_run_time = TimeTicks(),
-              Nestable nestable = Nestable::kNestable);
-  PendingTask(PendingTask&& other);
-  ~PendingTask();
-
-  PendingTask& operator=(PendingTask&& other);
-
-  // Used to support sorting.
-  bool operator<(const PendingTask& other) const;
-
-  // The task to run.
-  OnceClosure task;
-
-  // The site this PendingTask was posted from.
-  Location posted_from;
-
-  // The time when the task should be run.
-  base::TimeTicks delayed_run_time;
-
-  // Chain of up-to-four symbols of the parent tasks which led to this one being
-  // posted.
-  std::array<const void*, 4> task_backtrace = {};
-
-  // Secondary sort key for run time.
-  int sequence_num = 0;
-
-  // OK to dispatch from a nested loop.
-  Nestable nestable;
-
-  // Needs high resolution timers.
-  bool is_high_res = false;
-};
-
-using TaskQueue = base::queue<PendingTask>;
-
-// PendingTasks are sorted by their |delayed_run_time| property.
-using DelayedTaskQueue = std::priority_queue<base::PendingTask>;
-
-}  // namespace base
-
-#endif  // BASE_PENDING_TASK_H_
diff --git a/native/zucchini/vendor/libchrome/base/pickle.h b/native/zucchini/vendor/libchrome/base/pickle.h
deleted file mode 100644
index eff2092..0000000
--- a/native/zucchini/vendor/libchrome/base/pickle.h
+++ /dev/null
@@ -1,345 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_PICKLE_H_
-#define BASE_PICKLE_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <string>
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "base/gtest_prod_util.h"
-#include "base/logging.h"
-#include "base/memory/ref_counted.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-
-#if defined(OS_POSIX)
-#include "base/files/file.h"
-#endif
-
-namespace base {
-
-class Pickle;
-
-// PickleIterator reads data from a Pickle. The Pickle object must remain valid
-// while the PickleIterator object is in use.
-class BASE_EXPORT PickleIterator {
- public:
-  PickleIterator() : payload_(NULL), read_index_(0), end_index_(0) {}
-  explicit PickleIterator(const Pickle& pickle);
-
-  // Methods for reading the payload of the Pickle. To read from the start of
-  // the Pickle, create a PickleIterator from a Pickle. If successful, these
-  // methods return true. Otherwise, false is returned to indicate that the
-  // result could not be extracted. It is not possible to read from the iterator
-  // after that.
-  bool ReadBool(bool* result) WARN_UNUSED_RESULT;
-  bool ReadInt(int* result) WARN_UNUSED_RESULT;
-  bool ReadLong(long* result) WARN_UNUSED_RESULT;
-  bool ReadUInt16(uint16_t* result) WARN_UNUSED_RESULT;
-  bool ReadUInt32(uint32_t* result) WARN_UNUSED_RESULT;
-  bool ReadInt64(int64_t* result) WARN_UNUSED_RESULT;
-  bool ReadUInt64(uint64_t* result) WARN_UNUSED_RESULT;
-  bool ReadFloat(float* result) WARN_UNUSED_RESULT;
-  bool ReadDouble(double* result) WARN_UNUSED_RESULT;
-  bool ReadString(std::string* result) WARN_UNUSED_RESULT;
-  // The StringPiece data will only be valid for the lifetime of the message.
-  bool ReadStringPiece(StringPiece* result) WARN_UNUSED_RESULT;
-  bool ReadString16(string16* result) WARN_UNUSED_RESULT;
-  // The StringPiece16 data will only be valid for the lifetime of the message.
-  bool ReadStringPiece16(StringPiece16* result) WARN_UNUSED_RESULT;
-
-  // A pointer to the data will be placed in |*data|, and the length will be
-  // placed in |*length|. The pointer placed into |*data| points into the
-  // message's buffer so it will be scoped to the lifetime of the message (or
-  // until the message data is mutated). Do not keep the pointer around!
-  bool ReadData(const char** data, int* length) WARN_UNUSED_RESULT;
-
-  // A pointer to the data will be placed in |*data|. The caller specifies the
-  // number of bytes to read, and ReadBytes will validate this length. The
-  // pointer placed into |*data| points into the message's buffer so it will be
-  // scoped to the lifetime of the message (or until the message data is
-  // mutated). Do not keep the pointer around!
-  bool ReadBytes(const char** data, int length) WARN_UNUSED_RESULT;
-
-  // A safer version of ReadInt() that checks for the result not being negative.
-  // Use it for reading the object sizes.
-  bool ReadLength(int* result) WARN_UNUSED_RESULT {
-    return ReadInt(result) && *result >= 0;
-  }
-
-  // Skips bytes in the read buffer and returns true if there are at least
-  // num_bytes available. Otherwise, does nothing and returns false.
-  bool SkipBytes(int num_bytes) WARN_UNUSED_RESULT {
-    return !!GetReadPointerAndAdvance(num_bytes);
-  }
-
- private:
-  // Read Type from Pickle.
-  template <typename Type>
-  bool ReadBuiltinType(Type* result);
-
-  // Advance read_index_ but do not allow it to exceed end_index_.
-  // Keeps read_index_ aligned.
-  void Advance(size_t size);
-
-  // Get read pointer for Type and advance read pointer.
-  template<typename Type>
-  const char* GetReadPointerAndAdvance();
-
-  // Get read pointer for |num_bytes| and advance read pointer. This method
-  // checks num_bytes for negativity and wrapping.
-  const char* GetReadPointerAndAdvance(int num_bytes);
-
-  // Get read pointer for (num_elements * size_element) bytes and advance read
-  // pointer. This method checks for int overflow, negativity and wrapping.
-  const char* GetReadPointerAndAdvance(int num_elements,
-                                       size_t size_element);
-
-  const char* payload_;  // Start of our pickle's payload.
-  size_t read_index_;  // Offset of the next readable byte in payload.
-  size_t end_index_;  // Payload size.
-
-  FRIEND_TEST_ALL_PREFIXES(PickleTest, GetReadPointerAndAdvance);
-};
-
-// This class provides facilities for basic binary value packing and unpacking.
-//
-// The Pickle class supports appending primitive values (ints, strings, etc.)
-// to a pickle instance.  The Pickle instance grows its internal memory buffer
-// dynamically to hold the sequence of primitive values.   The internal memory
-// buffer is exposed as the "data" of the Pickle.  This "data" can be passed
-// to a Pickle object to initialize it for reading.
-//
-// When reading from a Pickle object, it is important for the consumer to know
-// what value types to read and in what order to read them as the Pickle does
-// not keep track of the type of data written to it.
-//
-// The Pickle's data has a header which contains the size of the Pickle's
-// payload.  It can optionally support additional space in the header.  That
-// space is controlled by the header_size parameter passed to the Pickle
-// constructor.
-//
-class BASE_EXPORT Pickle {
- public:
-  // Auxiliary data attached to a Pickle. Pickle must be subclassed along with
-  // this interface in order to provide a concrete implementation of support
-  // for attachments. The base Pickle implementation does not accept
-  // attachments.
-  class BASE_EXPORT Attachment : public RefCountedThreadSafe<Attachment> {
-   public:
-    Attachment();
-
-   protected:
-    friend class RefCountedThreadSafe<Attachment>;
-    virtual ~Attachment();
-
-    DISALLOW_COPY_AND_ASSIGN(Attachment);
-  };
-
-  // Initialize a Pickle object using the default header size.
-  Pickle();
-
-  // Initialize a Pickle object with the specified header size in bytes, which
-  // must be greater-than-or-equal-to sizeof(Pickle::Header).  The header size
-  // will be rounded up to ensure that the header size is 32bit-aligned.
-  explicit Pickle(int header_size);
-
-  // Initializes a Pickle from a const block of data.  The data is not copied;
-  // instead the data is merely referenced by this Pickle.  Only const methods
-  // should be used on the Pickle when initialized this way.  The header
-  // padding size is deduced from the data length.
-  Pickle(const char* data, int data_len);
-
-  // Initializes a Pickle as a deep copy of another Pickle.
-  Pickle(const Pickle& other);
-
-  // Note: There are no virtual methods in this class.  This destructor is
-  // virtual as an element of defensive coding.  Other classes have derived from
-  // this class, and there is a *chance* that they will cast into this base
-  // class before destruction.  At least one such class does have a virtual
-  // destructor, suggesting at least some need to call more derived destructors.
-  virtual ~Pickle();
-
-  // Performs a deep copy.
-  Pickle& operator=(const Pickle& other);
-
-  // Returns the number of bytes written in the Pickle, including the header.
-  size_t size() const { return header_size_ + header_->payload_size; }
-
-  // Returns the data for this Pickle.
-  const void* data() const { return header_; }
-
-  // Returns the effective memory capacity of this Pickle, that is, the total
-  // number of bytes currently dynamically allocated or 0 in the case of a
-  // read-only Pickle. This should be used only for diagnostic / profiling
-  // purposes.
-  size_t GetTotalAllocatedSize() const;
-
-  // Methods for adding to the payload of the Pickle.  These values are
-  // appended to the end of the Pickle's payload.  When reading values from a
-  // Pickle, it is important to read them in the order in which they were added
-  // to the Pickle.
-
-  void WriteBool(bool value) { WriteInt(value ? 1 : 0); }
-  void WriteInt(int value) { WritePOD(value); }
-  void WriteLong(long value) {
-    // Always write long as a 64-bit value to ensure compatibility between
-    // 32-bit and 64-bit processes.
-    WritePOD(static_cast<int64_t>(value));
-  }
-  void WriteUInt16(uint16_t value) { WritePOD(value); }
-  void WriteUInt32(uint32_t value) { WritePOD(value); }
-  void WriteInt64(int64_t value) { WritePOD(value); }
-  void WriteUInt64(uint64_t value) { WritePOD(value); }
-  void WriteFloat(float value) { WritePOD(value); }
-  void WriteDouble(double value) { WritePOD(value); }
-  void WriteString(const StringPiece& value);
-  void WriteString16(const StringPiece16& value);
-  // "Data" is a blob with a length. When you read it out you will be given the
-  // length. See also WriteBytes.
-  void WriteData(const char* data, int length);
-  // "Bytes" is a blob with no length. The caller must specify the length both
-  // when reading and writing. It is normally used to serialize PoD types of a
-  // known size. See also WriteData.
-  void WriteBytes(const void* data, int length);
-
-  // WriteAttachment appends |attachment| to the pickle. It returns
-  // false iff the set is full or if the Pickle implementation does not support
-  // attachments.
-  virtual bool WriteAttachment(scoped_refptr<Attachment> attachment);
-
-  // ReadAttachment parses an attachment given the parsing state |iter| and
-  // writes it to |*attachment|. It returns true on success.
-  virtual bool ReadAttachment(base::PickleIterator* iter,
-                              scoped_refptr<Attachment>* attachment) const;
-
-  // Indicates whether the pickle has any attachments.
-  virtual bool HasAttachments() const;
-
-  // Reserves space for upcoming writes when multiple writes will be made and
-  // their sizes are computed in advance. It can be significantly faster to call
-  // Reserve() before calling WriteFoo() multiple times.
-  void Reserve(size_t additional_capacity);
-
-  // Payload follows after allocation of Header (header size is customizable).
-  struct Header {
-    uint32_t payload_size;  // Specifies the size of the payload.
-  };
-
-  // Returns the header, cast to a user-specified type T.  The type T must be a
-  // subclass of Header and its size must correspond to the header_size passed
-  // to the Pickle constructor.
-  template <class T>
-  T* headerT() {
-    DCHECK_EQ(header_size_, sizeof(T));
-    return static_cast<T*>(header_);
-  }
-  template <class T>
-  const T* headerT() const {
-    DCHECK_EQ(header_size_, sizeof(T));
-    return static_cast<const T*>(header_);
-  }
-
-  // The payload is the pickle data immediately following the header.
-  size_t payload_size() const {
-    return header_ ? header_->payload_size : 0;
-  }
-
-  const char* payload() const {
-    return reinterpret_cast<const char*>(header_) + header_size_;
-  }
-
-  // Returns the address of the byte immediately following the currently valid
-  // header + payload.
-  const char* end_of_payload() const {
-    // This object may be invalid.
-    return header_ ? payload() + payload_size() : NULL;
-  }
-
- protected:
-  // Returns size of the header, which can have default value, set by user or
-  // calculated by passed raw data.
-  size_t header_size() const { return header_size_; }
-
-  char* mutable_payload() {
-    return reinterpret_cast<char*>(header_) + header_size_;
-  }
-
-  size_t capacity_after_header() const {
-    return capacity_after_header_;
-  }
-
-  // Resize the capacity, note that the input value should not include the size
-  // of the header.
-  void Resize(size_t new_capacity);
-
-  // Claims |num_bytes| bytes of payload. This is similar to Reserve() in that
-  // it may grow the capacity, but it also advances the write offset of the
-  // pickle by |num_bytes|. Claimed memory, including padding, is zeroed.
-  //
-  // Returns the address of the first byte claimed.
-  void* ClaimBytes(size_t num_bytes);
-
-  // Find the end of the pickled data that starts at range_start.  Returns NULL
-  // if the entire Pickle is not found in the given data range.
-  static const char* FindNext(size_t header_size,
-                              const char* range_start,
-                              const char* range_end);
-
-  // Parse pickle header and return total size of the pickle. Data range
-  // doesn't need to contain entire pickle.
-  // Returns true if pickle header was found and parsed. Callers must check
-  // returned |pickle_size| for sanity (against maximum message size, etc).
-  // NOTE: when function successfully parses a header, but encounters an
-  // overflow during pickle size calculation, it sets |pickle_size| to the
-  // maximum size_t value and returns true.
-  static bool PeekNext(size_t header_size,
-                       const char* range_start,
-                       const char* range_end,
-                       size_t* pickle_size);
-
-  // The allocation granularity of the payload.
-  static const int kPayloadUnit;
-
- private:
-  friend class PickleIterator;
-
-  Header* header_;
-  size_t header_size_;  // Supports extra data between header and payload.
-  // Allocation size of payload (or -1 if allocation is const). Note: this
-  // doesn't count the header.
-  size_t capacity_after_header_;
-  // The offset at which we will write the next field. Note: this doesn't count
-  // the header.
-  size_t write_offset_;
-
-  // Just like WriteBytes, but with a compile-time size, for performance.
-  template<size_t length> void BASE_EXPORT WriteBytesStatic(const void* data);
-
-  // Writes a POD by copying its bytes.
-  template <typename T> bool WritePOD(const T& data) {
-    WriteBytesStatic<sizeof(data)>(&data);
-    return true;
-  }
-
-  inline void* ClaimUninitializedBytesInternal(size_t num_bytes);
-  inline void WriteBytesCommon(const void* data, size_t length);
-
-  FRIEND_TEST_ALL_PREFIXES(PickleTest, DeepCopyResize);
-  FRIEND_TEST_ALL_PREFIXES(PickleTest, Resize);
-  FRIEND_TEST_ALL_PREFIXES(PickleTest, PeekNext);
-  FRIEND_TEST_ALL_PREFIXES(PickleTest, PeekNextOverflow);
-  FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNext);
-  FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextWithIncompleteHeader);
-  FRIEND_TEST_ALL_PREFIXES(PickleTest, FindNextOverflow);
-};
-
-}  // namespace base
-
-#endif  // BASE_PICKLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/posix/eintr_wrapper.h b/native/zucchini/vendor/libchrome/base/posix/eintr_wrapper.h
deleted file mode 100644
index 0e6e437..0000000
--- a/native/zucchini/vendor/libchrome/base/posix/eintr_wrapper.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This provides a wrapper around system calls which may be interrupted by a
-// signal and return EINTR. See man 7 signal.
-// To prevent long-lasting loops (which would likely be a bug, such as a signal
-// that should be masked) to go unnoticed, there is a limit after which the
-// caller will nonetheless see an EINTR in Debug builds.
-//
-// On Windows and Fuchsia, this wrapper macro does nothing because there are no
-// signals.
-//
-// Don't wrap close calls in HANDLE_EINTR. Use IGNORE_EINTR if the return
-// value of close is significant. See http://crbug.com/269623.
-
-#ifndef BASE_POSIX_EINTR_WRAPPER_H_
-#define BASE_POSIX_EINTR_WRAPPER_H_
-
-#include "build/build_config.h"
-
-#if defined(OS_POSIX)
-
-#include <errno.h>
-
-#if defined(NDEBUG)
-
-#define HANDLE_EINTR(x) ({ \
-  decltype(x) eintr_wrapper_result; \
-  do { \
-    eintr_wrapper_result = (x); \
-  } while (eintr_wrapper_result == -1 && errno == EINTR); \
-  eintr_wrapper_result; \
-})
-
-#else
-
-#define HANDLE_EINTR(x) ({ \
-  int eintr_wrapper_counter = 0; \
-  decltype(x) eintr_wrapper_result; \
-  do { \
-    eintr_wrapper_result = (x); \
-  } while (eintr_wrapper_result == -1 && errno == EINTR && \
-           eintr_wrapper_counter++ < 100); \
-  eintr_wrapper_result; \
-})
-
-#endif  // NDEBUG
-
-#define IGNORE_EINTR(x) ({ \
-  decltype(x) eintr_wrapper_result; \
-  do { \
-    eintr_wrapper_result = (x); \
-    if (eintr_wrapper_result == -1 && errno == EINTR) { \
-      eintr_wrapper_result = 0; \
-    } \
-  } while (0); \
-  eintr_wrapper_result; \
-})
-
-#else  // !OS_POSIX
-
-#define HANDLE_EINTR(x) (x)
-#define IGNORE_EINTR(x) (x)
-
-#endif  // !OS_POSIX
-
-#endif  // BASE_POSIX_EINTR_WRAPPER_H_
diff --git a/native/zucchini/vendor/libchrome/base/posix/file_descriptor_shuffle.h b/native/zucchini/vendor/libchrome/base/posix/file_descriptor_shuffle.h
deleted file mode 100644
index 2afdc28..0000000
--- a/native/zucchini/vendor/libchrome/base/posix/file_descriptor_shuffle.h
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_POSIX_FILE_DESCRIPTOR_SHUFFLE_H_
-#define BASE_POSIX_FILE_DESCRIPTOR_SHUFFLE_H_
-
-// This code exists to shuffle file descriptors, which is commonly needed when
-// forking subprocesses. The naive approach (just call dup2 to set up the
-// desired descriptors) is very simple, but wrong: it won't handle edge cases
-// (like mapping 0 -> 1, 1 -> 0) correctly.
-//
-// In order to unittest this code, it's broken into the abstract action (an
-// injective multimap) and the concrete code for dealing with file descriptors.
-// Users should use the code like this:
-//   base::InjectiveMultimap file_descriptor_map;
-//   file_descriptor_map.push_back(base::InjectionArc(devnull, 0, true));
-//   file_descriptor_map.push_back(base::InjectionArc(devnull, 2, true));
-//   file_descriptor_map.push_back(base::InjectionArc(pipe[1], 1, true));
-//   base::ShuffleFileDescriptors(file_descriptor_map);
-//
-// and trust the the Right Thing will get done.
-
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-
-namespace base {
-
-// A Delegate which performs the actions required to perform an injective
-// multimapping in place.
-class InjectionDelegate {
- public:
-  // Duplicate |fd|, an element of the domain, and write a fresh element of the
-  // domain into |result|. Returns true iff successful.
-  virtual bool Duplicate(int* result, int fd) = 0;
-  // Destructively move |src| to |dest|, overwriting |dest|. Returns true iff
-  // successful.
-  virtual bool Move(int src, int dest) = 0;
-  // Delete an element of the domain.
-  virtual void Close(int fd) = 0;
-
- protected:
-  virtual ~InjectionDelegate() = default;
-};
-
-// An implementation of the InjectionDelegate interface using the file
-// descriptor table of the current process as the domain.
-class BASE_EXPORT FileDescriptorTableInjection : public InjectionDelegate {
-  bool Duplicate(int* result, int fd) override;
-  bool Move(int src, int dest) override;
-  void Close(int fd) override;
-};
-
-// A single arc of the directed graph which describes an injective multimapping.
-struct InjectionArc {
-  InjectionArc(int in_source, int in_dest, bool in_close)
-      : source(in_source),
-        dest(in_dest),
-        close(in_close) {
-  }
-
-  int source;
-  int dest;
-  bool close;  // if true, delete the source element after performing the
-               // mapping.
-};
-
-typedef std::vector<InjectionArc> InjectiveMultimap;
-
-BASE_EXPORT bool PerformInjectiveMultimap(const InjectiveMultimap& map,
-                                          InjectionDelegate* delegate);
-
-BASE_EXPORT bool PerformInjectiveMultimapDestructive(
-    InjectiveMultimap* map,
-    InjectionDelegate* delegate);
-
-// This function will not call malloc but will mutate |map|
-static inline bool ShuffleFileDescriptors(InjectiveMultimap* map) {
-  FileDescriptorTableInjection delegate;
-  return PerformInjectiveMultimapDestructive(map, &delegate);
-}
-
-}  // namespace base
-
-#endif  // BASE_POSIX_FILE_DESCRIPTOR_SHUFFLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/posix/safe_strerror.h b/native/zucchini/vendor/libchrome/base/posix/safe_strerror.h
deleted file mode 100644
index 2945312..0000000
--- a/native/zucchini/vendor/libchrome/base/posix/safe_strerror.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_POSIX_SAFE_STRERROR_H_
-#define BASE_POSIX_SAFE_STRERROR_H_
-
-#include <stddef.h>
-
-#include <string>
-
-#include "base/base_export.h"
-
-namespace base {
-
-// BEFORE using anything from this file, first look at PLOG and friends in
-// logging.h and use them instead if applicable.
-//
-// This file declares safe, portable alternatives to the POSIX strerror()
-// function. strerror() is inherently unsafe in multi-threaded apps and should
-// never be used. Doing so can cause crashes. Additionally, the thread-safe
-// alternative strerror_r varies in semantics across platforms. Use these
-// functions instead.
-
-// Thread-safe strerror function with dependable semantics that never fails.
-// It will write the string form of error "err" to buffer buf of length len.
-// If there is an error calling the OS's strerror_r() function then a message to
-// that effect will be printed into buf, truncating if necessary. The final
-// result is always null-terminated. The value of errno is never changed.
-//
-// Use this instead of strerror_r().
-BASE_EXPORT void safe_strerror_r(int err, char *buf, size_t len);
-
-// Calls safe_strerror_r with a buffer of suitable size and returns the result
-// in a C++ string.
-//
-// Use this instead of strerror(). Note though that safe_strerror_r will be
-// more robust in the case of heap corruption errors, since it doesn't need to
-// allocate a string.
-BASE_EXPORT std::string safe_strerror(int err);
-
-}  // namespace base
-
-#endif  // BASE_POSIX_SAFE_STRERROR_H_
diff --git a/native/zucchini/vendor/libchrome/base/process/launch.h b/native/zucchini/vendor/libchrome/base/process/launch.h
deleted file mode 100644
index 7a2def2..0000000
--- a/native/zucchini/vendor/libchrome/base/process/launch.h
+++ /dev/null
@@ -1,396 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This file contains functions for launching subprocesses.
-
-#ifndef BASE_PROCESS_LAUNCH_H_
-#define BASE_PROCESS_LAUNCH_H_
-
-#include <stddef.h>
-
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/environment.h"
-#include "base/macros.h"
-#include "base/process/process.h"
-#include "base/process/process_handle.h"
-#include "base/strings/string_piece.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include <windows.h>
-#elif defined(OS_FUCHSIA)
-#include <lib/fdio/spawn.h>
-#include <zircon/types.h>
-#endif
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include "base/posix/file_descriptor_shuffle.h"
-#endif
-
-namespace base {
-
-class CommandLine;
-
-#if defined(OS_WIN)
-typedef std::vector<HANDLE> HandlesToInheritVector;
-#elif defined(OS_FUCHSIA)
-struct PathToTransfer {
-  base::FilePath path;
-  zx_handle_t handle;
-};
-struct HandleToTransfer {
-  uint32_t id;
-  zx_handle_t handle;
-};
-typedef std::vector<HandleToTransfer> HandlesToTransferVector;
-typedef std::vector<std::pair<int, int>> FileHandleMappingVector;
-#elif defined(OS_POSIX)
-typedef std::vector<std::pair<int, int>> FileHandleMappingVector;
-#endif  // defined(OS_WIN)
-
-// Options for launching a subprocess that are passed to LaunchProcess().
-// The default constructor constructs the object with default options.
-struct BASE_EXPORT LaunchOptions {
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-  // Delegate to be run in between fork and exec in the subprocess (see
-  // pre_exec_delegate below)
-  class BASE_EXPORT PreExecDelegate {
-   public:
-    PreExecDelegate() = default;
-    virtual ~PreExecDelegate() = default;
-
-    // Since this is to be run between fork and exec, and fork may have happened
-    // while multiple threads were running, this function needs to be async
-    // safe.
-    virtual void RunAsyncSafe() = 0;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(PreExecDelegate);
-  };
-#endif  // defined(OS_POSIX)
-
-  LaunchOptions();
-  LaunchOptions(const LaunchOptions&);
-  ~LaunchOptions();
-
-  // If true, wait for the process to complete.
-  bool wait = false;
-
-  // If not empty, change to this directory before executing the new process.
-  base::FilePath current_directory;
-
-#if defined(OS_WIN)
-  bool start_hidden = false;
-
-  // Windows can inherit handles when it launches child processes.
-  // See https://blogs.msdn.microsoft.com/oldnewthing/20111216-00/?p=8873
-  // for a good overview of Windows handle inheritance.
-  //
-  // Implementation note: it might be nice to implement in terms of
-  // base::Optional<>, but then the natural default state (vector not present)
-  // would be "all inheritable handles" while we want "no inheritance."
-  enum class Inherit {
-    // Only those handles in |handles_to_inherit| vector are inherited. If the
-    // vector is empty, no handles are inherited. The handles in the vector must
-    // all be inheritable.
-    kSpecific,
-
-    // All handles in the current process which are inheritable are inherited.
-    // In production code this flag should be used only when running
-    // short-lived, trusted binaries, because open handles from other libraries
-    // and subsystems will leak to the child process, causing errors such as
-    // open socket hangs. There are also race conditions that can cause handle
-    // over-sharing.
-    //
-    // |handles_to_inherit| must be null.
-    //
-    // DEPRECATED. THIS SHOULD NOT BE USED. Explicitly map all handles that
-    // need to be shared in new code.
-    // TODO(brettw) bug 748258: remove this.
-    kAll
-  };
-  Inherit inherit_mode = Inherit::kSpecific;
-  HandlesToInheritVector handles_to_inherit;
-
-  // If non-null, runs as if the user represented by the token had launched it.
-  // Whether the application is visible on the interactive desktop depends on
-  // the token belonging to an interactive logon session.
-  //
-  // To avoid hard to diagnose problems, when specified this loads the
-  // environment variables associated with the user and if this operation fails
-  // the entire call fails as well.
-  UserTokenHandle as_user = nullptr;
-
-  // If true, use an empty string for the desktop name.
-  bool empty_desktop_name = false;
-
-  // If non-null, launches the application in that job object. The process will
-  // be terminated immediately and LaunchProcess() will fail if assignment to
-  // the job object fails.
-  HANDLE job_handle = nullptr;
-
-  // Handles for the redirection of stdin, stdout and stderr. The caller should
-  // either set all three of them or none (i.e. there is no way to redirect
-  // stderr without redirecting stdin).
-  //
-  // The handles must be inheritable. Pseudo handles are used when stdout and
-  // stderr redirect to the console. In that case, GetFileType() will return
-  // FILE_TYPE_CHAR and they're automatically inherited by child processes. See
-  // https://msdn.microsoft.com/en-us/library/windows/desktop/ms682075.aspx
-  // Otherwise, the caller must ensure that the |inherit_mode| and/or
-  // |handles_to_inherit| set so that the handles are inherited.
-  HANDLE stdin_handle = nullptr;
-  HANDLE stdout_handle = nullptr;
-  HANDLE stderr_handle = nullptr;
-
-  // If set to true, ensures that the child process is launched with the
-  // CREATE_BREAKAWAY_FROM_JOB flag which allows it to breakout of the parent
-  // job if any.
-  bool force_breakaway_from_job_ = false;
-
-  // If set to true, permission to bring windows to the foreground is passed to
-  // the launched process if the current process has such permission.
-  bool grant_foreground_privilege = false;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  // Set/unset environment variables. These are applied on top of the parent
-  // process environment.  Empty (the default) means to inherit the same
-  // environment. See AlterEnvironment().
-  EnvironmentMap environ;
-
-  // Clear the environment for the new process before processing changes from
-  // |environ|.
-  bool clear_environ = false;
-
-  // Remap file descriptors according to the mapping of src_fd->dest_fd to
-  // propagate FDs into the child process.
-  FileHandleMappingVector fds_to_remap;
-#endif  // defined(OS_WIN)
-
-#if defined(OS_LINUX)
-  // If non-zero, start the process using clone(), using flags as provided.
-  // Unlike in clone, clone_flags may not contain a custom termination signal
-  // that is sent to the parent when the child dies. The termination signal will
-  // always be set to SIGCHLD.
-  int clone_flags = 0;
-
-  // By default, child processes will have the PR_SET_NO_NEW_PRIVS bit set. If
-  // true, then this bit will not be set in the new child process.
-  bool allow_new_privs = false;
-
-  // Sets parent process death signal to SIGKILL.
-  bool kill_on_parent_death = false;
-#endif  // defined(OS_LINUX)
-
-#if defined(OS_FUCHSIA)
-  // If valid, launches the application in that job object.
-  zx_handle_t job_handle = ZX_HANDLE_INVALID;
-
-  // Specifies additional handles to transfer (not duplicate) to the child
-  // process. Each entry is an <id,handle> pair, with an |id| created using the
-  // PA_HND() macro. The child retrieves the handle
-  // |zx_take_startup_handle(id)|. The supplied handles are consumed by
-  // LaunchProcess() even on failure.
-  HandlesToTransferVector handles_to_transfer;
-
-  // Specifies which basic capabilities to grant to the child process.
-  // By default the child process will receive the caller's complete namespace,
-  // access to the current base::fuchsia::DefaultJob(), handles for stdio and
-  // access to the dynamic library loader.
-  // Note that the child is always provided access to the loader service.
-  uint32_t spawn_flags = FDIO_SPAWN_CLONE_NAMESPACE | FDIO_SPAWN_CLONE_STDIO |
-                         FDIO_SPAWN_CLONE_JOB;
-
-  // Specifies paths to clone from the calling process' namespace into that of
-  // the child process. If |paths_to_clone| is empty then the process will
-  // receive either a full copy of the parent's namespace, or an empty one,
-  // depending on whether FDIO_SPAWN_CLONE_NAMESPACE is set.
-  std::vector<FilePath> paths_to_clone;
-
-  // Specifies handles which will be installed as files or directories in the
-  // child process' namespace. Paths installed by |paths_to_clone| will be
-  // overridden by these entries.
-  std::vector<PathToTransfer> paths_to_transfer;
-#endif  // defined(OS_FUCHSIA)
-
-#if defined(OS_POSIX)
-  // If not empty, launch the specified executable instead of
-  // cmdline.GetProgram(). This is useful when it is necessary to pass a custom
-  // argv[0].
-  base::FilePath real_path;
-
-  // If non-null, a delegate to be run immediately prior to executing the new
-  // program in the child process.
-  //
-  // WARNING: If LaunchProcess is called in the presence of multiple threads,
-  // code running in this delegate essentially needs to be async-signal safe
-  // (see man 7 signal for a list of allowed functions).
-  PreExecDelegate* pre_exec_delegate = nullptr;
-
-  // Each element is an RLIMIT_* constant that should be raised to its
-  // rlim_max.  This pointer is owned by the caller and must live through
-  // the call to LaunchProcess().
-  const std::vector<int>* maximize_rlimits = nullptr;
-
-  // If true, start the process in a new process group, instead of
-  // inheriting the parent's process group.  The pgid of the child process
-  // will be the same as its pid.
-  bool new_process_group = false;
-#endif  // defined(OS_POSIX)
-
-#if defined(OS_CHROMEOS)
-  // If non-negative, the specified file descriptor will be set as the launched
-  // process' controlling terminal.
-  int ctrl_terminal_fd = -1;
-#endif  // defined(OS_CHROMEOS)
-};
-
-// Launch a process via the command line |cmdline|.
-// See the documentation of LaunchOptions for details on |options|.
-//
-// Returns a valid Process upon success.
-//
-// Unix-specific notes:
-// - All file descriptors open in the parent process will be closed in the
-//   child process except for any preserved by options::fds_to_remap, and
-//   stdin, stdout, and stderr. If not remapped by options::fds_to_remap,
-//   stdin is reopened as /dev/null, and the child is allowed to inherit its
-//   parent's stdout and stderr.
-// - If the first argument on the command line does not contain a slash,
-//   PATH will be searched.  (See man execvp.)
-BASE_EXPORT Process LaunchProcess(const CommandLine& cmdline,
-                                  const LaunchOptions& options);
-
-#if defined(OS_WIN)
-// Windows-specific LaunchProcess that takes the command line as a
-// string.  Useful for situations where you need to control the
-// command line arguments directly, but prefer the CommandLine version
-// if launching Chrome itself.
-//
-// The first command line argument should be the path to the process,
-// and don't forget to quote it.
-//
-// Example (including literal quotes)
-//  cmdline = "c:\windows\explorer.exe" -foo "c:\bar\"
-BASE_EXPORT Process LaunchProcess(const string16& cmdline,
-                                  const LaunchOptions& options);
-
-// Launches a process with elevated privileges.  This does not behave exactly
-// like LaunchProcess as it uses ShellExecuteEx instead of CreateProcess to
-// create the process.  This means the process will have elevated privileges
-// and thus some common operations like OpenProcess will fail. Currently the
-// only supported LaunchOptions are |start_hidden| and |wait|.
-BASE_EXPORT Process LaunchElevatedProcess(const CommandLine& cmdline,
-                                          const LaunchOptions& options);
-
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-// A POSIX-specific version of LaunchProcess that takes an argv array
-// instead of a CommandLine.  Useful for situations where you need to
-// control the command line arguments directly, but prefer the
-// CommandLine version if launching Chrome itself.
-BASE_EXPORT Process LaunchProcess(const std::vector<std::string>& argv,
-                                  const LaunchOptions& options);
-
-// Close all file descriptors, except those which are a destination in the
-// given multimap. Only call this function in a child process where you know
-// that there aren't any other threads.
-BASE_EXPORT void CloseSuperfluousFds(const InjectiveMultimap& saved_map);
-#endif  // defined(OS_WIN)
-
-#if defined(OS_WIN)
-// Set |job_object|'s JOBOBJECT_EXTENDED_LIMIT_INFORMATION
-// BasicLimitInformation.LimitFlags to |limit_flags|.
-BASE_EXPORT bool SetJobObjectLimitFlags(HANDLE job_object, DWORD limit_flags);
-
-// Output multi-process printf, cout, cerr, etc to the cmd.exe console that ran
-// chrome. This is not thread-safe: only call from main thread.
-BASE_EXPORT void RouteStdioToConsole(bool create_console_if_not_found);
-#endif  // defined(OS_WIN)
-
-// Executes the application specified by |cl| and wait for it to exit. Stores
-// the output (stdout) in |output|. Redirects stderr to /dev/null. Returns true
-// on success (application launched and exited cleanly, with exit code
-// indicating success).
-BASE_EXPORT bool GetAppOutput(const CommandLine& cl, std::string* output);
-
-// Like GetAppOutput, but also includes stderr.
-BASE_EXPORT bool GetAppOutputAndError(const CommandLine& cl,
-                                      std::string* output);
-
-// A version of |GetAppOutput()| which also returns the exit code of the
-// executed command. Returns true if the application runs and exits cleanly. If
-// this is the case the exit code of the application is available in
-// |*exit_code|.
-BASE_EXPORT bool GetAppOutputWithExitCode(const CommandLine& cl,
-                                          std::string* output, int* exit_code);
-
-#if defined(OS_WIN)
-// A Windows-specific version of GetAppOutput that takes a command line string
-// instead of a CommandLine object. Useful for situations where you need to
-// control the command line arguments directly.
-BASE_EXPORT bool GetAppOutput(const StringPiece16& cl, std::string* output);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-// A POSIX-specific version of GetAppOutput that takes an argv array
-// instead of a CommandLine.  Useful for situations where you need to
-// control the command line arguments directly.
-BASE_EXPORT bool GetAppOutput(const std::vector<std::string>& argv,
-                              std::string* output);
-
-// Like the above POSIX-specific version of GetAppOutput, but also includes
-// stderr.
-BASE_EXPORT bool GetAppOutputAndError(const std::vector<std::string>& argv,
-                                      std::string* output);
-#endif  // defined(OS_WIN)
-
-// If supported on the platform, and the user has sufficent rights, increase
-// the current process's scheduling priority to a high priority.
-BASE_EXPORT void RaiseProcessToHighPriority();
-
-#if defined(OS_MACOSX)
-// An implementation of LaunchProcess() that uses posix_spawn() instead of
-// fork()+exec(). This does not support the |pre_exec_delegate| and
-// |current_directory| options.
-Process LaunchProcessPosixSpawn(const std::vector<std::string>& argv,
-                                const LaunchOptions& options);
-
-// Restore the default exception handler, setting it to Apple Crash Reporter
-// (ReportCrash).  When forking and execing a new process, the child will
-// inherit the parent's exception ports, which may be set to the Breakpad
-// instance running inside the parent.  The parent's Breakpad instance should
-// not handle the child's exceptions.  Calling RestoreDefaultExceptionHandler
-// in the child after forking will restore the standard exception handler.
-// See http://crbug.com/20371/ for more details.
-void RestoreDefaultExceptionHandler();
-#endif  // defined(OS_MACOSX)
-
-// Creates a LaunchOptions object suitable for launching processes in a test
-// binary. This should not be called in production/released code.
-BASE_EXPORT LaunchOptions LaunchOptionsForTest();
-
-#if defined(OS_LINUX) || defined(OS_NACL_NONSFI)
-// A wrapper for clone with fork-like behavior, meaning that it returns the
-// child's pid in the parent and 0 in the child. |flags|, |ptid|, and |ctid| are
-// as in the clone system call (the CLONE_VM flag is not supported).
-//
-// This function uses the libc clone wrapper (which updates libc's pid cache)
-// internally, so callers may expect things like getpid() to work correctly
-// after in both the child and parent.
-//
-// As with fork(), callers should be extremely careful when calling this while
-// multiple threads are running, since at the time the fork happened, the
-// threads could have been in any state (potentially holding locks, etc.).
-// Callers should most likely call execve() in the child soon after calling
-// this.
-//
-// It is unsafe to use any pthread APIs after ForkWithFlags().
-// However, performing an exec() will lift this restriction.
-BASE_EXPORT pid_t ForkWithFlags(unsigned long flags, pid_t* ptid, pid_t* ctid);
-#endif
-
-}  // namespace base
-
-#endif  // BASE_PROCESS_LAUNCH_H_
diff --git a/native/zucchini/vendor/libchrome/base/process/process.h b/native/zucchini/vendor/libchrome/base/process/process.h
deleted file mode 100644
index 674cea3..0000000
--- a/native/zucchini/vendor/libchrome/base/process/process.h
+++ /dev/null
@@ -1,213 +0,0 @@
-// Copyright 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_PROCESS_PROCESS_H_
-#define BASE_PROCESS_PROCESS_H_
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/process/process_handle.h"
-#include "base/time/time.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include "base/win/scoped_handle.h"
-#endif
-
-#if defined(OS_FUCHSIA)
-#include <lib/zx/process.h>
-#endif
-
-#if defined(OS_MACOSX)
-#include "base/feature_list.h"
-#include "base/process/port_provider_mac.h"
-#endif
-
-namespace base {
-
-#if defined(OS_MACOSX)
-extern const Feature kMacAllowBackgroundingProcesses;
-#endif
-
-// Provides a move-only encapsulation of a process.
-//
-// This object is not tied to the lifetime of the underlying process: the
-// process may be killed and this object may still around, and it will still
-// claim to be valid. The actual behavior in that case is OS dependent like so:
-//
-// Windows: The underlying ProcessHandle will be valid after the process dies
-// and can be used to gather some information about that process, but most
-// methods will obviously fail.
-//
-// POSIX: The underlying ProcessHandle is not guaranteed to remain valid after
-// the process dies, and it may be reused by the system, which means that it may
-// end up pointing to the wrong process.
-class BASE_EXPORT Process {
- public:
-  // On Windows, this takes ownership of |handle|. On POSIX, this does not take
-  // ownership of |handle|.
-  explicit Process(ProcessHandle handle = kNullProcessHandle);
-
-  Process(Process&& other);
-
-  // The destructor does not terminate the process.
-  ~Process();
-
-  Process& operator=(Process&& other);
-
-  // Returns an object for the current process.
-  static Process Current();
-
-  // Returns a Process for the given |pid|.
-  static Process Open(ProcessId pid);
-
-  // Returns a Process for the given |pid|. On Windows the handle is opened
-  // with more access rights and must only be used by trusted code (can read the
-  // address space and duplicate handles).
-  static Process OpenWithExtraPrivileges(ProcessId pid);
-
-#if defined(OS_WIN)
-  // Returns a Process for the given |pid|, using some |desired_access|.
-  // See ::OpenProcess documentation for valid |desired_access|.
-  static Process OpenWithAccess(ProcessId pid, DWORD desired_access);
-#endif
-
-  // Creates an object from a |handle| owned by someone else.
-  // Don't use this for new code. It is only intended to ease the migration to
-  // a strict ownership model.
-  // TODO(rvargas) crbug.com/417532: Remove this code.
-  static Process DeprecatedGetProcessFromHandle(ProcessHandle handle);
-
-  // Returns true if processes can be backgrounded.
-  static bool CanBackgroundProcesses();
-
-  // Terminates the current process immediately with |exit_code|.
-  [[noreturn]] static void TerminateCurrentProcessImmediately(int exit_code);
-
-  // Returns true if this objects represents a valid process.
-  bool IsValid() const;
-
-  // Returns a handle for this process. There is no guarantee about when that
-  // handle becomes invalid because this object retains ownership.
-  ProcessHandle Handle() const;
-
-  // Returns a second object that represents this process.
-  Process Duplicate() const;
-
-  // Get the PID for this process.
-  ProcessId Pid() const;
-
-  // Returns true if this process is the current process.
-  bool is_current() const;
-
-  // Close the process handle. This will not terminate the process.
-  void Close();
-
-  // Returns true if this process is still running. This is only safe on Windows
-  // (and maybe Fuchsia?), because the ProcessHandle will keep the zombie
-  // process information available until itself has been released. But on Posix,
-  // the OS may reuse the ProcessId.
-#if defined(OS_WIN)
-  bool IsRunning() const {
-    return !WaitForExitWithTimeout(base::TimeDelta(), nullptr);
-  }
-#endif
-
-  // Terminates the process with extreme prejudice. The given |exit_code| will
-  // be the exit code of the process. If |wait| is true, this method will wait
-  // for up to one minute for the process to actually terminate.
-  // Returns true if the process terminates within the allowed time.
-  // NOTE: On POSIX |exit_code| is ignored.
-  bool Terminate(int exit_code, bool wait) const;
-
-  // Waits for the process to exit. Returns true on success.
-  // On POSIX, if the process has been signaled then |exit_code| is set to -1.
-  // On Linux this must be a child process, however on Mac and Windows it can be
-  // any process.
-  // NOTE: |exit_code| is optional, nullptr can be passed if the exit code is
-  // not required.
-  bool WaitForExit(int* exit_code) const;
-
-  // Same as WaitForExit() but only waits for up to |timeout|.
-  // NOTE: |exit_code| is optional, nullptr can be passed if the exit code
-  // is not required.
-  bool WaitForExitWithTimeout(TimeDelta timeout, int* exit_code) const;
-
-  // Indicates that the process has exited with the specified |exit_code|.
-  // This should be called if process exit is observed outside of this class.
-  // (i.e. Not because Terminate or WaitForExit, above, was called.)
-  // Note that nothing prevents this being called multiple times for a dead
-  // process though that should be avoided.
-  void Exited(int exit_code) const;
-
-#if defined(OS_MACOSX)
-  // The Mac needs a Mach port in order to manipulate a process's priority,
-  // and there's no good way to get that from base given the pid. These Mac
-  // variants of the IsProcessBackgrounded and SetProcessBackgrounded API take
-  // a port provider for this reason. See crbug.com/460102
-  //
-  // A process is backgrounded when its task priority is
-  // |TASK_BACKGROUND_APPLICATION|.
-  //
-  // Returns true if the port_provider can locate a task port for the process
-  // and it is backgrounded. If port_provider is null, returns false.
-  bool IsProcessBackgrounded(PortProvider* port_provider) const;
-
-  // Set the process as backgrounded. If value is
-  // true, the priority of the associated task will be set to
-  // TASK_BACKGROUND_APPLICATION. If value is false, the
-  // priority of the process will be set to TASK_FOREGROUND_APPLICATION.
-  //
-  // Returns true if the priority was changed, false otherwise. If
-  // |port_provider| is null, this is a no-op and it returns false.
-  bool SetProcessBackgrounded(PortProvider* port_provider, bool value);
-#else
-  // A process is backgrounded when it's priority is lower than normal.
-  // Return true if this process is backgrounded, false otherwise.
-  bool IsProcessBackgrounded() const;
-
-  // Set a process as backgrounded. If value is true, the priority of the
-  // process will be lowered. If value is false, the priority of the process
-  // will be made "normal" - equivalent to default process priority.
-  // Returns true if the priority was changed, false otherwise.
-  bool SetProcessBackgrounded(bool value);
-#endif  // defined(OS_MACOSX)
-  // Returns an integer representing the priority of a process. The meaning
-  // of this value is OS dependent.
-  int GetPriority() const;
-
-#if defined(OS_CHROMEOS)
-  // Get the PID in its PID namespace.
-  // If the process is not in a PID namespace or /proc/<pid>/status does not
-  // report NSpid, kNullProcessId is returned.
-  ProcessId GetPidInNamespace() const;
-#endif
-
- private:
-#if defined(OS_WIN)
-  win::ScopedHandle process_;
-#elif defined(OS_FUCHSIA)
-  zx::process process_;
-#else
-  ProcessHandle process_;
-#endif
-
-#if defined(OS_WIN) || defined(OS_FUCHSIA)
-  bool is_current_process_;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(Process);
-};
-
-#if defined(OS_CHROMEOS)
-// Exposed for testing.
-// Given the contents of the /proc/<pid>/cgroup file, determine whether the
-// process is backgrounded or not.
-BASE_EXPORT bool IsProcessBackgroundedCGroup(
-    const StringPiece& cgroup_contents);
-#endif  // defined(OS_CHROMEOS)
-
-}  // namespace base
-
-#endif  // BASE_PROCESS_PROCESS_H_
diff --git a/native/zucchini/vendor/libchrome/base/process/process_handle.h b/native/zucchini/vendor/libchrome/base/process/process_handle.h
deleted file mode 100644
index f3f6343..0000000
--- a/native/zucchini/vendor/libchrome/base/process/process_handle.h
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_PROCESS_PROCESS_HANDLE_H_
-#define BASE_PROCESS_PROCESS_HANDLE_H_
-
-#include <stdint.h>
-#include <sys/types.h>
-
-#include "base/base_export.h"
-#include "base/files/file_path.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include "base/win/windows_types.h"
-#endif
-
-#if defined(OS_FUCHSIA)
-#include <zircon/types.h>
-#endif
-
-namespace base {
-
-// ProcessHandle is a platform specific type which represents the underlying OS
-// handle to a process.
-// ProcessId is a number which identifies the process in the OS.
-#if defined(OS_WIN)
-typedef HANDLE ProcessHandle;
-typedef DWORD ProcessId;
-typedef HANDLE UserTokenHandle;
-const ProcessHandle kNullProcessHandle = NULL;
-const ProcessId kNullProcessId = 0;
-#elif defined(OS_FUCHSIA)
-typedef zx_handle_t ProcessHandle;
-typedef zx_koid_t ProcessId;
-const ProcessHandle kNullProcessHandle = ZX_HANDLE_INVALID;
-const ProcessId kNullProcessId = ZX_KOID_INVALID;
-#elif defined(OS_POSIX)
-// On POSIX, our ProcessHandle will just be the PID.
-typedef pid_t ProcessHandle;
-typedef pid_t ProcessId;
-const ProcessHandle kNullProcessHandle = 0;
-const ProcessId kNullProcessId = 0;
-#endif  // defined(OS_WIN)
-
-// To print ProcessIds portably use CrPRIdPid (based on PRIuS and friends from
-// C99 and format_macros.h) like this:
-// base::StringPrintf("PID is %" CrPRIdPid ".\n", pid);
-#if defined(OS_WIN) || defined(OS_FUCHSIA)
-#define CrPRIdPid "ld"
-#else
-#define CrPRIdPid "d"
-#endif
-
-// Returns the id of the current process.
-// Note that on some platforms, this is not guaranteed to be unique across
-// processes (use GetUniqueIdForProcess if uniqueness is required).
-BASE_EXPORT ProcessId GetCurrentProcId();
-
-// Returns a unique ID for the current process. The ID will be unique across all
-// currently running processes within the chrome session, but IDs of terminated
-// processes may be reused. This returns an opaque value that is different from
-// a process's PID.
-BASE_EXPORT uint32_t GetUniqueIdForProcess();
-
-#if defined(OS_LINUX)
-// When a process is started in a different PID namespace from the browser
-// process, this function must be called with the process's PID in the browser's
-// PID namespace in order to initialize its unique ID. Not thread safe.
-// WARNING: To avoid inconsistent results from GetUniqueIdForProcess, this
-// should only be called very early after process startup - ideally as soon
-// after process creation as possible.
-BASE_EXPORT void InitUniqueIdForProcessInPidNamespace(
-    ProcessId pid_outside_of_namespace);
-#endif
-
-// Returns the ProcessHandle of the current process.
-BASE_EXPORT ProcessHandle GetCurrentProcessHandle();
-
-// Returns the process ID for the specified process. This is functionally the
-// same as Windows' GetProcessId(), but works on versions of Windows before Win
-// XP SP1 as well.
-// DEPRECATED. New code should be using Process::Pid() instead.
-// Note that on some platforms, this is not guaranteed to be unique across
-// processes.
-BASE_EXPORT ProcessId GetProcId(ProcessHandle process);
-
-#if !defined(OS_FUCHSIA)
-// Returns the ID for the parent of the given process. Not available on Fuchsia.
-// Returning a negative value indicates an error, such as if the |process| does
-// not exist. Returns 0 when |process| has no parent process.
-BASE_EXPORT ProcessId GetParentProcessId(ProcessHandle process);
-#endif  // !defined(OS_FUCHSIA)
-
-#if defined(OS_POSIX)
-// Returns the path to the executable of the given process.
-BASE_EXPORT FilePath GetProcessExecutablePath(ProcessHandle process);
-#endif
-
-}  // namespace base
-
-#endif  // BASE_PROCESS_PROCESS_HANDLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/scoped_clear_errno.h b/native/zucchini/vendor/libchrome/base/scoped_clear_errno.h
deleted file mode 100644
index 585f6f7..0000000
--- a/native/zucchini/vendor/libchrome/base/scoped_clear_errno.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright (c) 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_SCOPED_CLEAR_ERRNO_H_
-#define BASE_SCOPED_CLEAR_ERRNO_H_
-
-#include <errno.h>
-
-#include "base/macros.h"
-
-namespace base {
-
-// Simple scoper that saves the current value of errno, resets it to 0, and on
-// destruction puts the old value back.
-class ScopedClearErrno {
- public:
-  ScopedClearErrno() : old_errno_(errno) {
-    errno = 0;
-  }
-  ~ScopedClearErrno() {
-    if (errno == 0)
-      errno = old_errno_;
-  }
-
- private:
-  const int old_errno_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedClearErrno);
-};
-
-}  // namespace base
-
-#endif  // BASE_SCOPED_CLEAR_ERRNO_H_
diff --git a/native/zucchini/vendor/libchrome/base/scoped_generic.h b/native/zucchini/vendor/libchrome/base/scoped_generic.h
deleted file mode 100644
index 25e6208..0000000
--- a/native/zucchini/vendor/libchrome/base/scoped_generic.h
+++ /dev/null
@@ -1,189 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_SCOPED_GENERIC_H_
-#define BASE_SCOPED_GENERIC_H_
-
-#include <stdlib.h>
-
-#include <algorithm>
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-
-namespace base {
-
-// This class acts like unique_ptr with a custom deleter (although is slightly
-// less fancy in some of the more escoteric respects) except that it keeps a
-// copy of the object rather than a pointer, and we require that the contained
-// object has some kind of "invalid" value.
-//
-// Defining a scoper based on this class allows you to get a scoper for
-// non-pointer types without having to write custom code for set, reset, and
-// move, etc. and get almost identical semantics that people are used to from
-// unique_ptr.
-//
-// It is intended that you will typedef this class with an appropriate deleter
-// to implement clean up tasks for objects that act like pointers from a
-// resource management standpoint but aren't, such as file descriptors and
-// various types of operating system handles. Using unique_ptr for these
-// things requires that you keep a pointer to the handle valid for the lifetime
-// of the scoper (which is easy to mess up).
-//
-// For an object to be able to be put into a ScopedGeneric, it must support
-// standard copyable semantics and have a specific "invalid" value. The traits
-// must define a free function and also the invalid value to assign for
-// default-constructed and released objects.
-//
-//   struct FooScopedTraits {
-//     // It's assumed that this is a fast inline function with little-to-no
-//     // penalty for duplicate calls. This must be a static function even
-//     // for stateful traits.
-//     static int InvalidValue() {
-//       return 0;
-//     }
-//
-//     // This free function will not be called if f == InvalidValue()!
-//     static void Free(int f) {
-//       ::FreeFoo(f);
-//     }
-//   };
-//
-//   typedef ScopedGeneric<int, FooScopedTraits> ScopedFoo;
-template<typename T, typename Traits>
-class ScopedGeneric {
- private:
-  // This must be first since it's used inline below.
-  //
-  // Use the empty base class optimization to allow us to have a D
-  // member, while avoiding any space overhead for it when D is an
-  // empty class.  See e.g. http://www.cantrip.org/emptyopt.html for a good
-  // discussion of this technique.
-  struct Data : public Traits {
-    explicit Data(const T& in) : generic(in) {}
-    Data(const T& in, const Traits& other) : Traits(other), generic(in) {}
-    T generic;
-  };
-
- public:
-  typedef T element_type;
-  typedef Traits traits_type;
-
-  ScopedGeneric() : data_(traits_type::InvalidValue()) {}
-
-  // Constructor. Takes responsibility for freeing the resource associated with
-  // the object T.
-  explicit ScopedGeneric(const element_type& value) : data_(value) {}
-
-  // Constructor. Allows initialization of a stateful traits object.
-  ScopedGeneric(const element_type& value, const traits_type& traits)
-      : data_(value, traits) {
-  }
-
-  // Move constructor. Allows initialization from a ScopedGeneric rvalue.
-  ScopedGeneric(ScopedGeneric<T, Traits>&& rvalue)
-      : data_(rvalue.release(), rvalue.get_traits()) {
-  }
-
-  ~ScopedGeneric() {
-    FreeIfNecessary();
-  }
-
-  // operator=. Allows assignment from a ScopedGeneric rvalue.
-  ScopedGeneric& operator=(ScopedGeneric<T, Traits>&& rvalue) {
-    reset(rvalue.release());
-    return *this;
-  }
-
-  // Frees the currently owned object, if any. Then takes ownership of a new
-  // object, if given. Self-resets are not allowd as on unique_ptr. See
-  // http://crbug.com/162971
-  void reset(const element_type& value = traits_type::InvalidValue()) {
-    if (data_.generic != traits_type::InvalidValue() && data_.generic == value)
-      abort();
-    FreeIfNecessary();
-    data_.generic = value;
-  }
-
-  void swap(ScopedGeneric& other) {
-    // Standard swap idiom: 'using std::swap' ensures that std::swap is
-    // present in the overload set, but we call swap unqualified so that
-    // any more-specific overloads can be used, if available.
-    using std::swap;
-    swap(static_cast<Traits&>(data_), static_cast<Traits&>(other.data_));
-    swap(data_.generic, other.data_.generic);
-  }
-
-  // Release the object. The return value is the current object held by this
-  // object. After this operation, this object will hold a null value, and
-  // will not own the object any more.
-  element_type release() WARN_UNUSED_RESULT {
-    element_type old_generic = data_.generic;
-    data_.generic = traits_type::InvalidValue();
-    return old_generic;
-  }
-
-  // Returns a raw pointer to the object storage, to allow the scoper to be used
-  // to receive and manage out-parameter values. Implies reset().
-  element_type* receive() WARN_UNUSED_RESULT {
-    reset();
-    return &data_.generic;
-  }
-
-  const element_type& get() const { return data_.generic; }
-
-  // Returns true if this object doesn't hold the special null value for the
-  // associated data type.
-  bool is_valid() const { return data_.generic != traits_type::InvalidValue(); }
-
-  bool operator==(const element_type& value) const {
-    return data_.generic == value;
-  }
-  bool operator!=(const element_type& value) const {
-    return data_.generic != value;
-  }
-
-  Traits& get_traits() { return data_; }
-  const Traits& get_traits() const { return data_; }
-
- private:
-  void FreeIfNecessary() {
-    if (data_.generic != traits_type::InvalidValue()) {
-      data_.Free(data_.generic);
-      data_.generic = traits_type::InvalidValue();
-    }
-  }
-
-  // Forbid comparison. If U != T, it totally doesn't make sense, and if U ==
-  // T, it still doesn't make sense because you should never have the same
-  // object owned by two different ScopedGenerics.
-  template <typename T2, typename Traits2> bool operator==(
-      const ScopedGeneric<T2, Traits2>& p2) const;
-  template <typename T2, typename Traits2> bool operator!=(
-      const ScopedGeneric<T2, Traits2>& p2) const;
-
-  Data data_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedGeneric);
-};
-
-template<class T, class Traits>
-void swap(const ScopedGeneric<T, Traits>& a,
-          const ScopedGeneric<T, Traits>& b) {
-  a.swap(b);
-}
-
-template<class T, class Traits>
-bool operator==(const T& value, const ScopedGeneric<T, Traits>& scoped) {
-  return value == scoped.get();
-}
-
-template<class T, class Traits>
-bool operator!=(const T& value, const ScopedGeneric<T, Traits>& scoped) {
-  return value != scoped.get();
-}
-
-}  // namespace base
-
-#endif  // BASE_SCOPED_GENERIC_H_
diff --git a/native/zucchini/vendor/libchrome/base/sequence_checker.h b/native/zucchini/vendor/libchrome/base/sequence_checker.h
deleted file mode 100644
index 48b593b..0000000
--- a/native/zucchini/vendor/libchrome/base/sequence_checker.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_SEQUENCE_CHECKER_H_
-#define BASE_SEQUENCE_CHECKER_H_
-
-#include "base/compiler_specific.h"
-#include "base/logging.h"
-#include "base/sequence_checker_impl.h"
-
-// SequenceChecker is a helper class used to help verify that some methods of a
-// class are called sequentially (for thread-safety).
-//
-// Use the macros below instead of the SequenceChecker directly so that the
-// unused member doesn't result in an extra byte (four when padded) per
-// instance in production.
-//
-// This class is much prefered to ThreadChecker for thread-safety checks.
-// ThreadChecker should only be used for classes that are truly thread-affine
-// (use thread-local-storage or a third-party API that does).
-//
-// Usage:
-//   class MyClass {
-//    public:
-//     MyClass() {
-//       // It's sometimes useful to detach on construction for objects that are
-//       // constructed in one place and forever after used from another
-//       // sequence.
-//       DETACH_FROM_SEQUENCE(my_sequence_checker_);
-//     }
-//
-//     ~MyClass() {
-//       // SequenceChecker doesn't automatically check it's destroyed on origin
-//       // sequence for the same reason it's sometimes detached in the
-//       // constructor. It's okay to destroy off sequence if the owner
-//       // otherwise knows usage on the associated sequence is done. If you're
-//       // not detaching in the constructor, you probably want to explicitly
-//       // check in the destructor.
-//       DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker_);
-//     }
-//     void MyMethod() {
-//       DCHECK_CALLED_ON_VALID_SEQUENCE(my_sequence_checker_);
-//       ... (do stuff) ...
-//     }
-//
-//    private:
-//     SEQUENCE_CHECKER(my_sequence_checker_);
-//   }
-
-#if DCHECK_IS_ON()
-#define SEQUENCE_CHECKER(name) base::SequenceChecker name
-#define DCHECK_CALLED_ON_VALID_SEQUENCE(name) \
-  DCHECK((name).CalledOnValidSequence())
-#define DETACH_FROM_SEQUENCE(name) (name).DetachFromSequence()
-#else  // DCHECK_IS_ON()
-#define SEQUENCE_CHECKER(name)
-#define DCHECK_CALLED_ON_VALID_SEQUENCE(name) EAT_STREAM_PARAMETERS
-#define DETACH_FROM_SEQUENCE(name)
-#endif  // DCHECK_IS_ON()
-
-namespace base {
-
-// Do nothing implementation, for use in release mode.
-//
-// Note: You should almost always use the SequenceChecker class (through the
-// above macros) to get the right version for your build configuration.
-class SequenceCheckerDoNothing {
- public:
-  SequenceCheckerDoNothing() = default;
-  bool CalledOnValidSequence() const WARN_UNUSED_RESULT { return true; }
-  void DetachFromSequence() {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(SequenceCheckerDoNothing);
-};
-
-#if DCHECK_IS_ON()
-class SequenceChecker : public SequenceCheckerImpl {
-};
-#else
-class SequenceChecker : public SequenceCheckerDoNothing {
-};
-#endif  // DCHECK_IS_ON()
-
-}  // namespace base
-
-#endif  // BASE_SEQUENCE_CHECKER_H_
diff --git a/native/zucchini/vendor/libchrome/base/sequence_checker_impl.h b/native/zucchini/vendor/libchrome/base/sequence_checker_impl.h
deleted file mode 100644
index a54c388..0000000
--- a/native/zucchini/vendor/libchrome/base/sequence_checker_impl.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_SEQUENCE_CHECKER_IMPL_H_
-#define BASE_SEQUENCE_CHECKER_IMPL_H_
-
-#include <memory>
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/synchronization/lock.h"
-
-namespace base {
-
-// Real implementation of SequenceChecker for use in debug mode or for temporary
-// use in release mode (e.g. to CHECK on a threading issue seen only in the
-// wild).
-//
-// Note: You should almost always use the SequenceChecker class to get the right
-// version for your build configuration.
-class BASE_EXPORT SequenceCheckerImpl {
- public:
-  SequenceCheckerImpl();
-  ~SequenceCheckerImpl();
-
-  // Returns true if called in sequence with previous calls to this method and
-  // the constructor.
-  bool CalledOnValidSequence() const WARN_UNUSED_RESULT;
-
-  // Unbinds the checker from the currently associated sequence. The checker
-  // will be re-bound on the next call to CalledOnValidSequence().
-  void DetachFromSequence();
-
- private:
-  class Core;
-
-  // Guards all variables below.
-  mutable Lock lock_;
-  mutable std::unique_ptr<Core> core_;
-
-  DISALLOW_COPY_AND_ASSIGN(SequenceCheckerImpl);
-};
-
-}  // namespace base
-
-#endif  // BASE_SEQUENCE_CHECKER_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/sequenced_task_runner.h b/native/zucchini/vendor/libchrome/base/sequenced_task_runner.h
deleted file mode 100644
index 53d21ad..0000000
--- a/native/zucchini/vendor/libchrome/base/sequenced_task_runner.h
+++ /dev/null
@@ -1,176 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_SEQUENCED_TASK_RUNNER_H_
-#define BASE_SEQUENCED_TASK_RUNNER_H_
-
-#include <memory>
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/sequenced_task_runner_helpers.h"
-#include "base/task_runner.h"
-
-namespace base {
-
-// A SequencedTaskRunner is a subclass of TaskRunner that provides
-// additional guarantees on the order that tasks are started, as well
-// as guarantees on when tasks are in sequence, i.e. one task finishes
-// before the other one starts.
-//
-// Summary
-// -------
-// Non-nested tasks with the same delay will run one by one in FIFO
-// order.
-//
-// Detailed guarantees
-// -------------------
-//
-// SequencedTaskRunner also adds additional methods for posting
-// non-nestable tasks.  In general, an implementation of TaskRunner
-// may expose task-running methods which are themselves callable from
-// within tasks.  A non-nestable task is one that is guaranteed to not
-// be run from within an already-running task.  Conversely, a nestable
-// task (the default) is a task that can be run from within an
-// already-running task.
-//
-// The guarantees of SequencedTaskRunner are as follows:
-//
-//   - Given two tasks T2 and T1, T2 will start after T1 starts if:
-//
-//       * T2 is posted after T1; and
-//       * T2 has equal or higher delay than T1; and
-//       * T2 is non-nestable or T1 is nestable.
-//
-//   - If T2 will start after T1 starts by the above guarantee, then
-//     T2 will start after T1 finishes and is destroyed if:
-//
-//       * T2 is non-nestable, or
-//       * T1 doesn't call any task-running methods.
-//
-//   - If T2 will start after T1 finishes by the above guarantee, then
-//     all memory changes in T1 and T1's destruction will be visible
-//     to T2.
-//
-//   - If T2 runs nested within T1 via a call to the task-running
-//     method M, then all memory changes in T1 up to the call to M
-//     will be visible to T2, and all memory changes in T2 will be
-//     visible to T1 from the return from M.
-//
-// Note that SequencedTaskRunner does not guarantee that tasks are run
-// on a single dedicated thread, although the above guarantees provide
-// most (but not all) of the same guarantees.  If you do need to
-// guarantee that tasks are run on a single dedicated thread, see
-// SingleThreadTaskRunner (in single_thread_task_runner.h).
-//
-// Some corollaries to the above guarantees, assuming the tasks in
-// question don't call any task-running methods:
-//
-//   - Tasks posted via PostTask are run in FIFO order.
-//
-//   - Tasks posted via PostNonNestableTask are run in FIFO order.
-//
-//   - Tasks posted with the same delay and the same nestable state
-//     are run in FIFO order.
-//
-//   - A list of tasks with the same nestable state posted in order of
-//     non-decreasing delay is run in FIFO order.
-//
-//   - A list of tasks posted in order of non-decreasing delay with at
-//     most a single change in nestable state from nestable to
-//     non-nestable is run in FIFO order. (This is equivalent to the
-//     statement of the first guarantee above.)
-//
-// Some theoretical implementations of SequencedTaskRunner:
-//
-//   - A SequencedTaskRunner that wraps a regular TaskRunner but makes
-//     sure that only one task at a time is posted to the TaskRunner,
-//     with appropriate memory barriers in between tasks.
-//
-//   - A SequencedTaskRunner that, for each task, spawns a joinable
-//     thread to run that task and immediately quit, and then
-//     immediately joins that thread.
-//
-//   - A SequencedTaskRunner that stores the list of posted tasks and
-//     has a method Run() that runs each runnable task in FIFO order
-//     that can be called from any thread, but only if another
-//     (non-nested) Run() call isn't already happening.
-class BASE_EXPORT SequencedTaskRunner : public TaskRunner {
- public:
-  // The two PostNonNestable*Task methods below are like their
-  // nestable equivalents in TaskRunner, but they guarantee that the
-  // posted task will not run nested within an already-running task.
-  //
-  // A simple corollary is that posting a task as non-nestable can
-  // only delay when the task gets run.  That is, posting a task as
-  // non-nestable may not affect when the task gets run, or it could
-  // make it run later than it normally would, but it won't make it
-  // run earlier than it normally would.
-
-  // TODO(akalin): Get rid of the boolean return value for the methods
-  // below.
-
-  bool PostNonNestableTask(const Location& from_here, OnceClosure task);
-
-  virtual bool PostNonNestableDelayedTask(const Location& from_here,
-                                          OnceClosure task,
-                                          base::TimeDelta delay) = 0;
-
-  // Submits a non-nestable task to delete the given object.  Returns
-  // true if the object may be deleted at some point in the future,
-  // and false if the object definitely will not be deleted.
-  template <class T>
-  bool DeleteSoon(const Location& from_here, const T* object) {
-    return DeleteOrReleaseSoonInternal(from_here, &DeleteHelper<T>::DoDelete,
-                                       object);
-  }
-
-  template <class T>
-  bool DeleteSoon(const Location& from_here, std::unique_ptr<T> object) {
-    return DeleteSoon(from_here, object.release());
-  }
-
-  // Submits a non-nestable task to release the given object.  Returns
-  // true if the object may be released at some point in the future,
-  // and false if the object definitely will not be released.
-  template <class T>
-  bool ReleaseSoon(const Location& from_here, const T* object) {
-    return DeleteOrReleaseSoonInternal(from_here, &ReleaseHelper<T>::DoRelease,
-                                       object);
-  }
-
- protected:
-  ~SequencedTaskRunner() override = default;
-
- private:
-  bool DeleteOrReleaseSoonInternal(const Location& from_here,
-                                   void (*deleter)(const void*),
-                                   const void* object);
-};
-
-// Sample usage with std::unique_ptr :
-// std::unique_ptr<Foo, base::OnTaskRunnerDeleter> ptr(
-//     new Foo, base::OnTaskRunnerDeleter(my_task_runner));
-//
-// For RefCounted see base::RefCountedDeleteOnSequence.
-struct BASE_EXPORT OnTaskRunnerDeleter {
-  explicit OnTaskRunnerDeleter(scoped_refptr<SequencedTaskRunner> task_runner);
-  ~OnTaskRunnerDeleter();
-
-  OnTaskRunnerDeleter(OnTaskRunnerDeleter&&);
-  OnTaskRunnerDeleter& operator=(OnTaskRunnerDeleter&&);
-
-  // For compatibility with std:: deleters.
-  template <typename T>
-  void operator()(const T* ptr) {
-    if (ptr)
-      task_runner_->DeleteSoon(FROM_HERE, ptr);
-  }
-
-  scoped_refptr<SequencedTaskRunner> task_runner_;
-};
-
-}  // namespace base
-
-#endif  // BASE_SEQUENCED_TASK_RUNNER_H_
diff --git a/native/zucchini/vendor/libchrome/base/sequenced_task_runner_helpers.h b/native/zucchini/vendor/libchrome/base/sequenced_task_runner_helpers.h
deleted file mode 100644
index 18ec0e2..0000000
--- a/native/zucchini/vendor/libchrome/base/sequenced_task_runner_helpers.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_SEQUENCED_TASK_RUNNER_HELPERS_H_
-#define BASE_SEQUENCED_TASK_RUNNER_HELPERS_H_
-
-namespace base {
-
-class SequencedTaskRunner;
-
-// Template helpers which use function indirection to erase T from the
-// function signature while still remembering it so we can call the
-// correct destructor/release function.
-//
-// We use this trick so we don't need to include bind.h in a header
-// file like sequenced_task_runner.h. We also wrap the helpers in a
-// templated class to make it easier for users of DeleteSoon to
-// declare the helper as a friend.
-template <class T>
-class DeleteHelper {
- private:
-  static void DoDelete(const void* object) {
-    delete static_cast<const T*>(object);
-  }
-
-  friend class SequencedTaskRunner;
-};
-
-template <class T>
-class ReleaseHelper {
- private:
-  static void DoRelease(const void* object) {
-    static_cast<const T*>(object)->Release();
-  }
-
-  friend class SequencedTaskRunner;
-};
-
-}  // namespace base
-
-#endif  // BASE_SEQUENCED_TASK_RUNNER_HELPERS_H_
diff --git a/native/zucchini/vendor/libchrome/base/single_thread_task_runner.h b/native/zucchini/vendor/libchrome/base/single_thread_task_runner.h
deleted file mode 100644
index 4d6938e..0000000
--- a/native/zucchini/vendor/libchrome/base/single_thread_task_runner.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_SINGLE_THREAD_TASK_RUNNER_H_
-#define BASE_SINGLE_THREAD_TASK_RUNNER_H_
-
-#include "base/base_export.h"
-#include "base/sequenced_task_runner.h"
-
-namespace base {
-
-// A SingleThreadTaskRunner is a SequencedTaskRunner with one more
-// guarantee; namely, that all tasks are run on a single dedicated
-// thread.  Most use cases require only a SequencedTaskRunner, unless
-// there is a specific need to run tasks on only a single thread.
-//
-// SingleThreadTaskRunner implementations might:
-//   - Post tasks to an existing thread's MessageLoop (see
-//     MessageLoop::task_runner()).
-//   - Create their own worker thread and MessageLoop to post tasks to.
-//   - Add tasks to a FIFO and signal to a non-MessageLoop thread for them to
-//     be processed. This allows TaskRunner-oriented code run on threads
-//     running other kinds of message loop, e.g. Jingle threads.
-class BASE_EXPORT SingleThreadTaskRunner : public SequencedTaskRunner {
- public:
-  // A more explicit alias to RunsTasksInCurrentSequence().
-  bool BelongsToCurrentThread() const { return RunsTasksInCurrentSequence(); }
-
- protected:
-  ~SingleThreadTaskRunner() override = default;
-};
-
-}  // namespace base
-
-#endif  // BASE_SINGLE_THREAD_TASK_RUNNER_H_
diff --git a/native/zucchini/vendor/libchrome/base/stl_util.h b/native/zucchini/vendor/libchrome/base/stl_util.h
deleted file mode 100644
index 6d521cc..0000000
--- a/native/zucchini/vendor/libchrome/base/stl_util.h
+++ /dev/null
@@ -1,410 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Derived from google3/util/gtl/stl_util.h
-
-#ifndef BASE_STL_UTIL_H_
-#define BASE_STL_UTIL_H_
-
-#include <algorithm>
-#include <deque>
-#include <forward_list>
-#include <functional>
-#include <initializer_list>
-#include <iterator>
-#include <list>
-#include <map>
-#include <set>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include "base/logging.h"
-#include "base/optional.h"
-
-namespace base {
-
-namespace internal {
-
-// Calls erase on iterators of matching elements.
-template <typename Container, typename Predicate>
-void IterateAndEraseIf(Container& container, Predicate pred) {
-  for (auto it = container.begin(); it != container.end();) {
-    if (pred(*it))
-      it = container.erase(it);
-    else
-      ++it;
-  }
-}
-
-}  // namespace internal
-
-// C++14 implementation of C++17's std::size():
-// http://en.cppreference.com/w/cpp/iterator/size
-template <typename Container>
-constexpr auto size(const Container& c) -> decltype(c.size()) {
-  return c.size();
-}
-
-template <typename T, size_t N>
-constexpr size_t size(const T (&array)[N]) noexcept {
-  return N;
-}
-
-// C++14 implementation of C++17's std::empty():
-// http://en.cppreference.com/w/cpp/iterator/empty
-template <typename Container>
-constexpr auto empty(const Container& c) -> decltype(c.empty()) {
-  return c.empty();
-}
-
-template <typename T, size_t N>
-constexpr bool empty(const T (&array)[N]) noexcept {
-  return false;
-}
-
-template <typename T>
-constexpr bool empty(std::initializer_list<T> il) noexcept {
-  return il.size() == 0;
-}
-
-// C++14 implementation of C++17's std::data():
-// http://en.cppreference.com/w/cpp/iterator/data
-template <typename Container>
-constexpr auto data(Container& c) -> decltype(c.data()) {
-  return c.data();
-}
-
-// std::basic_string::data() had no mutable overload prior to C++17 [1].
-// Hence this overload is provided.
-// Note: str[0] is safe even for empty strings, as they are guaranteed to be
-// null-terminated [2].
-//
-// [1] http://en.cppreference.com/w/cpp/string/basic_string/data
-// [2] http://en.cppreference.com/w/cpp/string/basic_string/operator_at
-template <typename CharT, typename Traits, typename Allocator>
-CharT* data(std::basic_string<CharT, Traits, Allocator>& str) {
-  return std::addressof(str[0]);
-}
-
-template <typename Container>
-constexpr auto data(const Container& c) -> decltype(c.data()) {
-  return c.data();
-}
-
-template <typename T, size_t N>
-constexpr T* data(T (&array)[N]) noexcept {
-  return array;
-}
-
-template <typename T>
-constexpr const T* data(std::initializer_list<T> il) noexcept {
-  return il.begin();
-}
-
-// Returns a const reference to the underlying container of a container adapter.
-// Works for std::priority_queue, std::queue, and std::stack.
-template <class A>
-const typename A::container_type& GetUnderlyingContainer(const A& adapter) {
-  struct ExposedAdapter : A {
-    using A::c;
-  };
-  return adapter.*&ExposedAdapter::c;
-}
-
-// Clears internal memory of an STL object.
-// STL clear()/reserve(0) does not always free internal memory allocated
-// This function uses swap/destructor to ensure the internal memory is freed.
-template<class T>
-void STLClearObject(T* obj) {
-  T tmp;
-  tmp.swap(*obj);
-  // Sometimes "T tmp" allocates objects with memory (arena implementation?).
-  // Hence using additional reserve(0) even if it doesn't always work.
-  obj->reserve(0);
-}
-
-// Counts the number of instances of val in a container.
-template <typename Container, typename T>
-typename std::iterator_traits<
-    typename Container::const_iterator>::difference_type
-STLCount(const Container& container, const T& val) {
-  return std::count(container.begin(), container.end(), val);
-}
-
-// Test to see if a set or map contains a particular key.
-// Returns true if the key is in the collection.
-template <typename Collection, typename Key>
-bool ContainsKey(const Collection& collection, const Key& key) {
-  return collection.find(key) != collection.end();
-}
-
-namespace internal {
-
-template <typename Collection>
-class HasKeyType {
-  template <typename C>
-  static std::true_type test(typename C::key_type*);
-  template <typename C>
-  static std::false_type test(...);
-
- public:
-  static constexpr bool value = decltype(test<Collection>(nullptr))::value;
-};
-
-}  // namespace internal
-
-// Test to see if a collection like a vector contains a particular value.
-// Returns true if the value is in the collection.
-// Don't use this on collections such as sets or maps. This is enforced by
-// disabling this method if the collection defines a key_type.
-template <typename Collection,
-          typename Value,
-          typename std::enable_if<!internal::HasKeyType<Collection>::value,
-                                  int>::type = 0>
-bool ContainsValue(const Collection& collection, const Value& value) {
-  return std::find(std::begin(collection), std::end(collection), value) !=
-         std::end(collection);
-}
-
-// Returns true if the container is sorted.
-template <typename Container>
-bool STLIsSorted(const Container& cont) {
-  // Note: Use reverse iterator on container to ensure we only require
-  // value_type to implement operator<.
-  return std::adjacent_find(cont.rbegin(), cont.rend(),
-                            std::less<typename Container::value_type>())
-      == cont.rend();
-}
-
-// Returns a new ResultType containing the difference of two sorted containers.
-template <typename ResultType, typename Arg1, typename Arg2>
-ResultType STLSetDifference(const Arg1& a1, const Arg2& a2) {
-  DCHECK(STLIsSorted(a1));
-  DCHECK(STLIsSorted(a2));
-  ResultType difference;
-  std::set_difference(a1.begin(), a1.end(),
-                      a2.begin(), a2.end(),
-                      std::inserter(difference, difference.end()));
-  return difference;
-}
-
-// Returns a new ResultType containing the union of two sorted containers.
-template <typename ResultType, typename Arg1, typename Arg2>
-ResultType STLSetUnion(const Arg1& a1, const Arg2& a2) {
-  DCHECK(STLIsSorted(a1));
-  DCHECK(STLIsSorted(a2));
-  ResultType result;
-  std::set_union(a1.begin(), a1.end(),
-                 a2.begin(), a2.end(),
-                 std::inserter(result, result.end()));
-  return result;
-}
-
-// Returns a new ResultType containing the intersection of two sorted
-// containers.
-template <typename ResultType, typename Arg1, typename Arg2>
-ResultType STLSetIntersection(const Arg1& a1, const Arg2& a2) {
-  DCHECK(STLIsSorted(a1));
-  DCHECK(STLIsSorted(a2));
-  ResultType result;
-  std::set_intersection(a1.begin(), a1.end(),
-                        a2.begin(), a2.end(),
-                        std::inserter(result, result.end()));
-  return result;
-}
-
-// Returns true if the sorted container |a1| contains all elements of the sorted
-// container |a2|.
-template <typename Arg1, typename Arg2>
-bool STLIncludes(const Arg1& a1, const Arg2& a2) {
-  DCHECK(STLIsSorted(a1));
-  DCHECK(STLIsSorted(a2));
-  return std::includes(a1.begin(), a1.end(),
-                       a2.begin(), a2.end());
-}
-
-// Erase/EraseIf are based on library fundamentals ts v2 erase/erase_if
-// http://en.cppreference.com/w/cpp/experimental/lib_extensions_2
-// They provide a generic way to erase elements from a container.
-// The functions here implement these for the standard containers until those
-// functions are available in the C++ standard.
-// For Chromium containers overloads should be defined in their own headers
-// (like standard containers).
-// Note: there is no std::erase for standard associative containers so we don't
-// have it either.
-
-template <typename CharT, typename Traits, typename Allocator, typename Value>
-void Erase(std::basic_string<CharT, Traits, Allocator>& container,
-           const Value& value) {
-  container.erase(std::remove(container.begin(), container.end(), value),
-                  container.end());
-}
-
-template <typename CharT, typename Traits, typename Allocator, class Predicate>
-void EraseIf(std::basic_string<CharT, Traits, Allocator>& container,
-             Predicate pred) {
-  container.erase(std::remove_if(container.begin(), container.end(), pred),
-                  container.end());
-}
-
-template <class T, class Allocator, class Value>
-void Erase(std::deque<T, Allocator>& container, const Value& value) {
-  container.erase(std::remove(container.begin(), container.end(), value),
-                  container.end());
-}
-
-template <class T, class Allocator, class Predicate>
-void EraseIf(std::deque<T, Allocator>& container, Predicate pred) {
-  container.erase(std::remove_if(container.begin(), container.end(), pred),
-                  container.end());
-}
-
-template <class T, class Allocator, class Value>
-void Erase(std::vector<T, Allocator>& container, const Value& value) {
-  container.erase(std::remove(container.begin(), container.end(), value),
-                  container.end());
-}
-
-template <class T, class Allocator, class Predicate>
-void EraseIf(std::vector<T, Allocator>& container, Predicate pred) {
-  container.erase(std::remove_if(container.begin(), container.end(), pred),
-                  container.end());
-}
-
-template <class T, class Allocator, class Value>
-void Erase(std::forward_list<T, Allocator>& container, const Value& value) {
-  // Unlike std::forward_list::remove, this function template accepts
-  // heterogeneous types and does not force a conversion to the container's
-  // value type before invoking the == operator.
-  container.remove_if([&](const T& cur) { return cur == value; });
-}
-
-template <class T, class Allocator, class Predicate>
-void EraseIf(std::forward_list<T, Allocator>& container, Predicate pred) {
-  container.remove_if(pred);
-}
-
-template <class T, class Allocator, class Value>
-void Erase(std::list<T, Allocator>& container, const Value& value) {
-  // Unlike std::list::remove, this function template accepts heterogeneous
-  // types and does not force a conversion to the container's value type before
-  // invoking the == operator.
-  container.remove_if([&](const T& cur) { return cur == value; });
-}
-
-template <class T, class Allocator, class Predicate>
-void EraseIf(std::list<T, Allocator>& container, Predicate pred) {
-  container.remove_if(pred);
-}
-
-template <class Key, class T, class Compare, class Allocator, class Predicate>
-void EraseIf(std::map<Key, T, Compare, Allocator>& container, Predicate pred) {
-  internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key, class T, class Compare, class Allocator, class Predicate>
-void EraseIf(std::multimap<Key, T, Compare, Allocator>& container,
-             Predicate pred) {
-  internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key, class Compare, class Allocator, class Predicate>
-void EraseIf(std::set<Key, Compare, Allocator>& container, Predicate pred) {
-  internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key, class Compare, class Allocator, class Predicate>
-void EraseIf(std::multiset<Key, Compare, Allocator>& container,
-             Predicate pred) {
-  internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key,
-          class T,
-          class Hash,
-          class KeyEqual,
-          class Allocator,
-          class Predicate>
-void EraseIf(std::unordered_map<Key, T, Hash, KeyEqual, Allocator>& container,
-             Predicate pred) {
-  internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key,
-          class T,
-          class Hash,
-          class KeyEqual,
-          class Allocator,
-          class Predicate>
-void EraseIf(
-    std::unordered_multimap<Key, T, Hash, KeyEqual, Allocator>& container,
-    Predicate pred) {
-  internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key,
-          class Hash,
-          class KeyEqual,
-          class Allocator,
-          class Predicate>
-void EraseIf(std::unordered_set<Key, Hash, KeyEqual, Allocator>& container,
-             Predicate pred) {
-  internal::IterateAndEraseIf(container, pred);
-}
-
-template <class Key,
-          class Hash,
-          class KeyEqual,
-          class Allocator,
-          class Predicate>
-void EraseIf(std::unordered_multiset<Key, Hash, KeyEqual, Allocator>& container,
-             Predicate pred) {
-  internal::IterateAndEraseIf(container, pred);
-}
-
-// A helper class to be used as the predicate with |EraseIf| to implement
-// in-place set intersection. Helps implement the algorithm of going through
-// each container an element at a time, erasing elements from the first
-// container if they aren't in the second container. Requires each container be
-// sorted. Note that the logic below appears inverted since it is returning
-// whether an element should be erased.
-template <class Collection>
-class IsNotIn {
- public:
-  explicit IsNotIn(const Collection& collection)
-      : i_(collection.begin()), end_(collection.end()) {}
-
-  bool operator()(const typename Collection::value_type& x) {
-    while (i_ != end_ && *i_ < x)
-      ++i_;
-    if (i_ == end_)
-      return true;
-    if (*i_ == x) {
-      ++i_;
-      return false;
-    }
-    return true;
-  }
-
- private:
-  typename Collection::const_iterator i_;
-  const typename Collection::const_iterator end_;
-};
-
-// Helper for returning the optional value's address, or nullptr.
-template <class T>
-T* OptionalOrNullptr(base::Optional<T>& optional) {
-  return optional.has_value() ? &optional.value() : nullptr;
-}
-
-template <class T>
-const T* OptionalOrNullptr(const base::Optional<T>& optional) {
-  return optional.has_value() ? &optional.value() : nullptr;
-}
-
-}  // namespace base
-
-#endif  // BASE_STL_UTIL_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/char_traits.h b/native/zucchini/vendor/libchrome/base/strings/char_traits.h
deleted file mode 100644
index b193e21..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/char_traits.h
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_CHAR_TRAITS_H_
-#define BASE_STRINGS_CHAR_TRAITS_H_
-
-#include <stddef.h>
-
-#include "base/compiler_specific.h"
-
-namespace base {
-
-// constexpr version of http://en.cppreference.com/w/cpp/string/char_traits.
-// This currently just implements the bits needed to support a (mostly)
-// constexpr StringPiece.
-//
-// TODO(dcheng): Once we switch to C++17, most methods will become constexpr and
-// we can switch over to using the one in the standard library.
-template <typename T>
-struct CharTraits {
-  // Performs a lexographical comparison of the first N characters of |s1| and
-  // |s2|. Returns 0 if equal, -1 if |s1| is less than |s2|, and 1 if |s1| is
-  // greater than |s2|.
-  static constexpr int compare(const T* s1, const T* s2, size_t n) noexcept;
-
-  // Returns the length of |s|, assuming null termination (and not including the
-  // terminating null).
-  static constexpr size_t length(const T* s) noexcept;
-};
-
-template <typename T>
-constexpr int CharTraits<T>::compare(const T* s1,
-                                     const T* s2,
-                                     size_t n) noexcept {
-  for (; n; --n, ++s1, ++s2) {
-    if (*s1 < *s2)
-      return -1;
-    if (*s1 > *s2)
-      return 1;
-  }
-  return 0;
-}
-
-template <typename T>
-constexpr size_t CharTraits<T>::length(const T* s) noexcept {
-  size_t i = 0;
-  for (; *s; ++s)
-    ++i;
-  return i;
-}
-
-// char specialization of CharTraits that can use clang's constexpr instrinsics,
-// where available.
-template <>
-struct CharTraits<char> {
-  static constexpr int compare(const char* s1,
-                               const char* s2,
-                               size_t n) noexcept;
-  static constexpr size_t length(const char* s) noexcept;
-};
-
-constexpr int CharTraits<char>::compare(const char* s1,
-                                        const char* s2,
-                                        size_t n) noexcept {
-#if HAS_FEATURE(cxx_constexpr_string_builtins)
-  return __builtin_memcmp(s1, s2, n);
-#else
-  for (; n; --n, ++s1, ++s2) {
-    if (*s1 < *s2)
-      return -1;
-    if (*s1 > *s2)
-      return 1;
-  }
-  return 0;
-#endif
-}
-
-constexpr size_t CharTraits<char>::length(const char* s) noexcept {
-#if defined(__clang__)
-  return __builtin_strlen(s);
-#else
-  size_t i = 0;
-  for (; *s; ++s)
-    ++i;
-  return i;
-#endif
-}
-
-}  // namespace base
-
-#endif  // BASE_STRINGS_CHAR_TRAITS_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/string16.h b/native/zucchini/vendor/libchrome/base/strings/string16.h
deleted file mode 100644
index a86baa2..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/string16.h
+++ /dev/null
@@ -1,219 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_STRING16_H_
-#define BASE_STRINGS_STRING16_H_
-
-// WHAT:
-// A version of std::basic_string that provides 2-byte characters even when
-// wchar_t is not implemented as a 2-byte type. You can access this class as
-// string16. We also define char16, which string16 is based upon.
-//
-// WHY:
-// On Windows, wchar_t is 2 bytes, and it can conveniently handle UTF-16/UCS-2
-// data. Plenty of existing code operates on strings encoded as UTF-16.
-//
-// On many other platforms, sizeof(wchar_t) is 4 bytes by default. We can make
-// it 2 bytes by using the GCC flag -fshort-wchar. But then std::wstring fails
-// at run time, because it calls some functions (like wcslen) that come from
-// the system's native C library -- which was built with a 4-byte wchar_t!
-// It's wasteful to use 4-byte wchar_t strings to carry UTF-16 data, and it's
-// entirely improper on those systems where the encoding of wchar_t is defined
-// as UTF-32.
-//
-// Here, we define string16, which is similar to std::wstring but replaces all
-// libc functions with custom, 2-byte-char compatible routines. It is capable
-// of carrying UTF-16-encoded data.
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#include <functional>
-#include <string>
-
-#include "base/base_export.h"
-#include "build/build_config.h"
-
-#if defined(WCHAR_T_IS_UTF16)
-
-namespace base {
-
-typedef wchar_t char16;
-typedef std::wstring string16;
-
-}  // namespace base
-
-#elif defined(WCHAR_T_IS_UTF32)
-
-#include <wchar.h>  // for mbstate_t
-
-namespace base {
-
-typedef uint16_t char16;
-
-// char16 versions of the functions required by string16_char_traits; these
-// are based on the wide character functions of similar names ("w" or "wcs"
-// instead of "c16").
-BASE_EXPORT int c16memcmp(const char16* s1, const char16* s2, size_t n);
-BASE_EXPORT size_t c16len(const char16* s);
-BASE_EXPORT const char16* c16memchr(const char16* s, char16 c, size_t n);
-BASE_EXPORT char16* c16memmove(char16* s1, const char16* s2, size_t n);
-BASE_EXPORT char16* c16memcpy(char16* s1, const char16* s2, size_t n);
-BASE_EXPORT char16* c16memset(char16* s, char16 c, size_t n);
-
-// This namespace contains the implementation of base::string16 along with
-// things that need to be found via argument-dependent lookup from a
-// base::string16.
-namespace string16_internals {
-
-struct string16_char_traits {
-  typedef char16 char_type;
-  typedef int int_type;
-
-  // int_type needs to be able to hold each possible value of char_type, and in
-  // addition, the distinct value of eof().
-  static_assert(sizeof(int_type) > sizeof(char_type),
-                "int must be larger than 16 bits wide");
-
-  typedef std::streamoff off_type;
-  typedef mbstate_t state_type;
-  typedef std::fpos<state_type> pos_type;
-
-  static void assign(char_type& c1, const char_type& c2) {
-    c1 = c2;
-  }
-
-  static bool eq(const char_type& c1, const char_type& c2) {
-    return c1 == c2;
-  }
-  static bool lt(const char_type& c1, const char_type& c2) {
-    return c1 < c2;
-  }
-
-  static int compare(const char_type* s1, const char_type* s2, size_t n) {
-    return c16memcmp(s1, s2, n);
-  }
-
-  static size_t length(const char_type* s) {
-    return c16len(s);
-  }
-
-  static const char_type* find(const char_type* s, size_t n,
-                               const char_type& a) {
-    return c16memchr(s, a, n);
-  }
-
-  static char_type* move(char_type* s1, const char_type* s2, size_t n) {
-    return c16memmove(s1, s2, n);
-  }
-
-  static char_type* copy(char_type* s1, const char_type* s2, size_t n) {
-    return c16memcpy(s1, s2, n);
-  }
-
-  static char_type* assign(char_type* s, size_t n, char_type a) {
-    return c16memset(s, a, n);
-  }
-
-  static int_type not_eof(const int_type& c) {
-    return eq_int_type(c, eof()) ? 0 : c;
-  }
-
-  static char_type to_char_type(const int_type& c) {
-    return char_type(c);
-  }
-
-  static int_type to_int_type(const char_type& c) {
-    return int_type(c);
-  }
-
-  static bool eq_int_type(const int_type& c1, const int_type& c2) {
-    return c1 == c2;
-  }
-
-  static int_type eof() {
-    return static_cast<int_type>(EOF);
-  }
-};
-
-}  // namespace string16_internals
-
-typedef std::basic_string<char16,
-                          base::string16_internals::string16_char_traits>
-    string16;
-
-namespace string16_internals {
-
-BASE_EXPORT extern std::ostream& operator<<(std::ostream& out,
-                                            const string16& str);
-
-// This is required by googletest to print a readable output on test failures.
-BASE_EXPORT extern void PrintTo(const string16& str, std::ostream* out);
-
-}  // namespace string16_internals
-
-}  // namespace base
-
-// The string class will be explicitly instantiated only once, in string16.cc.
-//
-// std::basic_string<> in GNU libstdc++ contains a static data member,
-// _S_empty_rep_storage, to represent empty strings.  When an operation such
-// as assignment or destruction is performed on a string, causing its existing
-// data member to be invalidated, it must not be freed if this static data
-// member is being used.  Otherwise, it counts as an attempt to free static
-// (and not allocated) data, which is a memory error.
-//
-// Generally, due to C++ template magic, _S_empty_rep_storage will be marked
-// as a coalesced symbol, meaning that the linker will combine multiple
-// instances into a single one when generating output.
-//
-// If a string class is used by multiple shared libraries, a problem occurs.
-// Each library will get its own copy of _S_empty_rep_storage.  When strings
-// are passed across a library boundary for alteration or destruction, memory
-// errors will result.  GNU libstdc++ contains a configuration option,
-// --enable-fully-dynamic-string (_GLIBCXX_FULLY_DYNAMIC_STRING), which
-// disables the static data member optimization, but it's a good optimization
-// and non-STL code is generally at the mercy of the system's STL
-// configuration.  Fully-dynamic strings are not the default for GNU libstdc++
-// libstdc++ itself or for the libstdc++ installations on the systems we care
-// about, such as Mac OS X and relevant flavors of Linux.
-//
-// See also http://gcc.gnu.org/bugzilla/show_bug.cgi?id=24196 .
-//
-// To avoid problems, string classes need to be explicitly instantiated only
-// once, in exactly one library.  All other string users see it via an "extern"
-// declaration.  This is precisely how GNU libstdc++ handles
-// std::basic_string<char> (string) and std::basic_string<wchar_t> (wstring).
-//
-// This also works around a Mac OS X linker bug in ld64-85.2.1 (Xcode 3.1.2),
-// in which the linker does not fully coalesce symbols when dead code
-// stripping is enabled.  This bug causes the memory errors described above
-// to occur even when a std::basic_string<> does not cross shared library
-// boundaries, such as in statically-linked executables.
-//
-// TODO(mark): File this bug with Apple and update this note with a bug number.
-
-extern template class BASE_EXPORT
-    std::basic_string<base::char16,
-                      base::string16_internals::string16_char_traits>;
-
-// Specialize std::hash for base::string16. Although the style guide forbids
-// this in general, it is necessary for consistency with WCHAR_T_IS_UTF16
-// platforms, where base::string16 is a type alias for std::wstring.
-namespace std {
-template <>
-struct hash<base::string16> {
-  std::size_t operator()(const base::string16& s) const {
-    std::size_t result = 0;
-    for (base::char16 c : s)
-      result = (result * 131) + c;
-    return result;
-  }
-};
-}  // namespace std
-
-#endif  // WCHAR_T_IS_UTF32
-
-#endif  // BASE_STRINGS_STRING16_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_number_conversions.h b/native/zucchini/vendor/libchrome/base/strings/string_number_conversions.h
deleted file mode 100644
index 057b60a..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/string_number_conversions.h
+++ /dev/null
@@ -1,166 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_
-#define BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-#include "build/build_config.h"
-
-// ----------------------------------------------------------------------------
-// IMPORTANT MESSAGE FROM YOUR SPONSOR
-//
-// This file contains no "wstring" variants. New code should use string16. If
-// you need to make old code work, use the UTF8 version and convert. Please do
-// not add wstring variants.
-//
-// Please do not add "convenience" functions for converting strings to integers
-// that return the value and ignore success/failure. That encourages people to
-// write code that doesn't properly handle the error conditions.
-//
-// DO NOT use these functions in any UI unless it's NOT localized on purpose.
-// Instead, use base::MessageFormatter for a complex message with numbers
-// (integer, float, double) embedded or base::Format{Number,Double,Percent} to
-// just format a single number/percent. Note that some languages use native
-// digits instead of ASCII digits while others use a group separator or decimal
-// point different from ',' and '.'. Using these functions in the UI would lead
-// numbers to be formatted in a non-native way.
-// ----------------------------------------------------------------------------
-
-namespace base {
-
-// Number -> string conversions ------------------------------------------------
-
-// Ignores locale! see warning above.
-BASE_EXPORT std::string NumberToString(int value);
-BASE_EXPORT string16 NumberToString16(int value);
-BASE_EXPORT std::string NumberToString(unsigned int value);
-BASE_EXPORT string16 NumberToString16(unsigned int value);
-BASE_EXPORT std::string NumberToString(long value);
-BASE_EXPORT string16 NumberToString16(long value);
-BASE_EXPORT std::string NumberToString(unsigned long value);
-BASE_EXPORT string16 NumberToString16(unsigned long value);
-BASE_EXPORT std::string NumberToString(long long value);
-BASE_EXPORT string16 NumberToString16(long long value);
-BASE_EXPORT std::string NumberToString(unsigned long long value);
-BASE_EXPORT string16 NumberToString16(unsigned long long value);
-BASE_EXPORT std::string NumberToString(double value);
-BASE_EXPORT string16 NumberToString16(double value);
-
-// Type-specific naming for backwards compatibility.
-//
-// TODO(brettw) these should be removed and callers converted to the overloaded
-// "NumberToString" variant.
-inline std::string IntToString(int value) {
-  return NumberToString(value);
-}
-inline string16 IntToString16(int value) {
-  return NumberToString16(value);
-}
-inline std::string UintToString(unsigned value) {
-  return NumberToString(value);
-}
-inline string16 UintToString16(unsigned value) {
-  return NumberToString16(value);
-}
-inline std::string Int64ToString(int64_t value) {
-  return NumberToString(value);
-}
-inline string16 Int64ToString16(int64_t value) {
-  return NumberToString16(value);
-}
-
-// String -> number conversions ------------------------------------------------
-
-// Perform a best-effort conversion of the input string to a numeric type,
-// setting |*output| to the result of the conversion.  Returns true for
-// "perfect" conversions; returns false in the following cases:
-//  - Overflow. |*output| will be set to the maximum value supported
-//    by the data type.
-//  - Underflow. |*output| will be set to the minimum value supported
-//    by the data type.
-//  - Trailing characters in the string after parsing the number.  |*output|
-//    will be set to the value of the number that was parsed.
-//  - Leading whitespace in the string before parsing the number. |*output| will
-//    be set to the value of the number that was parsed.
-//  - No characters parseable as a number at the beginning of the string.
-//    |*output| will be set to 0.
-//  - Empty string.  |*output| will be set to 0.
-// WARNING: Will write to |output| even when returning false.
-//          Read the comments above carefully.
-BASE_EXPORT bool StringToInt(StringPiece input, int* output);
-BASE_EXPORT bool StringToInt(StringPiece16 input, int* output);
-
-BASE_EXPORT bool StringToUint(StringPiece input, unsigned* output);
-BASE_EXPORT bool StringToUint(StringPiece16 input, unsigned* output);
-
-BASE_EXPORT bool StringToInt64(StringPiece input, int64_t* output);
-BASE_EXPORT bool StringToInt64(StringPiece16 input, int64_t* output);
-
-BASE_EXPORT bool StringToUint64(StringPiece input, uint64_t* output);
-BASE_EXPORT bool StringToUint64(StringPiece16 input, uint64_t* output);
-
-BASE_EXPORT bool StringToSizeT(StringPiece input, size_t* output);
-BASE_EXPORT bool StringToSizeT(StringPiece16 input, size_t* output);
-
-// For floating-point conversions, only conversions of input strings in decimal
-// form are defined to work.  Behavior with strings representing floating-point
-// numbers in hexadecimal, and strings representing non-finite values (such as
-// NaN and inf) is undefined.  Otherwise, these behave the same as the integral
-// variants.  This expects the input string to NOT be specific to the locale.
-// If your input is locale specific, use ICU to read the number.
-// WARNING: Will write to |output| even when returning false.
-//          Read the comments here and above StringToInt() carefully.
-BASE_EXPORT bool StringToDouble(const std::string& input, double* output);
-
-// Hex encoding ----------------------------------------------------------------
-
-// Returns a hex string representation of a binary buffer. The returned hex
-// string will be in upper case. This function does not check if |size| is
-// within reasonable limits since it's written with trusted data in mind.  If
-// you suspect that the data you want to format might be large, the absolute
-// max size for |size| should be is
-//   std::numeric_limits<size_t>::max() / 2
-BASE_EXPORT std::string HexEncode(const void* bytes, size_t size);
-
-// Best effort conversion, see StringToInt above for restrictions.
-// Will only successful parse hex values that will fit into |output|, i.e.
-// -0x80000000 < |input| < 0x7FFFFFFF.
-BASE_EXPORT bool HexStringToInt(StringPiece input, int* output);
-
-// Best effort conversion, see StringToInt above for restrictions.
-// Will only successful parse hex values that will fit into |output|, i.e.
-// 0x00000000 < |input| < 0xFFFFFFFF.
-// The string is not required to start with 0x.
-BASE_EXPORT bool HexStringToUInt(StringPiece input, uint32_t* output);
-
-// Best effort conversion, see StringToInt above for restrictions.
-// Will only successful parse hex values that will fit into |output|, i.e.
-// -0x8000000000000000 < |input| < 0x7FFFFFFFFFFFFFFF.
-BASE_EXPORT bool HexStringToInt64(StringPiece input, int64_t* output);
-
-// Best effort conversion, see StringToInt above for restrictions.
-// Will only successful parse hex values that will fit into |output|, i.e.
-// 0x0000000000000000 < |input| < 0xFFFFFFFFFFFFFFFF.
-// The string is not required to start with 0x.
-BASE_EXPORT bool HexStringToUInt64(StringPiece input, uint64_t* output);
-
-// Similar to the previous functions, except that output is a vector of bytes.
-// |*output| will contain as many bytes as were successfully parsed prior to the
-// error.  There is no overflow, but input.size() must be evenly divisible by 2.
-// Leading 0x or +/- are not allowed.
-BASE_EXPORT bool HexStringToBytes(StringPiece input,
-                                  std::vector<uint8_t>* output);
-
-}  // namespace base
-
-#endif  // BASE_STRINGS_STRING_NUMBER_CONVERSIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_piece.cc b/native/zucchini/vendor/libchrome/base/strings/string_piece.cc
deleted file mode 100644
index c82a223..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/string_piece.cc
+++ /dev/null
@@ -1,453 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-// Copied from strings/stringpiece.cc with modifications
-
-#include "base/strings/string_piece.h"
-
-#include <limits.h>
-
-#include <algorithm>
-#include <ostream>
-
-#include "base/logging.h"
-
-namespace base {
-namespace {
-
-// For each character in characters_wanted, sets the index corresponding
-// to the ASCII code of that character to 1 in table.  This is used by
-// the find_.*_of methods below to tell whether or not a character is in
-// the lookup table in constant time.
-// The argument `table' must be an array that is large enough to hold all
-// the possible values of an unsigned char.  Thus it should be be declared
-// as follows:
-//   bool table[UCHAR_MAX + 1]
-inline void BuildLookupTable(const StringPiece& characters_wanted,
-                             bool* table) {
-  const size_t length = characters_wanted.length();
-  const char* const data = characters_wanted.data();
-  for (size_t i = 0; i < length; ++i) {
-    table[static_cast<unsigned char>(data[i])] = true;
-  }
-}
-
-}  // namespace
-
-// MSVC doesn't like complex extern templates and DLLs.
-#if !defined(COMPILER_MSVC)
-template class BasicStringPiece<std::string>;
-template class BasicStringPiece<string16>;
-#endif
-
-bool operator==(const StringPiece& x, const StringPiece& y) {
-  if (x.size() != y.size())
-    return false;
-
-  return CharTraits<StringPiece::value_type>::compare(x.data(), y.data(),
-                                                      x.size()) == 0;
-}
-
-std::ostream& operator<<(std::ostream& o, const StringPiece& piece) {
-  o.write(piece.data(), static_cast<std::streamsize>(piece.size()));
-  return o;
-}
-
-namespace internal {
-
-template<typename STR>
-void CopyToStringT(const BasicStringPiece<STR>& self, STR* target) {
-  if (self.empty())
-    target->clear();
-  else
-    target->assign(self.data(), self.size());
-}
-
-void CopyToString(const StringPiece& self, std::string* target) {
-  CopyToStringT(self, target);
-}
-
-void CopyToString(const StringPiece16& self, string16* target) {
-  CopyToStringT(self, target);
-}
-
-template<typename STR>
-void AppendToStringT(const BasicStringPiece<STR>& self, STR* target) {
-  if (!self.empty())
-    target->append(self.data(), self.size());
-}
-
-void AppendToString(const StringPiece& self, std::string* target) {
-  AppendToStringT(self, target);
-}
-
-void AppendToString(const StringPiece16& self, string16* target) {
-  AppendToStringT(self, target);
-}
-
-template<typename STR>
-size_t copyT(const BasicStringPiece<STR>& self,
-             typename STR::value_type* buf,
-             size_t n,
-             size_t pos) {
-  size_t ret = std::min(self.size() - pos, n);
-  memcpy(buf, self.data() + pos, ret * sizeof(typename STR::value_type));
-  return ret;
-}
-
-size_t copy(const StringPiece& self, char* buf, size_t n, size_t pos) {
-  return copyT(self, buf, n, pos);
-}
-
-size_t copy(const StringPiece16& self, char16* buf, size_t n, size_t pos) {
-  return copyT(self, buf, n, pos);
-}
-
-template<typename STR>
-size_t findT(const BasicStringPiece<STR>& self,
-             const BasicStringPiece<STR>& s,
-             size_t pos) {
-  if (pos > self.size())
-    return BasicStringPiece<STR>::npos;
-
-  typename BasicStringPiece<STR>::const_iterator result =
-      std::search(self.begin() + pos, self.end(), s.begin(), s.end());
-  const size_t xpos =
-    static_cast<size_t>(result - self.begin());
-  return xpos + s.size() <= self.size() ? xpos : BasicStringPiece<STR>::npos;
-}
-
-size_t find(const StringPiece& self, const StringPiece& s, size_t pos) {
-  return findT(self, s, pos);
-}
-
-size_t find(const StringPiece16& self, const StringPiece16& s, size_t pos) {
-  return findT(self, s, pos);
-}
-
-template<typename STR>
-size_t findT(const BasicStringPiece<STR>& self,
-             typename STR::value_type c,
-             size_t pos) {
-  if (pos >= self.size())
-    return BasicStringPiece<STR>::npos;
-
-  typename BasicStringPiece<STR>::const_iterator result =
-      std::find(self.begin() + pos, self.end(), c);
-  return result != self.end() ?
-      static_cast<size_t>(result - self.begin()) : BasicStringPiece<STR>::npos;
-}
-
-size_t find(const StringPiece& self, char c, size_t pos) {
-  return findT(self, c, pos);
-}
-
-size_t find(const StringPiece16& self, char16 c, size_t pos) {
-  return findT(self, c, pos);
-}
-
-template<typename STR>
-size_t rfindT(const BasicStringPiece<STR>& self,
-              const BasicStringPiece<STR>& s,
-              size_t pos) {
-  if (self.size() < s.size())
-    return BasicStringPiece<STR>::npos;
-
-  if (s.empty())
-    return std::min(self.size(), pos);
-
-  typename BasicStringPiece<STR>::const_iterator last =
-      self.begin() + std::min(self.size() - s.size(), pos) + s.size();
-  typename BasicStringPiece<STR>::const_iterator result =
-      std::find_end(self.begin(), last, s.begin(), s.end());
-  return result != last ?
-      static_cast<size_t>(result - self.begin()) : BasicStringPiece<STR>::npos;
-}
-
-size_t rfind(const StringPiece& self, const StringPiece& s, size_t pos) {
-  return rfindT(self, s, pos);
-}
-
-size_t rfind(const StringPiece16& self, const StringPiece16& s, size_t pos) {
-  return rfindT(self, s, pos);
-}
-
-template<typename STR>
-size_t rfindT(const BasicStringPiece<STR>& self,
-              typename STR::value_type c,
-              size_t pos) {
-  if (self.size() == 0)
-    return BasicStringPiece<STR>::npos;
-
-  for (size_t i = std::min(pos, self.size() - 1); ;
-       --i) {
-    if (self.data()[i] == c)
-      return i;
-    if (i == 0)
-      break;
-  }
-  return BasicStringPiece<STR>::npos;
-}
-
-size_t rfind(const StringPiece& self, char c, size_t pos) {
-  return rfindT(self, c, pos);
-}
-
-size_t rfind(const StringPiece16& self, char16 c, size_t pos) {
-  return rfindT(self, c, pos);
-}
-
-// 8-bit version using lookup table.
-size_t find_first_of(const StringPiece& self,
-                     const StringPiece& s,
-                     size_t pos) {
-  if (self.size() == 0 || s.size() == 0)
-    return StringPiece::npos;
-
-  // Avoid the cost of BuildLookupTable() for a single-character search.
-  if (s.size() == 1)
-    return find(self, s.data()[0], pos);
-
-  bool lookup[UCHAR_MAX + 1] = { false };
-  BuildLookupTable(s, lookup);
-  for (size_t i = pos; i < self.size(); ++i) {
-    if (lookup[static_cast<unsigned char>(self.data()[i])]) {
-      return i;
-    }
-  }
-  return StringPiece::npos;
-}
-
-// 16-bit brute force version.
-size_t find_first_of(const StringPiece16& self,
-                     const StringPiece16& s,
-                     size_t pos) {
-  StringPiece16::const_iterator found =
-      std::find_first_of(self.begin() + pos, self.end(), s.begin(), s.end());
-  if (found == self.end())
-    return StringPiece16::npos;
-  return found - self.begin();
-}
-
-// 8-bit version using lookup table.
-size_t find_first_not_of(const StringPiece& self,
-                         const StringPiece& s,
-                         size_t pos) {
-  if (self.size() == 0)
-    return StringPiece::npos;
-
-  if (s.size() == 0)
-    return 0;
-
-  // Avoid the cost of BuildLookupTable() for a single-character search.
-  if (s.size() == 1)
-    return find_first_not_of(self, s.data()[0], pos);
-
-  bool lookup[UCHAR_MAX + 1] = { false };
-  BuildLookupTable(s, lookup);
-  for (size_t i = pos; i < self.size(); ++i) {
-    if (!lookup[static_cast<unsigned char>(self.data()[i])]) {
-      return i;
-    }
-  }
-  return StringPiece::npos;
-}
-
-// 16-bit brute-force version.
-BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
-                                     const StringPiece16& s,
-                                     size_t pos) {
-  if (self.size() == 0)
-    return StringPiece16::npos;
-
-  for (size_t self_i = pos; self_i < self.size(); ++self_i) {
-    bool found = false;
-    for (size_t s_i = 0; s_i < s.size(); ++s_i) {
-      if (self[self_i] == s[s_i]) {
-        found = true;
-        break;
-      }
-    }
-    if (!found)
-      return self_i;
-  }
-  return StringPiece16::npos;
-}
-
-template<typename STR>
-size_t find_first_not_ofT(const BasicStringPiece<STR>& self,
-                          typename STR::value_type c,
-                          size_t pos) {
-  if (self.size() == 0)
-    return BasicStringPiece<STR>::npos;
-
-  for (; pos < self.size(); ++pos) {
-    if (self.data()[pos] != c) {
-      return pos;
-    }
-  }
-  return BasicStringPiece<STR>::npos;
-}
-
-size_t find_first_not_of(const StringPiece& self,
-                         char c,
-                         size_t pos) {
-  return find_first_not_ofT(self, c, pos);
-}
-
-size_t find_first_not_of(const StringPiece16& self,
-                         char16 c,
-                         size_t pos) {
-  return find_first_not_ofT(self, c, pos);
-}
-
-// 8-bit version using lookup table.
-size_t find_last_of(const StringPiece& self, const StringPiece& s, size_t pos) {
-  if (self.size() == 0 || s.size() == 0)
-    return StringPiece::npos;
-
-  // Avoid the cost of BuildLookupTable() for a single-character search.
-  if (s.size() == 1)
-    return rfind(self, s.data()[0], pos);
-
-  bool lookup[UCHAR_MAX + 1] = { false };
-  BuildLookupTable(s, lookup);
-  for (size_t i = std::min(pos, self.size() - 1); ; --i) {
-    if (lookup[static_cast<unsigned char>(self.data()[i])])
-      return i;
-    if (i == 0)
-      break;
-  }
-  return StringPiece::npos;
-}
-
-// 16-bit brute-force version.
-size_t find_last_of(const StringPiece16& self,
-                    const StringPiece16& s,
-                    size_t pos) {
-  if (self.size() == 0)
-    return StringPiece16::npos;
-
-  for (size_t self_i = std::min(pos, self.size() - 1); ;
-       --self_i) {
-    for (size_t s_i = 0; s_i < s.size(); s_i++) {
-      if (self.data()[self_i] == s[s_i])
-        return self_i;
-    }
-    if (self_i == 0)
-      break;
-  }
-  return StringPiece16::npos;
-}
-
-// 8-bit version using lookup table.
-size_t find_last_not_of(const StringPiece& self,
-                        const StringPiece& s,
-                        size_t pos) {
-  if (self.size() == 0)
-    return StringPiece::npos;
-
-  size_t i = std::min(pos, self.size() - 1);
-  if (s.size() == 0)
-    return i;
-
-  // Avoid the cost of BuildLookupTable() for a single-character search.
-  if (s.size() == 1)
-    return find_last_not_of(self, s.data()[0], pos);
-
-  bool lookup[UCHAR_MAX + 1] = { false };
-  BuildLookupTable(s, lookup);
-  for (; ; --i) {
-    if (!lookup[static_cast<unsigned char>(self.data()[i])])
-      return i;
-    if (i == 0)
-      break;
-  }
-  return StringPiece::npos;
-}
-
-// 16-bit brute-force version.
-size_t find_last_not_of(const StringPiece16& self,
-                        const StringPiece16& s,
-                        size_t pos) {
-  if (self.size() == 0)
-    return StringPiece::npos;
-
-  for (size_t self_i = std::min(pos, self.size() - 1); ; --self_i) {
-    bool found = false;
-    for (size_t s_i = 0; s_i < s.size(); s_i++) {
-      if (self.data()[self_i] == s[s_i]) {
-        found = true;
-        break;
-      }
-    }
-    if (!found)
-      return self_i;
-    if (self_i == 0)
-      break;
-  }
-  return StringPiece16::npos;
-}
-
-template<typename STR>
-size_t find_last_not_ofT(const BasicStringPiece<STR>& self,
-                         typename STR::value_type c,
-                         size_t pos) {
-  if (self.size() == 0)
-    return BasicStringPiece<STR>::npos;
-
-  for (size_t i = std::min(pos, self.size() - 1); ; --i) {
-    if (self.data()[i] != c)
-      return i;
-    if (i == 0)
-      break;
-  }
-  return BasicStringPiece<STR>::npos;
-}
-
-size_t find_last_not_of(const StringPiece& self,
-                        char c,
-                        size_t pos) {
-  return find_last_not_ofT(self, c, pos);
-}
-
-size_t find_last_not_of(const StringPiece16& self,
-                        char16 c,
-                        size_t pos) {
-  return find_last_not_ofT(self, c, pos);
-}
-
-template<typename STR>
-BasicStringPiece<STR> substrT(const BasicStringPiece<STR>& self,
-                              size_t pos,
-                              size_t n) {
-  if (pos > self.size()) pos = self.size();
-  if (n > self.size() - pos) n = self.size() - pos;
-  return BasicStringPiece<STR>(self.data() + pos, n);
-}
-
-StringPiece substr(const StringPiece& self,
-                   size_t pos,
-                   size_t n) {
-  return substrT(self, pos, n);
-}
-
-StringPiece16 substr(const StringPiece16& self,
-                     size_t pos,
-                     size_t n) {
-  return substrT(self, pos, n);
-}
-
-#if DCHECK_IS_ON()
-void AssertIteratorsInOrder(std::string::const_iterator begin,
-                            std::string::const_iterator end) {
-  DCHECK(begin <= end) << "StringPiece iterators swapped or invalid.";
-}
-void AssertIteratorsInOrder(string16::const_iterator begin,
-                            string16::const_iterator end) {
-  DCHECK(begin <= end) << "StringPiece iterators swapped or invalid.";
-}
-#endif
-
-}  // namespace internal
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_piece.h b/native/zucchini/vendor/libchrome/base/strings/string_piece.h
deleted file mode 100644
index 775ea7c..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/string_piece.h
+++ /dev/null
@@ -1,483 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-// Copied from strings/stringpiece.h with modifications
-//
-// A string-like object that points to a sized piece of memory.
-//
-// You can use StringPiece as a function or method parameter.  A StringPiece
-// parameter can receive a double-quoted string literal argument, a "const
-// char*" argument, a string argument, or a StringPiece argument with no data
-// copying.  Systematic use of StringPiece for arguments reduces data
-// copies and strlen() calls.
-//
-// Prefer passing StringPieces by value:
-//   void MyFunction(StringPiece arg);
-// If circumstances require, you may also pass by const reference:
-//   void MyFunction(const StringPiece& arg);  // not preferred
-// Both of these have the same lifetime semantics.  Passing by value
-// generates slightly smaller code.  For more discussion, Googlers can see
-// the thread go/stringpiecebyvalue on c-users.
-
-#ifndef BASE_STRINGS_STRING_PIECE_H_
-#define BASE_STRINGS_STRING_PIECE_H_
-
-#include <stddef.h>
-
-#include <iosfwd>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/logging.h"
-#include "base/strings/char_traits.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece_forward.h"
-
-namespace base {
-
-// internal --------------------------------------------------------------------
-
-// Many of the StringPiece functions use different implementations for the
-// 8-bit and 16-bit versions, and we don't want lots of template expansions in
-// this (very common) header that will slow down compilation.
-//
-// So here we define overloaded functions called by the StringPiece template.
-// For those that share an implementation, the two versions will expand to a
-// template internal to the .cc file.
-namespace internal {
-
-BASE_EXPORT void CopyToString(const StringPiece& self, std::string* target);
-BASE_EXPORT void CopyToString(const StringPiece16& self, string16* target);
-
-BASE_EXPORT void AppendToString(const StringPiece& self, std::string* target);
-BASE_EXPORT void AppendToString(const StringPiece16& self, string16* target);
-
-BASE_EXPORT size_t copy(const StringPiece& self,
-                        char* buf,
-                        size_t n,
-                        size_t pos);
-BASE_EXPORT size_t copy(const StringPiece16& self,
-                        char16* buf,
-                        size_t n,
-                        size_t pos);
-
-BASE_EXPORT size_t find(const StringPiece& self,
-                        const StringPiece& s,
-                        size_t pos);
-BASE_EXPORT size_t find(const StringPiece16& self,
-                        const StringPiece16& s,
-                        size_t pos);
-BASE_EXPORT size_t find(const StringPiece& self,
-                        char c,
-                        size_t pos);
-BASE_EXPORT size_t find(const StringPiece16& self,
-                        char16 c,
-                        size_t pos);
-
-BASE_EXPORT size_t rfind(const StringPiece& self,
-                         const StringPiece& s,
-                         size_t pos);
-BASE_EXPORT size_t rfind(const StringPiece16& self,
-                         const StringPiece16& s,
-                         size_t pos);
-BASE_EXPORT size_t rfind(const StringPiece& self,
-                         char c,
-                         size_t pos);
-BASE_EXPORT size_t rfind(const StringPiece16& self,
-                         char16 c,
-                         size_t pos);
-
-BASE_EXPORT size_t find_first_of(const StringPiece& self,
-                                 const StringPiece& s,
-                                 size_t pos);
-BASE_EXPORT size_t find_first_of(const StringPiece16& self,
-                                 const StringPiece16& s,
-                                 size_t pos);
-
-BASE_EXPORT size_t find_first_not_of(const StringPiece& self,
-                                     const StringPiece& s,
-                                     size_t pos);
-BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
-                                     const StringPiece16& s,
-                                     size_t pos);
-BASE_EXPORT size_t find_first_not_of(const StringPiece& self,
-                                     char c,
-                                     size_t pos);
-BASE_EXPORT size_t find_first_not_of(const StringPiece16& self,
-                                     char16 c,
-                                     size_t pos);
-
-BASE_EXPORT size_t find_last_of(const StringPiece& self,
-                                const StringPiece& s,
-                                size_t pos);
-BASE_EXPORT size_t find_last_of(const StringPiece16& self,
-                                const StringPiece16& s,
-                                size_t pos);
-BASE_EXPORT size_t find_last_of(const StringPiece& self,
-                                char c,
-                                size_t pos);
-BASE_EXPORT size_t find_last_of(const StringPiece16& self,
-                                char16 c,
-                                size_t pos);
-
-BASE_EXPORT size_t find_last_not_of(const StringPiece& self,
-                                    const StringPiece& s,
-                                    size_t pos);
-BASE_EXPORT size_t find_last_not_of(const StringPiece16& self,
-                                    const StringPiece16& s,
-                                    size_t pos);
-BASE_EXPORT size_t find_last_not_of(const StringPiece16& self,
-                                    char16 c,
-                                    size_t pos);
-BASE_EXPORT size_t find_last_not_of(const StringPiece& self,
-                                    char c,
-                                    size_t pos);
-
-BASE_EXPORT StringPiece substr(const StringPiece& self,
-                               size_t pos,
-                               size_t n);
-BASE_EXPORT StringPiece16 substr(const StringPiece16& self,
-                                 size_t pos,
-                                 size_t n);
-
-#if DCHECK_IS_ON()
-// Asserts that begin <= end to catch some errors with iterator usage.
-BASE_EXPORT void AssertIteratorsInOrder(std::string::const_iterator begin,
-                                        std::string::const_iterator end);
-BASE_EXPORT void AssertIteratorsInOrder(string16::const_iterator begin,
-                                        string16::const_iterator end);
-#endif
-
-}  // namespace internal
-
-// BasicStringPiece ------------------------------------------------------------
-
-// Defines the types, methods, operators, and data members common to both
-// StringPiece and StringPiece16. Do not refer to this class directly, but
-// rather to BasicStringPiece, StringPiece, or StringPiece16.
-//
-// This is templatized by string class type rather than character type, so
-// BasicStringPiece<std::string> or BasicStringPiece<base::string16>.
-template <typename STRING_TYPE> class BasicStringPiece {
- public:
-  // Standard STL container boilerplate.
-  typedef size_t size_type;
-  typedef typename STRING_TYPE::value_type value_type;
-  typedef const value_type* pointer;
-  typedef const value_type& reference;
-  typedef const value_type& const_reference;
-  typedef ptrdiff_t difference_type;
-  typedef const value_type* const_iterator;
-  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
-  static const size_type npos;
-
- public:
-  // We provide non-explicit singleton constructors so users can pass
-  // in a "const char*" or a "string" wherever a "StringPiece" is
-  // expected (likewise for char16, string16, StringPiece16).
-  constexpr BasicStringPiece() : ptr_(NULL), length_(0) {}
-  // TODO(dcheng): Construction from nullptr is not allowed for
-  // std::basic_string_view, so remove the special handling for it.
-  // Note: This doesn't just use STRING_TYPE::traits_type::length(), since that
-  // isn't constexpr until C++17.
-  constexpr BasicStringPiece(const value_type* str)
-      : ptr_(str), length_(!str ? 0 : CharTraits<value_type>::length(str)) {}
-  BasicStringPiece(const STRING_TYPE& str)
-      : ptr_(str.data()), length_(str.size()) {}
-  constexpr BasicStringPiece(const value_type* offset, size_type len)
-      : ptr_(offset), length_(len) {}
-  BasicStringPiece(const typename STRING_TYPE::const_iterator& begin,
-                   const typename STRING_TYPE::const_iterator& end) {
-#if DCHECK_IS_ON()
-    // This assertion is done out-of-line to avoid bringing in logging.h and
-    // instantiating logging macros for every instantiation.
-    internal::AssertIteratorsInOrder(begin, end);
-#endif
-    length_ = static_cast<size_t>(std::distance(begin, end));
-
-    // The length test before assignment is to avoid dereferencing an iterator
-    // that may point to the end() of a string.
-    ptr_ = length_ > 0 ? &*begin : nullptr;
-  }
-
-  // data() may return a pointer to a buffer with embedded NULs, and the
-  // returned buffer may or may not be null terminated.  Therefore it is
-  // typically a mistake to pass data() to a routine that expects a NUL
-  // terminated string.
-  constexpr const value_type* data() const { return ptr_; }
-  constexpr size_type size() const { return length_; }
-  constexpr size_type length() const { return length_; }
-  bool empty() const { return length_ == 0; }
-
-  void clear() {
-    ptr_ = NULL;
-    length_ = 0;
-  }
-  void set(const value_type* data, size_type len) {
-    ptr_ = data;
-    length_ = len;
-  }
-  void set(const value_type* str) {
-    ptr_ = str;
-    length_ = str ? STRING_TYPE::traits_type::length(str) : 0;
-  }
-
-  constexpr value_type operator[](size_type i) const {
-    CHECK(i < length_);
-    return ptr_[i];
-  }
-
-  value_type front() const {
-    CHECK_NE(0UL, length_);
-    return ptr_[0];
-  }
-
-  value_type back() const {
-    CHECK_NE(0UL, length_);
-    return ptr_[length_ - 1];
-  }
-
-  constexpr void remove_prefix(size_type n) {
-    CHECK(n <= length_);
-    ptr_ += n;
-    length_ -= n;
-  }
-
-  constexpr void remove_suffix(size_type n) {
-    CHECK(n <= length_);
-    length_ -= n;
-  }
-
-  constexpr int compare(BasicStringPiece x) const noexcept {
-    int r = CharTraits<value_type>::compare(
-        ptr_, x.ptr_, (length_ < x.length_ ? length_ : x.length_));
-    if (r == 0) {
-      if (length_ < x.length_) r = -1;
-      else if (length_ > x.length_) r = +1;
-    }
-    return r;
-  }
-
-  // This is the style of conversion preferred by std::string_view in C++17.
-  explicit operator STRING_TYPE() const { return as_string(); }
-
-  STRING_TYPE as_string() const {
-    // std::string doesn't like to take a NULL pointer even with a 0 size.
-    return empty() ? STRING_TYPE() : STRING_TYPE(data(), size());
-  }
-
-  const_iterator begin() const { return ptr_; }
-  const_iterator end() const { return ptr_ + length_; }
-  const_reverse_iterator rbegin() const {
-    return const_reverse_iterator(ptr_ + length_);
-  }
-  const_reverse_iterator rend() const {
-    return const_reverse_iterator(ptr_);
-  }
-
-  size_type max_size() const { return length_; }
-  size_type capacity() const { return length_; }
-
-  // Sets the value of the given string target type to be the current string.
-  // This saves a temporary over doing |a = b.as_string()|
-  void CopyToString(STRING_TYPE* target) const {
-    internal::CopyToString(*this, target);
-  }
-
-  void AppendToString(STRING_TYPE* target) const {
-    internal::AppendToString(*this, target);
-  }
-
-  size_type copy(value_type* buf, size_type n, size_type pos = 0) const {
-    return internal::copy(*this, buf, n, pos);
-  }
-
-  // Does "this" start with "x"
-  constexpr bool starts_with(BasicStringPiece x) const noexcept {
-    return (
-        (this->length_ >= x.length_) &&
-        (CharTraits<value_type>::compare(this->ptr_, x.ptr_, x.length_) == 0));
-  }
-
-  // Does "this" end with "x"
-  constexpr bool ends_with(BasicStringPiece x) const noexcept {
-    return ((this->length_ >= x.length_) &&
-            (CharTraits<value_type>::compare(
-                 this->ptr_ + (this->length_ - x.length_), x.ptr_, x.length_) ==
-             0));
-  }
-
-  // find: Search for a character or substring at a given offset.
-  size_type find(const BasicStringPiece<STRING_TYPE>& s,
-                 size_type pos = 0) const {
-    return internal::find(*this, s, pos);
-  }
-  size_type find(value_type c, size_type pos = 0) const {
-    return internal::find(*this, c, pos);
-  }
-
-  // rfind: Reverse find.
-  size_type rfind(const BasicStringPiece& s,
-                  size_type pos = BasicStringPiece::npos) const {
-    return internal::rfind(*this, s, pos);
-  }
-  size_type rfind(value_type c, size_type pos = BasicStringPiece::npos) const {
-    return internal::rfind(*this, c, pos);
-  }
-
-  // find_first_of: Find the first occurence of one of a set of characters.
-  size_type find_first_of(const BasicStringPiece& s,
-                          size_type pos = 0) const {
-    return internal::find_first_of(*this, s, pos);
-  }
-  size_type find_first_of(value_type c, size_type pos = 0) const {
-    return find(c, pos);
-  }
-
-  // find_first_not_of: Find the first occurence not of a set of characters.
-  size_type find_first_not_of(const BasicStringPiece& s,
-                              size_type pos = 0) const {
-    return internal::find_first_not_of(*this, s, pos);
-  }
-  size_type find_first_not_of(value_type c, size_type pos = 0) const {
-    return internal::find_first_not_of(*this, c, pos);
-  }
-
-  // find_last_of: Find the last occurence of one of a set of characters.
-  size_type find_last_of(const BasicStringPiece& s,
-                         size_type pos = BasicStringPiece::npos) const {
-    return internal::find_last_of(*this, s, pos);
-  }
-  size_type find_last_of(value_type c,
-                         size_type pos = BasicStringPiece::npos) const {
-    return rfind(c, pos);
-  }
-
-  // find_last_not_of: Find the last occurence not of a set of characters.
-  size_type find_last_not_of(const BasicStringPiece& s,
-                             size_type pos = BasicStringPiece::npos) const {
-    return internal::find_last_not_of(*this, s, pos);
-  }
-  size_type find_last_not_of(value_type c,
-                             size_type pos = BasicStringPiece::npos) const {
-    return internal::find_last_not_of(*this, c, pos);
-  }
-
-  // substr.
-  BasicStringPiece substr(size_type pos,
-                          size_type n = BasicStringPiece::npos) const {
-    return internal::substr(*this, pos, n);
-  }
-
- protected:
-  const value_type* ptr_;
-  size_type length_;
-};
-
-template <typename STRING_TYPE>
-const typename BasicStringPiece<STRING_TYPE>::size_type
-BasicStringPiece<STRING_TYPE>::npos =
-    typename BasicStringPiece<STRING_TYPE>::size_type(-1);
-
-// MSVC doesn't like complex extern templates and DLLs.
-#if !defined(COMPILER_MSVC)
-extern template class BASE_EXPORT BasicStringPiece<std::string>;
-extern template class BASE_EXPORT BasicStringPiece<string16>;
-#endif
-
-// StingPiece operators --------------------------------------------------------
-
-BASE_EXPORT bool operator==(const StringPiece& x, const StringPiece& y);
-
-inline bool operator!=(const StringPiece& x, const StringPiece& y) {
-  return !(x == y);
-}
-
-inline bool operator<(const StringPiece& x, const StringPiece& y) {
-  const int r = CharTraits<StringPiece::value_type>::compare(
-      x.data(), y.data(), (x.size() < y.size() ? x.size() : y.size()));
-  return ((r < 0) || ((r == 0) && (x.size() < y.size())));
-}
-
-inline bool operator>(const StringPiece& x, const StringPiece& y) {
-  return y < x;
-}
-
-inline bool operator<=(const StringPiece& x, const StringPiece& y) {
-  return !(x > y);
-}
-
-inline bool operator>=(const StringPiece& x, const StringPiece& y) {
-  return !(x < y);
-}
-
-// StringPiece16 operators -----------------------------------------------------
-
-inline bool operator==(const StringPiece16& x, const StringPiece16& y) {
-  if (x.size() != y.size())
-    return false;
-
-  return CharTraits<StringPiece16::value_type>::compare(x.data(), y.data(),
-                                                        x.size()) == 0;
-}
-
-inline bool operator!=(const StringPiece16& x, const StringPiece16& y) {
-  return !(x == y);
-}
-
-inline bool operator<(const StringPiece16& x, const StringPiece16& y) {
-  const int r = CharTraits<StringPiece16::value_type>::compare(
-      x.data(), y.data(), (x.size() < y.size() ? x.size() : y.size()));
-  return ((r < 0) || ((r == 0) && (x.size() < y.size())));
-}
-
-inline bool operator>(const StringPiece16& x, const StringPiece16& y) {
-  return y < x;
-}
-
-inline bool operator<=(const StringPiece16& x, const StringPiece16& y) {
-  return !(x > y);
-}
-
-inline bool operator>=(const StringPiece16& x, const StringPiece16& y) {
-  return !(x < y);
-}
-
-BASE_EXPORT std::ostream& operator<<(std::ostream& o,
-                                     const StringPiece& piece);
-
-// Hashing ---------------------------------------------------------------------
-
-// We provide appropriate hash functions so StringPiece and StringPiece16 can
-// be used as keys in hash sets and maps.
-
-// This hash function is copied from base/strings/string16.h. We don't use the
-// ones already defined for string and string16 directly because it would
-// require the string constructors to be called, which we don't want.
-#define HASH_STRING_PIECE(StringPieceType, string_piece)         \
-  std::size_t result = 0;                                        \
-  for (StringPieceType::const_iterator i = string_piece.begin(); \
-       i != string_piece.end(); ++i)                             \
-    result = (result * 131) + *i;                                \
-  return result;
-
-struct StringPieceHash {
-  std::size_t operator()(const StringPiece& sp) const {
-    HASH_STRING_PIECE(StringPiece, sp);
-  }
-};
-struct StringPiece16Hash {
-  std::size_t operator()(const StringPiece16& sp16) const {
-    HASH_STRING_PIECE(StringPiece16, sp16);
-  }
-};
-struct WStringPieceHash {
-  std::size_t operator()(const WStringPiece& wsp) const {
-    HASH_STRING_PIECE(WStringPiece, wsp);
-  }
-};
-
-}  // namespace base
-
-#endif  // BASE_STRINGS_STRING_PIECE_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_piece_forward.h b/native/zucchini/vendor/libchrome/base/strings/string_piece_forward.h
deleted file mode 100644
index b50b980..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/string_piece_forward.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Forward declaration of StringPiece types from base/strings/string_piece.h
-
-#ifndef BASE_STRINGS_STRING_PIECE_FORWARD_H_
-#define BASE_STRINGS_STRING_PIECE_FORWARD_H_
-
-#include <string>
-
-#include "base/strings/string16.h"
-
-namespace base {
-
-template <typename STRING_TYPE>
-class BasicStringPiece;
-typedef BasicStringPiece<std::string> StringPiece;
-typedef BasicStringPiece<string16> StringPiece16;
-typedef BasicStringPiece<std::wstring> WStringPiece;
-
-}  // namespace base
-
-#endif  // BASE_STRINGS_STRING_PIECE_FORWARD_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_util.cc b/native/zucchini/vendor/libchrome/base/strings/string_util.cc
deleted file mode 100644
index 32e5ff2..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/string_util.cc
+++ /dev/null
@@ -1,1124 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/strings/string_util.h"
-
-#include <ctype.h>
-#include <errno.h>
-#include <math.h>
-#include <stdarg.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <time.h>
-#include <wchar.h>
-#include <wctype.h>
-
-#include <algorithm>
-#include <limits>
-#include <vector>
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/singleton.h"
-#include "base/strings/utf_string_conversion_utils.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/third_party/icu/icu_utf.h"
-#include "build/build_config.h"
-
-namespace base {
-
-namespace {
-
-// Force the singleton used by EmptyString[16] to be a unique type. This
-// prevents other code that might accidentally use Singleton<string> from
-// getting our internal one.
-struct EmptyStrings {
-  EmptyStrings() = default;
-  const std::string s;
-  const string16 s16;
-
-  static EmptyStrings* GetInstance() {
-    return Singleton<EmptyStrings>::get();
-  }
-};
-
-// Used by ReplaceStringPlaceholders to track the position in the string of
-// replaced parameters.
-struct ReplacementOffset {
-  ReplacementOffset(uintptr_t parameter, size_t offset)
-      : parameter(parameter),
-        offset(offset) {}
-
-  // Index of the parameter.
-  uintptr_t parameter;
-
-  // Starting position in the string.
-  size_t offset;
-};
-
-static bool CompareParameter(const ReplacementOffset& elem1,
-                             const ReplacementOffset& elem2) {
-  return elem1.parameter < elem2.parameter;
-}
-
-// Overloaded function to append one string onto the end of another. Having a
-// separate overload for |source| as both string and StringPiece allows for more
-// efficient usage from functions templated to work with either type (avoiding a
-// redundant call to the BasicStringPiece constructor in both cases).
-template <typename string_type>
-inline void AppendToString(string_type* target, const string_type& source) {
-  target->append(source);
-}
-
-template <typename string_type>
-inline void AppendToString(string_type* target,
-                           const BasicStringPiece<string_type>& source) {
-  source.AppendToString(target);
-}
-
-// Assuming that a pointer is the size of a "machine word", then
-// uintptr_t is an integer type that is also a machine word.
-typedef uintptr_t MachineWord;
-const uintptr_t kMachineWordAlignmentMask = sizeof(MachineWord) - 1;
-
-inline bool IsAlignedToMachineWord(const void* pointer) {
-  return !(reinterpret_cast<MachineWord>(pointer) & kMachineWordAlignmentMask);
-}
-
-template<typename T> inline T* AlignToMachineWord(T* pointer) {
-  return reinterpret_cast<T*>(reinterpret_cast<MachineWord>(pointer) &
-                              ~kMachineWordAlignmentMask);
-}
-
-template<size_t size, typename CharacterType> struct NonASCIIMask;
-template<> struct NonASCIIMask<4, char16> {
-    static inline uint32_t value() { return 0xFF80FF80U; }
-};
-template<> struct NonASCIIMask<4, char> {
-    static inline uint32_t value() { return 0x80808080U; }
-};
-template<> struct NonASCIIMask<8, char16> {
-    static inline uint64_t value() { return 0xFF80FF80FF80FF80ULL; }
-};
-template<> struct NonASCIIMask<8, char> {
-    static inline uint64_t value() { return 0x8080808080808080ULL; }
-};
-#if defined(WCHAR_T_IS_UTF32)
-template<> struct NonASCIIMask<4, wchar_t> {
-    static inline uint32_t value() { return 0xFFFFFF80U; }
-};
-template<> struct NonASCIIMask<8, wchar_t> {
-    static inline uint64_t value() { return 0xFFFFFF80FFFFFF80ULL; }
-};
-#endif  // WCHAR_T_IS_UTF32
-
-}  // namespace
-
-bool IsWprintfFormatPortable(const wchar_t* format) {
-  for (const wchar_t* position = format; *position != '\0'; ++position) {
-    if (*position == '%') {
-      bool in_specification = true;
-      bool modifier_l = false;
-      while (in_specification) {
-        // Eat up characters until reaching a known specifier.
-        if (*++position == '\0') {
-          // The format string ended in the middle of a specification.  Call
-          // it portable because no unportable specifications were found.  The
-          // string is equally broken on all platforms.
-          return true;
-        }
-
-        if (*position == 'l') {
-          // 'l' is the only thing that can save the 's' and 'c' specifiers.
-          modifier_l = true;
-        } else if (((*position == 's' || *position == 'c') && !modifier_l) ||
-                   *position == 'S' || *position == 'C' || *position == 'F' ||
-                   *position == 'D' || *position == 'O' || *position == 'U') {
-          // Not portable.
-          return false;
-        }
-
-        if (wcschr(L"diouxXeEfgGaAcspn%", *position)) {
-          // Portable, keep scanning the rest of the format string.
-          in_specification = false;
-        }
-      }
-    }
-  }
-
-  return true;
-}
-
-namespace {
-
-template<typename StringType>
-StringType ToLowerASCIIImpl(BasicStringPiece<StringType> str) {
-  StringType ret;
-  ret.reserve(str.size());
-  for (size_t i = 0; i < str.size(); i++)
-    ret.push_back(ToLowerASCII(str[i]));
-  return ret;
-}
-
-template<typename StringType>
-StringType ToUpperASCIIImpl(BasicStringPiece<StringType> str) {
-  StringType ret;
-  ret.reserve(str.size());
-  for (size_t i = 0; i < str.size(); i++)
-    ret.push_back(ToUpperASCII(str[i]));
-  return ret;
-}
-
-}  // namespace
-
-std::string ToLowerASCII(StringPiece str) {
-  return ToLowerASCIIImpl<std::string>(str);
-}
-
-string16 ToLowerASCII(StringPiece16 str) {
-  return ToLowerASCIIImpl<string16>(str);
-}
-
-std::string ToUpperASCII(StringPiece str) {
-  return ToUpperASCIIImpl<std::string>(str);
-}
-
-string16 ToUpperASCII(StringPiece16 str) {
-  return ToUpperASCIIImpl<string16>(str);
-}
-
-template<class StringType>
-int CompareCaseInsensitiveASCIIT(BasicStringPiece<StringType> a,
-                                 BasicStringPiece<StringType> b) {
-  // Find the first characters that aren't equal and compare them.  If the end
-  // of one of the strings is found before a nonequal character, the lengths
-  // of the strings are compared.
-  size_t i = 0;
-  while (i < a.length() && i < b.length()) {
-    typename StringType::value_type lower_a = ToLowerASCII(a[i]);
-    typename StringType::value_type lower_b = ToLowerASCII(b[i]);
-    if (lower_a < lower_b)
-      return -1;
-    if (lower_a > lower_b)
-      return 1;
-    i++;
-  }
-
-  // End of one string hit before finding a different character. Expect the
-  // common case to be "strings equal" at this point so check that first.
-  if (a.length() == b.length())
-    return 0;
-
-  if (a.length() < b.length())
-    return -1;
-  return 1;
-}
-
-int CompareCaseInsensitiveASCII(StringPiece a, StringPiece b) {
-  return CompareCaseInsensitiveASCIIT<std::string>(a, b);
-}
-
-int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
-  return CompareCaseInsensitiveASCIIT<string16>(a, b);
-}
-
-bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b) {
-  if (a.length() != b.length())
-    return false;
-  return CompareCaseInsensitiveASCIIT<std::string>(a, b) == 0;
-}
-
-bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b) {
-  if (a.length() != b.length())
-    return false;
-  return CompareCaseInsensitiveASCIIT<string16>(a, b) == 0;
-}
-
-const std::string& EmptyString() {
-  return EmptyStrings::GetInstance()->s;
-}
-
-const string16& EmptyString16() {
-  return EmptyStrings::GetInstance()->s16;
-}
-
-template <class StringType>
-bool ReplaceCharsT(const StringType& input,
-                   BasicStringPiece<StringType> find_any_of_these,
-                   BasicStringPiece<StringType> replace_with,
-                   StringType* output);
-
-bool ReplaceChars(const string16& input,
-                  StringPiece16 replace_chars,
-                  const string16& replace_with,
-                  string16* output) {
-  return ReplaceCharsT(input, replace_chars, StringPiece16(replace_with),
-                       output);
-}
-
-bool ReplaceChars(const std::string& input,
-                  StringPiece replace_chars,
-                  const std::string& replace_with,
-                  std::string* output) {
-  return ReplaceCharsT(input, replace_chars, StringPiece(replace_with), output);
-}
-
-bool RemoveChars(const string16& input,
-                 StringPiece16 remove_chars,
-                 string16* output) {
-  return ReplaceCharsT(input, remove_chars, StringPiece16(), output);
-}
-
-bool RemoveChars(const std::string& input,
-                 StringPiece remove_chars,
-                 std::string* output) {
-  return ReplaceCharsT(input, remove_chars, StringPiece(), output);
-}
-
-template<typename Str>
-TrimPositions TrimStringT(const Str& input,
-                          BasicStringPiece<Str> trim_chars,
-                          TrimPositions positions,
-                          Str* output) {
-  // Find the edges of leading/trailing whitespace as desired. Need to use
-  // a StringPiece version of input to be able to call find* on it with the
-  // StringPiece version of trim_chars (normally the trim_chars will be a
-  // constant so avoid making a copy).
-  BasicStringPiece<Str> input_piece(input);
-  const size_t last_char = input.length() - 1;
-  const size_t first_good_char = (positions & TRIM_LEADING) ?
-      input_piece.find_first_not_of(trim_chars) : 0;
-  const size_t last_good_char = (positions & TRIM_TRAILING) ?
-      input_piece.find_last_not_of(trim_chars) : last_char;
-
-  // When the string was all trimmed, report that we stripped off characters
-  // from whichever position the caller was interested in. For empty input, we
-  // stripped no characters, but we still need to clear |output|.
-  if (input.empty() ||
-      (first_good_char == Str::npos) || (last_good_char == Str::npos)) {
-    bool input_was_empty = input.empty();  // in case output == &input
-    output->clear();
-    return input_was_empty ? TRIM_NONE : positions;
-  }
-
-  // Trim.
-  *output =
-      input.substr(first_good_char, last_good_char - first_good_char + 1);
-
-  // Return where we trimmed from.
-  return static_cast<TrimPositions>(
-      ((first_good_char == 0) ? TRIM_NONE : TRIM_LEADING) |
-      ((last_good_char == last_char) ? TRIM_NONE : TRIM_TRAILING));
-}
-
-bool TrimString(const string16& input,
-                StringPiece16 trim_chars,
-                string16* output) {
-  return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
-}
-
-bool TrimString(const std::string& input,
-                StringPiece trim_chars,
-                std::string* output) {
-  return TrimStringT(input, trim_chars, TRIM_ALL, output) != TRIM_NONE;
-}
-
-template<typename Str>
-BasicStringPiece<Str> TrimStringPieceT(BasicStringPiece<Str> input,
-                                       BasicStringPiece<Str> trim_chars,
-                                       TrimPositions positions) {
-  size_t begin = (positions & TRIM_LEADING) ?
-      input.find_first_not_of(trim_chars) : 0;
-  size_t end = (positions & TRIM_TRAILING) ?
-      input.find_last_not_of(trim_chars) + 1 : input.size();
-  return input.substr(begin, end - begin);
-}
-
-StringPiece16 TrimString(StringPiece16 input,
-                         StringPiece16 trim_chars,
-                         TrimPositions positions) {
-  return TrimStringPieceT(input, trim_chars, positions);
-}
-
-StringPiece TrimString(StringPiece input,
-                       StringPiece trim_chars,
-                       TrimPositions positions) {
-  return TrimStringPieceT(input, trim_chars, positions);
-}
-
-void TruncateUTF8ToByteSize(const std::string& input,
-                            const size_t byte_size,
-                            std::string* output) {
-  DCHECK(output);
-  if (byte_size > input.length()) {
-    *output = input;
-    return;
-  }
-  DCHECK_LE(byte_size,
-            static_cast<uint32_t>(std::numeric_limits<int32_t>::max()));
-  // Note: This cast is necessary because CBU8_NEXT uses int32_ts.
-  int32_t truncation_length = static_cast<int32_t>(byte_size);
-  int32_t char_index = truncation_length - 1;
-  const char* data = input.data();
-
-  // Using CBU8, we will move backwards from the truncation point
-  // to the beginning of the string looking for a valid UTF8
-  // character.  Once a full UTF8 character is found, we will
-  // truncate the string to the end of that character.
-  while (char_index >= 0) {
-    int32_t prev = char_index;
-    base_icu::UChar32 code_point = 0;
-    CBU8_NEXT(data, char_index, truncation_length, code_point);
-    if (!IsValidCharacter(code_point) ||
-        !IsValidCodepoint(code_point)) {
-      char_index = prev - 1;
-    } else {
-      break;
-    }
-  }
-
-  if (char_index >= 0 )
-    *output = input.substr(0, char_index);
-  else
-    output->clear();
-}
-
-TrimPositions TrimWhitespace(const string16& input,
-                             TrimPositions positions,
-                             string16* output) {
-  return TrimStringT(input, StringPiece16(kWhitespaceUTF16), positions, output);
-}
-
-StringPiece16 TrimWhitespace(StringPiece16 input,
-                             TrimPositions positions) {
-  return TrimStringPieceT(input, StringPiece16(kWhitespaceUTF16), positions);
-}
-
-TrimPositions TrimWhitespaceASCII(const std::string& input,
-                                  TrimPositions positions,
-                                  std::string* output) {
-  return TrimStringT(input, StringPiece(kWhitespaceASCII), positions, output);
-}
-
-StringPiece TrimWhitespaceASCII(StringPiece input, TrimPositions positions) {
-  return TrimStringPieceT(input, StringPiece(kWhitespaceASCII), positions);
-}
-
-template<typename STR>
-STR CollapseWhitespaceT(const STR& text,
-                        bool trim_sequences_with_line_breaks) {
-  STR result;
-  result.resize(text.size());
-
-  // Set flags to pretend we're already in a trimmed whitespace sequence, so we
-  // will trim any leading whitespace.
-  bool in_whitespace = true;
-  bool already_trimmed = true;
-
-  int chars_written = 0;
-  for (typename STR::const_iterator i(text.begin()); i != text.end(); ++i) {
-    if (IsUnicodeWhitespace(*i)) {
-      if (!in_whitespace) {
-        // Reduce all whitespace sequences to a single space.
-        in_whitespace = true;
-        result[chars_written++] = L' ';
-      }
-      if (trim_sequences_with_line_breaks && !already_trimmed &&
-          ((*i == '\n') || (*i == '\r'))) {
-        // Whitespace sequences containing CR or LF are eliminated entirely.
-        already_trimmed = true;
-        --chars_written;
-      }
-    } else {
-      // Non-whitespace chracters are copied straight across.
-      in_whitespace = false;
-      already_trimmed = false;
-      result[chars_written++] = *i;
-    }
-  }
-
-  if (in_whitespace && !already_trimmed) {
-    // Any trailing whitespace is eliminated.
-    --chars_written;
-  }
-
-  result.resize(chars_written);
-  return result;
-}
-
-string16 CollapseWhitespace(const string16& text,
-                            bool trim_sequences_with_line_breaks) {
-  return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
-}
-
-std::string CollapseWhitespaceASCII(const std::string& text,
-                                    bool trim_sequences_with_line_breaks) {
-  return CollapseWhitespaceT(text, trim_sequences_with_line_breaks);
-}
-
-bool ContainsOnlyChars(StringPiece input, StringPiece characters) {
-  return input.find_first_not_of(characters) == StringPiece::npos;
-}
-
-bool ContainsOnlyChars(StringPiece16 input, StringPiece16 characters) {
-  return input.find_first_not_of(characters) == StringPiece16::npos;
-}
-
-template <class Char>
-inline bool DoIsStringASCII(const Char* characters, size_t length) {
-  MachineWord all_char_bits = 0;
-  const Char* end = characters + length;
-
-  // Prologue: align the input.
-  while (!IsAlignedToMachineWord(characters) && characters != end) {
-    all_char_bits |= *characters;
-    ++characters;
-  }
-
-  // Compare the values of CPU word size.
-  const Char* word_end = AlignToMachineWord(end);
-  const size_t loop_increment = sizeof(MachineWord) / sizeof(Char);
-  while (characters < word_end) {
-    all_char_bits |= *(reinterpret_cast<const MachineWord*>(characters));
-    characters += loop_increment;
-  }
-
-  // Process the remaining bytes.
-  while (characters != end) {
-    all_char_bits |= *characters;
-    ++characters;
-  }
-
-  MachineWord non_ascii_bit_mask =
-      NonASCIIMask<sizeof(MachineWord), Char>::value();
-  return !(all_char_bits & non_ascii_bit_mask);
-}
-
-bool IsStringASCII(StringPiece str) {
-  return DoIsStringASCII(str.data(), str.length());
-}
-
-bool IsStringASCII(StringPiece16 str) {
-  return DoIsStringASCII(str.data(), str.length());
-}
-
-#if defined(WCHAR_T_IS_UTF32)
-bool IsStringASCII(WStringPiece str) {
-  return DoIsStringASCII(str.data(), str.length());
-}
-#endif
-
-bool IsStringUTF8(StringPiece str) {
-  const char *src = str.data();
-  int32_t src_len = static_cast<int32_t>(str.length());
-  int32_t char_index = 0;
-
-  while (char_index < src_len) {
-    int32_t code_point;
-    CBU8_NEXT(src, char_index, src_len, code_point);
-    if (!IsValidCharacter(code_point))
-      return false;
-  }
-  return true;
-}
-
-// Implementation note: Normally this function will be called with a hardcoded
-// constant for the lowercase_ascii parameter. Constructing a StringPiece from
-// a C constant requires running strlen, so the result will be two passes
-// through the buffers, one to file the length of lowercase_ascii, and one to
-// compare each letter.
-//
-// This function could have taken a const char* to avoid this and only do one
-// pass through the string. But the strlen is faster than the case-insensitive
-// compares and lets us early-exit in the case that the strings are different
-// lengths (will often be the case for non-matches). So whether one approach or
-// the other will be faster depends on the case.
-//
-// The hardcoded strings are typically very short so it doesn't matter, and the
-// string piece gives additional flexibility for the caller (doesn't have to be
-// null terminated) so we choose the StringPiece route.
-template<typename Str>
-static inline bool DoLowerCaseEqualsASCII(BasicStringPiece<Str> str,
-                                          StringPiece lowercase_ascii) {
-  if (str.size() != lowercase_ascii.size())
-    return false;
-  for (size_t i = 0; i < str.size(); i++) {
-    if (ToLowerASCII(str[i]) != lowercase_ascii[i])
-      return false;
-  }
-  return true;
-}
-
-bool LowerCaseEqualsASCII(StringPiece str, StringPiece lowercase_ascii) {
-  return DoLowerCaseEqualsASCII<std::string>(str, lowercase_ascii);
-}
-
-bool LowerCaseEqualsASCII(StringPiece16 str, StringPiece lowercase_ascii) {
-  return DoLowerCaseEqualsASCII<string16>(str, lowercase_ascii);
-}
-
-bool EqualsASCII(StringPiece16 str, StringPiece ascii) {
-  if (str.length() != ascii.length())
-    return false;
-  return std::equal(ascii.begin(), ascii.end(), str.begin());
-}
-
-template<typename Str>
-bool StartsWithT(BasicStringPiece<Str> str,
-                 BasicStringPiece<Str> search_for,
-                 CompareCase case_sensitivity) {
-  if (search_for.size() > str.size())
-    return false;
-
-  BasicStringPiece<Str> source = str.substr(0, search_for.size());
-
-  switch (case_sensitivity) {
-    case CompareCase::SENSITIVE:
-      return source == search_for;
-
-    case CompareCase::INSENSITIVE_ASCII:
-      return std::equal(
-          search_for.begin(), search_for.end(),
-          source.begin(),
-          CaseInsensitiveCompareASCII<typename Str::value_type>());
-
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
-bool StartsWith(StringPiece str,
-                StringPiece search_for,
-                CompareCase case_sensitivity) {
-  return StartsWithT<std::string>(str, search_for, case_sensitivity);
-}
-
-bool StartsWith(StringPiece16 str,
-                StringPiece16 search_for,
-                CompareCase case_sensitivity) {
-  return StartsWithT<string16>(str, search_for, case_sensitivity);
-}
-
-template <typename Str>
-bool EndsWithT(BasicStringPiece<Str> str,
-               BasicStringPiece<Str> search_for,
-               CompareCase case_sensitivity) {
-  if (search_for.size() > str.size())
-    return false;
-
-  BasicStringPiece<Str> source = str.substr(str.size() - search_for.size(),
-                                            search_for.size());
-
-  switch (case_sensitivity) {
-    case CompareCase::SENSITIVE:
-      return source == search_for;
-
-    case CompareCase::INSENSITIVE_ASCII:
-      return std::equal(
-          source.begin(), source.end(),
-          search_for.begin(),
-          CaseInsensitiveCompareASCII<typename Str::value_type>());
-
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
-bool EndsWith(StringPiece str,
-              StringPiece search_for,
-              CompareCase case_sensitivity) {
-  return EndsWithT<std::string>(str, search_for, case_sensitivity);
-}
-
-bool EndsWith(StringPiece16 str,
-              StringPiece16 search_for,
-              CompareCase case_sensitivity) {
-  return EndsWithT<string16>(str, search_for, case_sensitivity);
-}
-
-char HexDigitToInt(wchar_t c) {
-  DCHECK(IsHexDigit(c));
-  if (c >= '0' && c <= '9')
-    return static_cast<char>(c - '0');
-  if (c >= 'A' && c <= 'F')
-    return static_cast<char>(c - 'A' + 10);
-  if (c >= 'a' && c <= 'f')
-    return static_cast<char>(c - 'a' + 10);
-  return 0;
-}
-
-bool IsUnicodeWhitespace(wchar_t c) {
-  // kWhitespaceWide is a NULL-terminated string
-  for (const wchar_t* cur = kWhitespaceWide; *cur; ++cur) {
-    if (*cur == c)
-      return true;
-  }
-  return false;
-}
-
-static const char* const kByteStringsUnlocalized[] = {
-  " B",
-  " kB",
-  " MB",
-  " GB",
-  " TB",
-  " PB"
-};
-
-string16 FormatBytesUnlocalized(int64_t bytes) {
-  double unit_amount = static_cast<double>(bytes);
-  size_t dimension = 0;
-  const int kKilo = 1024;
-  while (unit_amount >= kKilo &&
-         dimension < arraysize(kByteStringsUnlocalized) - 1) {
-    unit_amount /= kKilo;
-    dimension++;
-  }
-
-  char buf[64];
-  if (bytes != 0 && dimension > 0 && unit_amount < 100) {
-    base::snprintf(buf, arraysize(buf), "%.1lf%s", unit_amount,
-                   kByteStringsUnlocalized[dimension]);
-  } else {
-    base::snprintf(buf, arraysize(buf), "%.0lf%s", unit_amount,
-                   kByteStringsUnlocalized[dimension]);
-  }
-
-  return ASCIIToUTF16(buf);
-}
-
-// A Matcher for DoReplaceMatchesAfterOffset() that matches substrings.
-template <class StringType>
-struct SubstringMatcher {
-  BasicStringPiece<StringType> find_this;
-
-  size_t Find(const StringType& input, size_t pos) {
-    return input.find(find_this.data(), pos, find_this.length());
-  }
-  size_t MatchSize() { return find_this.length(); }
-};
-
-// A Matcher for DoReplaceMatchesAfterOffset() that matches single characters.
-template <class StringType>
-struct CharacterMatcher {
-  BasicStringPiece<StringType> find_any_of_these;
-
-  size_t Find(const StringType& input, size_t pos) {
-    return input.find_first_of(find_any_of_these.data(), pos,
-                               find_any_of_these.length());
-  }
-  constexpr size_t MatchSize() { return 1; }
-};
-
-enum class ReplaceType { REPLACE_ALL, REPLACE_FIRST };
-
-// Runs in O(n) time in the length of |str|, and transforms the string without
-// reallocating when possible. Returns |true| if any matches were found.
-//
-// This is parameterized on a |Matcher| traits type, so that it can be the
-// implementation for both ReplaceChars() and ReplaceSubstringsAfterOffset().
-template <class StringType, class Matcher>
-bool DoReplaceMatchesAfterOffset(StringType* str,
-                                 size_t initial_offset,
-                                 Matcher matcher,
-                                 BasicStringPiece<StringType> replace_with,
-                                 ReplaceType replace_type) {
-  using CharTraits = typename StringType::traits_type;
-
-  const size_t find_length = matcher.MatchSize();
-  if (!find_length)
-    return false;
-
-  // If the find string doesn't appear, there's nothing to do.
-  size_t first_match = matcher.Find(*str, initial_offset);
-  if (first_match == StringType::npos)
-    return false;
-
-  // If we're only replacing one instance, there's no need to do anything
-  // complicated.
-  const size_t replace_length = replace_with.length();
-  if (replace_type == ReplaceType::REPLACE_FIRST) {
-    str->replace(first_match, find_length, replace_with.data(), replace_length);
-    return true;
-  }
-
-  // If the find and replace strings are the same length, we can simply use
-  // replace() on each instance, and finish the entire operation in O(n) time.
-  if (find_length == replace_length) {
-    auto* buffer = &((*str)[0]);
-    for (size_t offset = first_match; offset != StringType::npos;
-         offset = matcher.Find(*str, offset + replace_length)) {
-      CharTraits::copy(buffer + offset, replace_with.data(), replace_length);
-    }
-    return true;
-  }
-
-  // Since the find and replace strings aren't the same length, a loop like the
-  // one above would be O(n^2) in the worst case, as replace() will shift the
-  // entire remaining string each time. We need to be more clever to keep things
-  // O(n).
-  //
-  // When the string is being shortened, it's possible to just shift the matches
-  // down in one pass while finding, and truncate the length at the end of the
-  // search.
-  //
-  // If the string is being lengthened, more work is required. The strategy used
-  // here is to make two find() passes through the string. The first pass counts
-  // the number of matches to determine the new size. The second pass will
-  // either construct the new string into a new buffer (if the existing buffer
-  // lacked capacity), or else -- if there is room -- create a region of scratch
-  // space after |first_match| by shifting the tail of the string to a higher
-  // index, and doing in-place moves from the tail to lower indices thereafter.
-  size_t str_length = str->length();
-  size_t expansion = 0;
-  if (replace_length > find_length) {
-    // This operation lengthens the string; determine the new length by counting
-    // matches.
-    const size_t expansion_per_match = (replace_length - find_length);
-    size_t num_matches = 0;
-    for (size_t match = first_match; match != StringType::npos;
-         match = matcher.Find(*str, match + find_length)) {
-      expansion += expansion_per_match;
-      ++num_matches;
-    }
-    const size_t final_length = str_length + expansion;
-
-    if (str->capacity() < final_length) {
-      // If we'd have to allocate a new buffer to grow the string, build the
-      // result directly into the new allocation via append().
-      StringType src(str->get_allocator());
-      str->swap(src);
-      str->reserve(final_length);
-
-      size_t pos = 0;
-      for (size_t match = first_match;; match = matcher.Find(src, pos)) {
-        str->append(src, pos, match - pos);
-        str->append(replace_with.data(), replace_length);
-        pos = match + find_length;
-
-        // A mid-loop test/break enables skipping the final Find() call; the
-        // number of matches is known, so don't search past the last one.
-        if (!--num_matches)
-          break;
-      }
-
-      // Handle substring after the final match.
-      str->append(src, pos, str_length - pos);
-      return true;
-    }
-
-    // Prepare for the copy/move loop below -- expand the string to its final
-    // size by shifting the data after the first match to the end of the resized
-    // string.
-    size_t shift_src = first_match + find_length;
-    size_t shift_dst = shift_src + expansion;
-
-    // Big |expansion| factors (relative to |str_length|) require padding up to
-    // |shift_dst|.
-    if (shift_dst > str_length)
-      str->resize(shift_dst);
-
-    str->replace(shift_dst, str_length - shift_src, *str, shift_src,
-                 str_length - shift_src);
-    str_length = final_length;
-  }
-
-  // We can alternate replacement and move operations. This won't overwrite the
-  // unsearched region of the string so long as |write_offset| <= |read_offset|;
-  // that condition is always satisfied because:
-  //
-  //   (a) If the string is being shortened, |expansion| is zero and
-  //       |write_offset| grows slower than |read_offset|.
-  //
-  //   (b) If the string is being lengthened, |write_offset| grows faster than
-  //       |read_offset|, but |expansion| is big enough so that |write_offset|
-  //       will only catch up to |read_offset| at the point of the last match.
-  auto* buffer = &((*str)[0]);
-  size_t write_offset = first_match;
-  size_t read_offset = first_match + expansion;
-  do {
-    if (replace_length) {
-      CharTraits::copy(buffer + write_offset, replace_with.data(),
-                       replace_length);
-      write_offset += replace_length;
-    }
-    read_offset += find_length;
-
-    // min() clamps StringType::npos (the largest unsigned value) to str_length.
-    size_t match = std::min(matcher.Find(*str, read_offset), str_length);
-
-    size_t length = match - read_offset;
-    if (length) {
-      CharTraits::move(buffer + write_offset, buffer + read_offset, length);
-      write_offset += length;
-      read_offset += length;
-    }
-  } while (read_offset < str_length);
-
-  // If we're shortening the string, truncate it now.
-  str->resize(write_offset);
-  return true;
-}
-
-template <class StringType>
-bool ReplaceCharsT(const StringType& input,
-                   BasicStringPiece<StringType> find_any_of_these,
-                   BasicStringPiece<StringType> replace_with,
-                   StringType* output) {
-  // Commonly, this is called with output and input being the same string; in
-  // that case, this assignment is inexpensive.
-  *output = input;
-
-  return DoReplaceMatchesAfterOffset(
-      output, 0, CharacterMatcher<StringType>{find_any_of_these}, replace_with,
-      ReplaceType::REPLACE_ALL);
-}
-
-void ReplaceFirstSubstringAfterOffset(string16* str,
-                                      size_t start_offset,
-                                      StringPiece16 find_this,
-                                      StringPiece16 replace_with) {
-  DoReplaceMatchesAfterOffset(str, start_offset,
-                              SubstringMatcher<string16>{find_this},
-                              replace_with, ReplaceType::REPLACE_FIRST);
-}
-
-void ReplaceFirstSubstringAfterOffset(std::string* str,
-                                      size_t start_offset,
-                                      StringPiece find_this,
-                                      StringPiece replace_with) {
-  DoReplaceMatchesAfterOffset(str, start_offset,
-                              SubstringMatcher<std::string>{find_this},
-                              replace_with, ReplaceType::REPLACE_FIRST);
-}
-
-void ReplaceSubstringsAfterOffset(string16* str,
-                                  size_t start_offset,
-                                  StringPiece16 find_this,
-                                  StringPiece16 replace_with) {
-  DoReplaceMatchesAfterOffset(str, start_offset,
-                              SubstringMatcher<string16>{find_this},
-                              replace_with, ReplaceType::REPLACE_ALL);
-}
-
-void ReplaceSubstringsAfterOffset(std::string* str,
-                                  size_t start_offset,
-                                  StringPiece find_this,
-                                  StringPiece replace_with) {
-  DoReplaceMatchesAfterOffset(str, start_offset,
-                              SubstringMatcher<std::string>{find_this},
-                              replace_with, ReplaceType::REPLACE_ALL);
-}
-
-template <class string_type>
-inline typename string_type::value_type* WriteIntoT(string_type* str,
-                                                    size_t length_with_null) {
-  DCHECK_GT(length_with_null, 1u);
-  str->reserve(length_with_null);
-  str->resize(length_with_null - 1);
-  return &((*str)[0]);
-}
-
-char* WriteInto(std::string* str, size_t length_with_null) {
-  return WriteIntoT(str, length_with_null);
-}
-
-char16* WriteInto(string16* str, size_t length_with_null) {
-  return WriteIntoT(str, length_with_null);
-}
-
-#if defined(_MSC_VER) && !defined(__clang__)
-// Work around VC++ code-gen bug. https://crbug.com/804884
-#pragma optimize("", off)
-#endif
-
-// Generic version for all JoinString overloads. |list_type| must be a sequence
-// (std::vector or std::initializer_list) of strings/StringPieces (std::string,
-// string16, StringPiece or StringPiece16). |string_type| is either std::string
-// or string16.
-template <typename list_type, typename string_type>
-static string_type JoinStringT(const list_type& parts,
-                               BasicStringPiece<string_type> sep) {
-  if (parts.size() == 0)
-    return string_type();
-
-  // Pre-allocate the eventual size of the string. Start with the size of all of
-  // the separators (note that this *assumes* parts.size() > 0).
-  size_t total_size = (parts.size() - 1) * sep.size();
-  for (const auto& part : parts)
-    total_size += part.size();
-  string_type result;
-  result.reserve(total_size);
-
-  auto iter = parts.begin();
-  DCHECK(iter != parts.end());
-  AppendToString(&result, *iter);
-  ++iter;
-
-  for (; iter != parts.end(); ++iter) {
-    sep.AppendToString(&result);
-    // Using the overloaded AppendToString allows this template function to work
-    // on both strings and StringPieces without creating an intermediate
-    // StringPiece object.
-    AppendToString(&result, *iter);
-  }
-
-  // Sanity-check that we pre-allocated correctly.
-  DCHECK_EQ(total_size, result.size());
-
-  return result;
-}
-
-std::string JoinString(const std::vector<std::string>& parts,
-                       StringPiece separator) {
-  return JoinStringT(parts, separator);
-}
-
-string16 JoinString(const std::vector<string16>& parts,
-                    StringPiece16 separator) {
-  return JoinStringT(parts, separator);
-}
-
-#if defined(_MSC_VER) && !defined(__clang__)
-// Work around VC++ code-gen bug. https://crbug.com/804884
-#pragma optimize("", on)
-#endif
-
-std::string JoinString(const std::vector<StringPiece>& parts,
-                       StringPiece separator) {
-  return JoinStringT(parts, separator);
-}
-
-string16 JoinString(const std::vector<StringPiece16>& parts,
-                    StringPiece16 separator) {
-  return JoinStringT(parts, separator);
-}
-
-std::string JoinString(std::initializer_list<StringPiece> parts,
-                       StringPiece separator) {
-  return JoinStringT(parts, separator);
-}
-
-string16 JoinString(std::initializer_list<StringPiece16> parts,
-                    StringPiece16 separator) {
-  return JoinStringT(parts, separator);
-}
-
-template<class FormatStringType, class OutStringType>
-OutStringType DoReplaceStringPlaceholders(
-    const FormatStringType& format_string,
-    const std::vector<OutStringType>& subst,
-    std::vector<size_t>* offsets) {
-  size_t substitutions = subst.size();
-  DCHECK_LT(substitutions, 10U);
-
-  size_t sub_length = 0;
-  for (const auto& cur : subst)
-    sub_length += cur.length();
-
-  OutStringType formatted;
-  formatted.reserve(format_string.length() + sub_length);
-
-  std::vector<ReplacementOffset> r_offsets;
-  for (auto i = format_string.begin(); i != format_string.end(); ++i) {
-    if ('$' == *i) {
-      if (i + 1 != format_string.end()) {
-        ++i;
-        if ('$' == *i) {
-          while (i != format_string.end() && '$' == *i) {
-            formatted.push_back('$');
-            ++i;
-          }
-          --i;
-        } else {
-          if (*i < '1' || *i > '9') {
-            DLOG(ERROR) << "Invalid placeholder: $" << *i;
-            continue;
-          }
-          uintptr_t index = *i - '1';
-          if (offsets) {
-            ReplacementOffset r_offset(index,
-                                       static_cast<int>(formatted.size()));
-            r_offsets.insert(
-                std::upper_bound(r_offsets.begin(), r_offsets.end(), r_offset,
-                                 &CompareParameter),
-                r_offset);
-          }
-          if (index < substitutions)
-            formatted.append(subst.at(index));
-        }
-      }
-    } else {
-      formatted.push_back(*i);
-    }
-  }
-  if (offsets) {
-    for (const auto& cur : r_offsets)
-      offsets->push_back(cur.offset);
-  }
-  return formatted;
-}
-
-string16 ReplaceStringPlaceholders(const string16& format_string,
-                                   const std::vector<string16>& subst,
-                                   std::vector<size_t>* offsets) {
-  return DoReplaceStringPlaceholders(format_string, subst, offsets);
-}
-
-std::string ReplaceStringPlaceholders(StringPiece format_string,
-                                      const std::vector<std::string>& subst,
-                                      std::vector<size_t>* offsets) {
-  return DoReplaceStringPlaceholders(format_string, subst, offsets);
-}
-
-string16 ReplaceStringPlaceholders(const string16& format_string,
-                                   const string16& a,
-                                   size_t* offset) {
-  std::vector<size_t> offsets;
-  std::vector<string16> subst;
-  subst.push_back(a);
-  string16 result = ReplaceStringPlaceholders(format_string, subst, &offsets);
-
-  DCHECK_EQ(1U, offsets.size());
-  if (offset)
-    *offset = offsets[0];
-  return result;
-}
-
-// The following code is compatible with the OpenBSD lcpy interface.  See:
-//   http://www.gratisoft.us/todd/papers/strlcpy.html
-//   ftp://ftp.openbsd.org/pub/OpenBSD/src/lib/libc/string/{wcs,str}lcpy.c
-
-namespace {
-
-template <typename CHAR>
-size_t lcpyT(CHAR* dst, const CHAR* src, size_t dst_size) {
-  for (size_t i = 0; i < dst_size; ++i) {
-    if ((dst[i] = src[i]) == 0)  // We hit and copied the terminating NULL.
-      return i;
-  }
-
-  // We were left off at dst_size.  We over copied 1 byte.  Null terminate.
-  if (dst_size != 0)
-    dst[dst_size - 1] = 0;
-
-  // Count the rest of the |src|, and return it's length in characters.
-  while (src[dst_size]) ++dst_size;
-  return dst_size;
-}
-
-}  // namespace
-
-size_t strlcpy(char* dst, const char* src, size_t dst_size) {
-  return lcpyT<char>(dst, src, dst_size);
-}
-size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size) {
-  return lcpyT<wchar_t>(dst, src, dst_size);
-}
-
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_util.h b/native/zucchini/vendor/libchrome/base/strings/string_util.h
deleted file mode 100644
index d6780ec..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/string_util.h
+++ /dev/null
@@ -1,485 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-// This file defines utility functions for working with strings.
-
-#ifndef BASE_STRINGS_STRING_UTIL_H_
-#define BASE_STRINGS_STRING_UTIL_H_
-
-#include <ctype.h>
-#include <stdarg.h>   // va_list
-#include <stddef.h>
-#include <stdint.h>
-
-#include <initializer_list>
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"  // For implicit conversions.
-#include "build/build_config.h"
-
-namespace base {
-
-// C standard-library functions that aren't cross-platform are provided as
-// "base::...", and their prototypes are listed below. These functions are
-// then implemented as inline calls to the platform-specific equivalents in the
-// platform-specific headers.
-
-// Wrapper for vsnprintf that always null-terminates and always returns the
-// number of characters that would be in an untruncated formatted
-// string, even when truncation occurs.
-int vsnprintf(char* buffer, size_t size, const char* format, va_list arguments)
-    PRINTF_FORMAT(3, 0);
-
-// Some of these implementations need to be inlined.
-
-// We separate the declaration from the implementation of this inline
-// function just so the PRINTF_FORMAT works.
-inline int snprintf(char* buffer,
-                    size_t size,
-                    _Printf_format_string_ const char* format,
-                    ...) PRINTF_FORMAT(3, 4);
-inline int snprintf(char* buffer,
-                    size_t size,
-                    _Printf_format_string_ const char* format,
-                    ...) {
-  va_list arguments;
-  va_start(arguments, format);
-  int result = vsnprintf(buffer, size, format, arguments);
-  va_end(arguments);
-  return result;
-}
-
-// BSD-style safe and consistent string copy functions.
-// Copies |src| to |dst|, where |dst_size| is the total allocated size of |dst|.
-// Copies at most |dst_size|-1 characters, and always NULL terminates |dst|, as
-// long as |dst_size| is not 0.  Returns the length of |src| in characters.
-// If the return value is >= dst_size, then the output was truncated.
-// NOTE: All sizes are in number of characters, NOT in bytes.
-BASE_EXPORT size_t strlcpy(char* dst, const char* src, size_t dst_size);
-BASE_EXPORT size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dst_size);
-
-// Scan a wprintf format string to determine whether it's portable across a
-// variety of systems.  This function only checks that the conversion
-// specifiers used by the format string are supported and have the same meaning
-// on a variety of systems.  It doesn't check for other errors that might occur
-// within a format string.
-//
-// Nonportable conversion specifiers for wprintf are:
-//  - 's' and 'c' without an 'l' length modifier.  %s and %c operate on char
-//     data on all systems except Windows, which treat them as wchar_t data.
-//     Use %ls and %lc for wchar_t data instead.
-//  - 'S' and 'C', which operate on wchar_t data on all systems except Windows,
-//     which treat them as char data.  Use %ls and %lc for wchar_t data
-//     instead.
-//  - 'F', which is not identified by Windows wprintf documentation.
-//  - 'D', 'O', and 'U', which are deprecated and not available on all systems.
-//     Use %ld, %lo, and %lu instead.
-//
-// Note that there is no portable conversion specifier for char data when
-// working with wprintf.
-//
-// This function is intended to be called from base::vswprintf.
-BASE_EXPORT bool IsWprintfFormatPortable(const wchar_t* format);
-
-// ASCII-specific tolower.  The standard library's tolower is locale sensitive,
-// so we don't want to use it here.
-inline char ToLowerASCII(char c) {
-  return (c >= 'A' && c <= 'Z') ? (c + ('a' - 'A')) : c;
-}
-inline char16 ToLowerASCII(char16 c) {
-  return (c >= 'A' && c <= 'Z') ? (c + ('a' - 'A')) : c;
-}
-
-// ASCII-specific toupper.  The standard library's toupper is locale sensitive,
-// so we don't want to use it here.
-inline char ToUpperASCII(char c) {
-  return (c >= 'a' && c <= 'z') ? (c + ('A' - 'a')) : c;
-}
-inline char16 ToUpperASCII(char16 c) {
-  return (c >= 'a' && c <= 'z') ? (c + ('A' - 'a')) : c;
-}
-
-// Converts the given string to it's ASCII-lowercase equivalent.
-BASE_EXPORT std::string ToLowerASCII(StringPiece str);
-BASE_EXPORT string16 ToLowerASCII(StringPiece16 str);
-
-// Converts the given string to it's ASCII-uppercase equivalent.
-BASE_EXPORT std::string ToUpperASCII(StringPiece str);
-BASE_EXPORT string16 ToUpperASCII(StringPiece16 str);
-
-// Functor for case-insensitive ASCII comparisons for STL algorithms like
-// std::search.
-//
-// Note that a full Unicode version of this functor is not possible to write
-// because case mappings might change the number of characters, depend on
-// context (combining accents), and require handling UTF-16. If you need
-// proper Unicode support, use base::i18n::ToLower/FoldCase and then just
-// use a normal operator== on the result.
-template<typename Char> struct CaseInsensitiveCompareASCII {
- public:
-  bool operator()(Char x, Char y) const {
-    return ToLowerASCII(x) == ToLowerASCII(y);
-  }
-};
-
-// Like strcasecmp for case-insensitive ASCII characters only. Returns:
-//   -1  (a < b)
-//    0  (a == b)
-//    1  (a > b)
-// (unlike strcasecmp which can return values greater or less than 1/-1). For
-// full Unicode support, use base::i18n::ToLower or base::i18h::FoldCase
-// and then just call the normal string operators on the result.
-BASE_EXPORT int CompareCaseInsensitiveASCII(StringPiece a, StringPiece b);
-BASE_EXPORT int CompareCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);
-
-// Equality for ASCII case-insensitive comparisons. For full Unicode support,
-// use base::i18n::ToLower or base::i18h::FoldCase and then compare with either
-// == or !=.
-BASE_EXPORT bool EqualsCaseInsensitiveASCII(StringPiece a, StringPiece b);
-BASE_EXPORT bool EqualsCaseInsensitiveASCII(StringPiece16 a, StringPiece16 b);
-
-// These threadsafe functions return references to globally unique empty
-// strings.
-//
-// It is likely faster to construct a new empty string object (just a few
-// instructions to set the length to 0) than to get the empty string singleton
-// returned by these functions (which requires threadsafe singleton access).
-//
-// Therefore, DO NOT USE THESE AS A GENERAL-PURPOSE SUBSTITUTE FOR DEFAULT
-// CONSTRUCTORS. There is only one case where you should use these: functions
-// which need to return a string by reference (e.g. as a class member
-// accessor), and don't have an empty string to use (e.g. in an error case).
-// These should not be used as initializers, function arguments, or return
-// values for functions which return by value or outparam.
-BASE_EXPORT const std::string& EmptyString();
-BASE_EXPORT const string16& EmptyString16();
-
-// Contains the set of characters representing whitespace in the corresponding
-// encoding. Null-terminated. The ASCII versions are the whitespaces as defined
-// by HTML5, and don't include control characters.
-BASE_EXPORT extern const wchar_t kWhitespaceWide[];  // Includes Unicode.
-BASE_EXPORT extern const char16 kWhitespaceUTF16[];  // Includes Unicode.
-BASE_EXPORT extern const char kWhitespaceASCII[];
-BASE_EXPORT extern const char16 kWhitespaceASCIIAs16[];  // No unicode.
-
-// Null-terminated string representing the UTF-8 byte order mark.
-BASE_EXPORT extern const char kUtf8ByteOrderMark[];
-
-// Removes characters in |remove_chars| from anywhere in |input|.  Returns true
-// if any characters were removed.  |remove_chars| must be null-terminated.
-// NOTE: Safe to use the same variable for both |input| and |output|.
-BASE_EXPORT bool RemoveChars(const string16& input,
-                             StringPiece16 remove_chars,
-                             string16* output);
-BASE_EXPORT bool RemoveChars(const std::string& input,
-                             StringPiece remove_chars,
-                             std::string* output);
-
-// Replaces characters in |replace_chars| from anywhere in |input| with
-// |replace_with|.  Each character in |replace_chars| will be replaced with
-// the |replace_with| string.  Returns true if any characters were replaced.
-// |replace_chars| must be null-terminated.
-// NOTE: Safe to use the same variable for both |input| and |output|.
-BASE_EXPORT bool ReplaceChars(const string16& input,
-                              StringPiece16 replace_chars,
-                              const string16& replace_with,
-                              string16* output);
-BASE_EXPORT bool ReplaceChars(const std::string& input,
-                              StringPiece replace_chars,
-                              const std::string& replace_with,
-                              std::string* output);
-
-enum TrimPositions {
-  TRIM_NONE     = 0,
-  TRIM_LEADING  = 1 << 0,
-  TRIM_TRAILING = 1 << 1,
-  TRIM_ALL      = TRIM_LEADING | TRIM_TRAILING,
-};
-
-// Removes characters in |trim_chars| from the beginning and end of |input|.
-// The 8-bit version only works on 8-bit characters, not UTF-8. Returns true if
-// any characters were removed.
-//
-// It is safe to use the same variable for both |input| and |output| (this is
-// the normal usage to trim in-place).
-BASE_EXPORT bool TrimString(const string16& input,
-                            StringPiece16 trim_chars,
-                            string16* output);
-BASE_EXPORT bool TrimString(const std::string& input,
-                            StringPiece trim_chars,
-                            std::string* output);
-
-// StringPiece versions of the above. The returned pieces refer to the original
-// buffer.
-BASE_EXPORT StringPiece16 TrimString(StringPiece16 input,
-                                     StringPiece16 trim_chars,
-                                     TrimPositions positions);
-BASE_EXPORT StringPiece TrimString(StringPiece input,
-                                   StringPiece trim_chars,
-                                   TrimPositions positions);
-
-// Truncates a string to the nearest UTF-8 character that will leave
-// the string less than or equal to the specified byte size.
-BASE_EXPORT void TruncateUTF8ToByteSize(const std::string& input,
-                                        const size_t byte_size,
-                                        std::string* output);
-
-// Trims any whitespace from either end of the input string.
-//
-// The StringPiece versions return a substring referencing the input buffer.
-// The ASCII versions look only for ASCII whitespace.
-//
-// The std::string versions return where whitespace was found.
-// NOTE: Safe to use the same variable for both input and output.
-BASE_EXPORT TrimPositions TrimWhitespace(const string16& input,
-                                         TrimPositions positions,
-                                         string16* output);
-BASE_EXPORT StringPiece16 TrimWhitespace(StringPiece16 input,
-                                         TrimPositions positions);
-BASE_EXPORT TrimPositions TrimWhitespaceASCII(const std::string& input,
-                                              TrimPositions positions,
-                                              std::string* output);
-BASE_EXPORT StringPiece TrimWhitespaceASCII(StringPiece input,
-                                            TrimPositions positions);
-
-// Searches for CR or LF characters.  Removes all contiguous whitespace
-// strings that contain them.  This is useful when trying to deal with text
-// copied from terminals.
-// Returns |text|, with the following three transformations:
-// (1) Leading and trailing whitespace is trimmed.
-// (2) If |trim_sequences_with_line_breaks| is true, any other whitespace
-//     sequences containing a CR or LF are trimmed.
-// (3) All other whitespace sequences are converted to single spaces.
-BASE_EXPORT string16 CollapseWhitespace(
-    const string16& text,
-    bool trim_sequences_with_line_breaks);
-BASE_EXPORT std::string CollapseWhitespaceASCII(
-    const std::string& text,
-    bool trim_sequences_with_line_breaks);
-
-// Returns true if |input| is empty or contains only characters found in
-// |characters|.
-BASE_EXPORT bool ContainsOnlyChars(StringPiece input, StringPiece characters);
-BASE_EXPORT bool ContainsOnlyChars(StringPiece16 input,
-                                   StringPiece16 characters);
-
-// Returns true if the specified string matches the criteria. How can a wide
-// string be 8-bit or UTF8? It contains only characters that are < 256 (in the
-// first case) or characters that use only 8-bits and whose 8-bit
-// representation looks like a UTF-8 string (the second case).
-//
-// Note that IsStringUTF8 checks not only if the input is structurally
-// valid but also if it doesn't contain any non-character codepoint
-// (e.g. U+FFFE). It's done on purpose because all the existing callers want
-// to have the maximum 'discriminating' power from other encodings. If
-// there's a use case for just checking the structural validity, we have to
-// add a new function for that.
-//
-// IsStringASCII assumes the input is likely all ASCII, and does not leave early
-// if it is not the case.
-BASE_EXPORT bool IsStringUTF8(StringPiece str);
-BASE_EXPORT bool IsStringASCII(StringPiece str);
-BASE_EXPORT bool IsStringASCII(StringPiece16 str);
-#if defined(WCHAR_T_IS_UTF32)
-BASE_EXPORT bool IsStringASCII(WStringPiece str);
-#endif
-
-// Compare the lower-case form of the given string against the given
-// previously-lower-cased ASCII string (typically a constant).
-BASE_EXPORT bool LowerCaseEqualsASCII(StringPiece str,
-                                      StringPiece lowecase_ascii);
-BASE_EXPORT bool LowerCaseEqualsASCII(StringPiece16 str,
-                                      StringPiece lowecase_ascii);
-
-// Performs a case-sensitive string compare of the given 16-bit string against
-// the given 8-bit ASCII string (typically a constant). The behavior is
-// undefined if the |ascii| string is not ASCII.
-BASE_EXPORT bool EqualsASCII(StringPiece16 str, StringPiece ascii);
-
-// Indicates case sensitivity of comparisons. Only ASCII case insensitivity
-// is supported. Full Unicode case-insensitive conversions would need to go in
-// base/i18n so it can use ICU.
-//
-// If you need to do Unicode-aware case-insensitive StartsWith/EndsWith, it's
-// best to call base::i18n::ToLower() or base::i18n::FoldCase() (see
-// base/i18n/case_conversion.h for usage advice) on the arguments, and then use
-// the results to a case-sensitive comparison.
-enum class CompareCase {
-  SENSITIVE,
-  INSENSITIVE_ASCII,
-};
-
-BASE_EXPORT bool StartsWith(StringPiece str,
-                            StringPiece search_for,
-                            CompareCase case_sensitivity);
-BASE_EXPORT bool StartsWith(StringPiece16 str,
-                            StringPiece16 search_for,
-                            CompareCase case_sensitivity);
-BASE_EXPORT bool EndsWith(StringPiece str,
-                          StringPiece search_for,
-                          CompareCase case_sensitivity);
-BASE_EXPORT bool EndsWith(StringPiece16 str,
-                          StringPiece16 search_for,
-                          CompareCase case_sensitivity);
-
-// Determines the type of ASCII character, independent of locale (the C
-// library versions will change based on locale).
-template <typename Char>
-inline bool IsAsciiWhitespace(Char c) {
-  return c == ' ' || c == '\r' || c == '\n' || c == '\t';
-}
-template <typename Char>
-inline bool IsAsciiAlpha(Char c) {
-  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
-}
-template <typename Char>
-inline bool IsAsciiUpper(Char c) {
-  return c >= 'A' && c <= 'Z';
-}
-template <typename Char>
-inline bool IsAsciiLower(Char c) {
-  return c >= 'a' && c <= 'z';
-}
-template <typename Char>
-inline bool IsAsciiDigit(Char c) {
-  return c >= '0' && c <= '9';
-}
-
-template <typename Char>
-inline bool IsHexDigit(Char c) {
-  return (c >= '0' && c <= '9') ||
-         (c >= 'A' && c <= 'F') ||
-         (c >= 'a' && c <= 'f');
-}
-
-// Returns the integer corresponding to the given hex character. For example:
-//    '4' -> 4
-//    'a' -> 10
-//    'B' -> 11
-// Assumes the input is a valid hex character. DCHECKs in debug builds if not.
-BASE_EXPORT char HexDigitToInt(wchar_t c);
-
-// Returns true if it's a Unicode whitespace character.
-BASE_EXPORT bool IsUnicodeWhitespace(wchar_t c);
-
-// Return a byte string in human-readable format with a unit suffix. Not
-// appropriate for use in any UI; use of FormatBytes and friends in ui/base is
-// highly recommended instead. TODO(avi): Figure out how to get callers to use
-// FormatBytes instead; remove this.
-BASE_EXPORT string16 FormatBytesUnlocalized(int64_t bytes);
-
-// Starting at |start_offset| (usually 0), replace the first instance of
-// |find_this| with |replace_with|.
-BASE_EXPORT void ReplaceFirstSubstringAfterOffset(
-    base::string16* str,
-    size_t start_offset,
-    StringPiece16 find_this,
-    StringPiece16 replace_with);
-BASE_EXPORT void ReplaceFirstSubstringAfterOffset(
-    std::string* str,
-    size_t start_offset,
-    StringPiece find_this,
-    StringPiece replace_with);
-
-// Starting at |start_offset| (usually 0), look through |str| and replace all
-// instances of |find_this| with |replace_with|.
-//
-// This does entire substrings; use std::replace in <algorithm> for single
-// characters, for example:
-//   std::replace(str.begin(), str.end(), 'a', 'b');
-BASE_EXPORT void ReplaceSubstringsAfterOffset(
-    string16* str,
-    size_t start_offset,
-    StringPiece16 find_this,
-    StringPiece16 replace_with);
-BASE_EXPORT void ReplaceSubstringsAfterOffset(
-    std::string* str,
-    size_t start_offset,
-    StringPiece find_this,
-    StringPiece replace_with);
-
-// Reserves enough memory in |str| to accommodate |length_with_null| characters,
-// sets the size of |str| to |length_with_null - 1| characters, and returns a
-// pointer to the underlying contiguous array of characters.  This is typically
-// used when calling a function that writes results into a character array, but
-// the caller wants the data to be managed by a string-like object.  It is
-// convenient in that is can be used inline in the call, and fast in that it
-// avoids copying the results of the call from a char* into a string.
-//
-// |length_with_null| must be at least 2, since otherwise the underlying string
-// would have size 0, and trying to access &((*str)[0]) in that case can result
-// in a number of problems.
-//
-// Internally, this takes linear time because the resize() call 0-fills the
-// underlying array for potentially all
-// (|length_with_null - 1| * sizeof(string_type::value_type)) bytes.  Ideally we
-// could avoid this aspect of the resize() call, as we expect the caller to
-// immediately write over this memory, but there is no other way to set the size
-// of the string, and not doing that will mean people who access |str| rather
-// than str.c_str() will get back a string of whatever size |str| had on entry
-// to this function (probably 0).
-BASE_EXPORT char* WriteInto(std::string* str, size_t length_with_null);
-BASE_EXPORT char16* WriteInto(string16* str, size_t length_with_null);
-
-// Does the opposite of SplitString()/SplitStringPiece(). Joins a vector or list
-// of strings into a single string, inserting |separator| (which may be empty)
-// in between all elements.
-//
-// If possible, callers should build a vector of StringPieces and use the
-// StringPiece variant, so that they do not create unnecessary copies of
-// strings. For example, instead of using SplitString, modifying the vector,
-// then using JoinString, use SplitStringPiece followed by JoinString so that no
-// copies of those strings are created until the final join operation.
-//
-// Use StrCat (in base/strings/strcat.h) if you don't need a separator.
-BASE_EXPORT std::string JoinString(const std::vector<std::string>& parts,
-                                   StringPiece separator);
-BASE_EXPORT string16 JoinString(const std::vector<string16>& parts,
-                                StringPiece16 separator);
-BASE_EXPORT std::string JoinString(const std::vector<StringPiece>& parts,
-                                   StringPiece separator);
-BASE_EXPORT string16 JoinString(const std::vector<StringPiece16>& parts,
-                                StringPiece16 separator);
-// Explicit initializer_list overloads are required to break ambiguity when used
-// with a literal initializer list (otherwise the compiler would not be able to
-// decide between the string and StringPiece overloads).
-BASE_EXPORT std::string JoinString(std::initializer_list<StringPiece> parts,
-                                   StringPiece separator);
-BASE_EXPORT string16 JoinString(std::initializer_list<StringPiece16> parts,
-                                StringPiece16 separator);
-
-// Replace $1-$2-$3..$9 in the format string with values from |subst|.
-// Additionally, any number of consecutive '$' characters is replaced by that
-// number less one. Eg $$->$, $$$->$$, etc. The offsets parameter here can be
-// NULL. This only allows you to use up to nine replacements.
-BASE_EXPORT string16 ReplaceStringPlaceholders(
-    const string16& format_string,
-    const std::vector<string16>& subst,
-    std::vector<size_t>* offsets);
-
-BASE_EXPORT std::string ReplaceStringPlaceholders(
-    StringPiece format_string,
-    const std::vector<std::string>& subst,
-    std::vector<size_t>* offsets);
-
-// Single-string shortcut for ReplaceStringHolders. |offset| may be NULL.
-BASE_EXPORT string16 ReplaceStringPlaceholders(const string16& format_string,
-                                               const string16& a,
-                                               size_t* offset);
-
-}  // namespace base
-
-#if defined(OS_WIN)
-#include "base/strings/string_util_win.h"
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include "base/strings/string_util_posix.h"
-#else
-#error Define string operations appropriately for your platform
-#endif
-
-#endif  // BASE_STRINGS_STRING_UTIL_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/string_util_posix.h b/native/zucchini/vendor/libchrome/base/strings/string_util_posix.h
deleted file mode 100644
index 8299118..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/string_util_posix.h
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_STRING_UTIL_POSIX_H_
-#define BASE_STRINGS_STRING_UTIL_POSIX_H_
-
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <string.h>
-#include <wchar.h>
-
-#include "base/logging.h"
-
-namespace base {
-
-// Chromium code style is to not use malloc'd strings; this is only for use
-// for interaction with APIs that require it.
-inline char* strdup(const char* str) {
-  return ::strdup(str);
-}
-
-inline int vsnprintf(char* buffer, size_t size,
-                     const char* format, va_list arguments) {
-  return ::vsnprintf(buffer, size, format, arguments);
-}
-
-inline int vswprintf(wchar_t* buffer, size_t size,
-                     const wchar_t* format, va_list arguments) {
-  DCHECK(IsWprintfFormatPortable(format));
-  return ::vswprintf(buffer, size, format, arguments);
-}
-
-}  // namespace base
-
-#endif  // BASE_STRINGS_STRING_UTIL_POSIX_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/stringprintf.cc b/native/zucchini/vendor/libchrome/base/strings/stringprintf.cc
deleted file mode 100644
index 415845d..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/stringprintf.cc
+++ /dev/null
@@ -1,189 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/strings/stringprintf.h"
-
-#include <errno.h>
-#include <stddef.h>
-
-#include <vector>
-
-#include "base/macros.h"
-#include "base/scoped_clear_errno.h"
-#include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
-#include "build/build_config.h"
-
-namespace base {
-
-namespace {
-
-// Overloaded wrappers around vsnprintf and vswprintf. The buf_size parameter
-// is the size of the buffer. These return the number of characters in the
-// formatted string excluding the NUL terminator. If the buffer is not
-// large enough to accommodate the formatted string without truncation, they
-// return the number of characters that would be in the fully-formatted string
-// (vsnprintf, and vswprintf on Windows), or -1 (vswprintf on POSIX platforms).
-inline int vsnprintfT(char* buffer,
-                      size_t buf_size,
-                      const char* format,
-                      va_list argptr) {
-  return base::vsnprintf(buffer, buf_size, format, argptr);
-}
-
-#if defined(OS_WIN)
-inline int vsnprintfT(wchar_t* buffer,
-                      size_t buf_size,
-                      const wchar_t* format,
-                      va_list argptr) {
-  return base::vswprintf(buffer, buf_size, format, argptr);
-}
-#endif
-
-// Templatized backend for StringPrintF/StringAppendF. This does not finalize
-// the va_list, the caller is expected to do that.
-template <class StringType>
-static void StringAppendVT(StringType* dst,
-                           const typename StringType::value_type* format,
-                           va_list ap) {
-  // First try with a small fixed size buffer.
-  // This buffer size should be kept in sync with StringUtilTest.GrowBoundary
-  // and StringUtilTest.StringPrintfBounds.
-  typename StringType::value_type stack_buf[1024];
-
-  va_list ap_copy;
-  va_copy(ap_copy, ap);
-
-#if !defined(OS_WIN)
-  ScopedClearErrno clear_errno;
-#endif
-  int result = vsnprintfT(stack_buf, arraysize(stack_buf), format, ap_copy);
-  va_end(ap_copy);
-
-  if (result >= 0 && result < static_cast<int>(arraysize(stack_buf))) {
-    // It fit.
-    dst->append(stack_buf, result);
-    return;
-  }
-
-  // Repeatedly increase buffer size until it fits.
-  int mem_length = arraysize(stack_buf);
-  while (true) {
-    if (result < 0) {
-#if defined(OS_WIN)
-      // On Windows, vsnprintfT always returns the number of characters in a
-      // fully-formatted string, so if we reach this point, something else is
-      // wrong and no amount of buffer-doubling is going to fix it.
-      return;
-#else
-      if (errno != 0 && errno != EOVERFLOW)
-        return;
-      // Try doubling the buffer size.
-      mem_length *= 2;
-#endif
-    } else {
-      // We need exactly "result + 1" characters.
-      mem_length = result + 1;
-    }
-
-    if (mem_length > 32 * 1024 * 1024) {
-      // That should be plenty, don't try anything larger.  This protects
-      // against huge allocations when using vsnprintfT implementations that
-      // return -1 for reasons other than overflow without setting errno.
-      DLOG(WARNING) << "Unable to printf the requested string due to size.";
-      return;
-    }
-
-    std::vector<typename StringType::value_type> mem_buf(mem_length);
-
-    // NOTE: You can only use a va_list once.  Since we're in a while loop, we
-    // need to make a new copy each time so we don't use up the original.
-    va_copy(ap_copy, ap);
-    result = vsnprintfT(&mem_buf[0], mem_length, format, ap_copy);
-    va_end(ap_copy);
-
-    if ((result >= 0) && (result < mem_length)) {
-      // It fit.
-      dst->append(&mem_buf[0], result);
-      return;
-    }
-  }
-}
-
-}  // namespace
-
-std::string StringPrintf(const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  std::string result;
-  StringAppendV(&result, format, ap);
-  va_end(ap);
-  return result;
-}
-
-#if defined(OS_WIN)
-std::wstring StringPrintf(const wchar_t* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  std::wstring result;
-  StringAppendV(&result, format, ap);
-  va_end(ap);
-  return result;
-}
-#endif
-
-std::string StringPrintV(const char* format, va_list ap) {
-  std::string result;
-  StringAppendV(&result, format, ap);
-  return result;
-}
-
-const std::string& SStringPrintf(std::string* dst, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  dst->clear();
-  StringAppendV(dst, format, ap);
-  va_end(ap);
-  return *dst;
-}
-
-#if defined(OS_WIN)
-const std::wstring& SStringPrintf(std::wstring* dst,
-                                  const wchar_t* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  dst->clear();
-  StringAppendV(dst, format, ap);
-  va_end(ap);
-  return *dst;
-}
-#endif
-
-void StringAppendF(std::string* dst, const char* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  StringAppendV(dst, format, ap);
-  va_end(ap);
-}
-
-#if defined(OS_WIN)
-void StringAppendF(std::wstring* dst, const wchar_t* format, ...) {
-  va_list ap;
-  va_start(ap, format);
-  StringAppendV(dst, format, ap);
-  va_end(ap);
-}
-#endif
-
-void StringAppendV(std::string* dst, const char* format, va_list ap) {
-  StringAppendVT(dst, format, ap);
-}
-
-#if defined(OS_WIN)
-void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap) {
-  StringAppendVT(dst, format, ap);
-}
-#endif
-
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/strings/stringprintf.h b/native/zucchini/vendor/libchrome/base/strings/stringprintf.h
deleted file mode 100644
index 7a75d89..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/stringprintf.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright 2013 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_STRINGPRINTF_H_
-#define BASE_STRINGS_STRINGPRINTF_H_
-
-#include <stdarg.h>   // va_list
-
-#include <string>
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "build/build_config.h"
-
-namespace base {
-
-// Return a C++ string given printf-like input.
-BASE_EXPORT std::string StringPrintf(_Printf_format_string_ const char* format,
-                                     ...)
-    PRINTF_FORMAT(1, 2) WARN_UNUSED_RESULT;
-#if defined(OS_WIN)
-BASE_EXPORT std::wstring StringPrintf(
-    _Printf_format_string_ const wchar_t* format,
-    ...) WPRINTF_FORMAT(1, 2) WARN_UNUSED_RESULT;
-#endif
-
-// Return a C++ string given vprintf-like input.
-BASE_EXPORT std::string StringPrintV(const char* format, va_list ap)
-    PRINTF_FORMAT(1, 0) WARN_UNUSED_RESULT;
-
-// Store result into a supplied string and return it.
-BASE_EXPORT const std::string& SStringPrintf(
-    std::string* dst,
-    _Printf_format_string_ const char* format,
-    ...) PRINTF_FORMAT(2, 3);
-#if defined(OS_WIN)
-BASE_EXPORT const std::wstring& SStringPrintf(
-    std::wstring* dst,
-    _Printf_format_string_ const wchar_t* format,
-    ...) WPRINTF_FORMAT(2, 3);
-#endif
-
-// Append result to a supplied string.
-BASE_EXPORT void StringAppendF(std::string* dst,
-                               _Printf_format_string_ const char* format,
-                               ...) PRINTF_FORMAT(2, 3);
-#if defined(OS_WIN)
-BASE_EXPORT void StringAppendF(std::wstring* dst,
-                               _Printf_format_string_ const wchar_t* format,
-                               ...) WPRINTF_FORMAT(2, 3);
-#endif
-
-// Lower-level routine that takes a va_list and appends to a specified
-// string.  All other routines are just convenience wrappers around it.
-BASE_EXPORT void StringAppendV(std::string* dst, const char* format, va_list ap)
-    PRINTF_FORMAT(2, 0);
-#if defined(OS_WIN)
-BASE_EXPORT void StringAppendV(std::wstring* dst,
-                               const wchar_t* format, va_list ap)
-    WPRINTF_FORMAT(2, 0);
-#endif
-
-}  // namespace base
-
-#endif  // BASE_STRINGS_STRINGPRINTF_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/sys_string_conversions.h b/native/zucchini/vendor/libchrome/base/strings/sys_string_conversions.h
deleted file mode 100644
index 1ad0307..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/sys_string_conversions.h
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_SYS_STRING_CONVERSIONS_H_
-#define BASE_STRINGS_SYS_STRING_CONVERSIONS_H_
-
-// Provides system-dependent string type conversions for cases where it's
-// necessary to not use ICU. Generally, you should not need this in Chrome,
-// but it is used in some shared code. Dependencies should be minimal.
-
-#include <stdint.h>
-
-#include <string>
-
-#include "base/base_export.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-#include "build/build_config.h"
-
-#if defined(OS_MACOSX)
-#include <CoreFoundation/CoreFoundation.h>
-#ifdef __OBJC__
-@class NSString;
-#else
-class NSString;
-#endif
-#endif  // OS_MACOSX
-
-namespace base {
-
-// Converts between wide and UTF-8 representations of a string. On error, the
-// result is system-dependent.
-BASE_EXPORT std::string SysWideToUTF8(const std::wstring& wide);
-BASE_EXPORT std::wstring SysUTF8ToWide(StringPiece utf8);
-
-// Converts between wide and the system multi-byte representations of a string.
-// DANGER: This will lose information and can change (on Windows, this can
-// change between reboots).
-BASE_EXPORT std::string SysWideToNativeMB(const std::wstring& wide);
-BASE_EXPORT std::wstring SysNativeMBToWide(StringPiece native_mb);
-
-// Windows-specific ------------------------------------------------------------
-
-#if defined(OS_WIN)
-
-// Converts between 8-bit and wide strings, using the given code page. The
-// code page identifier is one accepted by the Windows function
-// MultiByteToWideChar().
-BASE_EXPORT std::wstring SysMultiByteToWide(StringPiece mb, uint32_t code_page);
-BASE_EXPORT std::string SysWideToMultiByte(const std::wstring& wide,
-                                           uint32_t code_page);
-
-#endif  // defined(OS_WIN)
-
-// Mac-specific ----------------------------------------------------------------
-
-#if defined(OS_MACOSX)
-
-// Converts between STL strings and CFStringRefs/NSStrings.
-
-// Creates a string, and returns it with a refcount of 1. You are responsible
-// for releasing it. Returns NULL on failure.
-BASE_EXPORT CFStringRef SysUTF8ToCFStringRef(const std::string& utf8);
-BASE_EXPORT CFStringRef SysUTF16ToCFStringRef(const string16& utf16);
-
-// Same, but returns an autoreleased NSString.
-BASE_EXPORT NSString* SysUTF8ToNSString(const std::string& utf8);
-BASE_EXPORT NSString* SysUTF16ToNSString(const string16& utf16);
-
-// Converts a CFStringRef to an STL string. Returns an empty string on failure.
-BASE_EXPORT std::string SysCFStringRefToUTF8(CFStringRef ref);
-BASE_EXPORT string16 SysCFStringRefToUTF16(CFStringRef ref);
-
-// Same, but accepts NSString input. Converts nil NSString* to the appropriate
-// string type of length 0.
-BASE_EXPORT std::string SysNSStringToUTF8(NSString* ref);
-BASE_EXPORT string16 SysNSStringToUTF16(NSString* ref);
-
-#endif  // defined(OS_MACOSX)
-
-}  // namespace base
-
-#endif  // BASE_STRINGS_SYS_STRING_CONVERSIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/utf_string_conversion_utils.h b/native/zucchini/vendor/libchrome/base/strings/utf_string_conversion_utils.h
deleted file mode 100644
index 2d95870..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/utf_string_conversion_utils.h
+++ /dev/null
@@ -1,100 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_UTF_STRING_CONVERSION_UTILS_H_
-#define BASE_STRINGS_UTF_STRING_CONVERSION_UTILS_H_
-
-// Low-level UTF handling functions. Most code will want to use the functions
-// in utf_string_conversions.h
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/base_export.h"
-#include "base/strings/string16.h"
-
-namespace base {
-
-inline bool IsValidCodepoint(uint32_t code_point) {
-  // Excludes the surrogate code points ([0xD800, 0xDFFF]) and
-  // codepoints larger than 0x10FFFF (the highest codepoint allowed).
-  // Non-characters and unassigned codepoints are allowed.
-  return code_point < 0xD800u ||
-         (code_point >= 0xE000u && code_point <= 0x10FFFFu);
-}
-
-inline bool IsValidCharacter(uint32_t code_point) {
-  // Excludes non-characters (U+FDD0..U+FDEF, and all codepoints ending in
-  // 0xFFFE or 0xFFFF) from the set of valid code points.
-  return code_point < 0xD800u || (code_point >= 0xE000u &&
-      code_point < 0xFDD0u) || (code_point > 0xFDEFu &&
-      code_point <= 0x10FFFFu && (code_point & 0xFFFEu) != 0xFFFEu);
-}
-
-// ReadUnicodeCharacter --------------------------------------------------------
-
-// Reads a UTF-8 stream, placing the next code point into the given output
-// |*code_point|. |src| represents the entire string to read, and |*char_index|
-// is the character offset within the string to start reading at. |*char_index|
-// will be updated to index the last character read, such that incrementing it
-// (as in a for loop) will take the reader to the next character.
-//
-// Returns true on success. On false, |*code_point| will be invalid.
-BASE_EXPORT bool ReadUnicodeCharacter(const char* src,
-                                      int32_t src_len,
-                                      int32_t* char_index,
-                                      uint32_t* code_point_out);
-
-// Reads a UTF-16 character. The usage is the same as the 8-bit version above.
-BASE_EXPORT bool ReadUnicodeCharacter(const char16* src,
-                                      int32_t src_len,
-                                      int32_t* char_index,
-                                      uint32_t* code_point);
-
-#if defined(WCHAR_T_IS_UTF32)
-// Reads UTF-32 character. The usage is the same as the 8-bit version above.
-BASE_EXPORT bool ReadUnicodeCharacter(const wchar_t* src,
-                                      int32_t src_len,
-                                      int32_t* char_index,
-                                      uint32_t* code_point);
-#endif  // defined(WCHAR_T_IS_UTF32)
-
-// WriteUnicodeCharacter -------------------------------------------------------
-
-// Appends a UTF-8 character to the given 8-bit string.  Returns the number of
-// bytes written.
-BASE_EXPORT size_t WriteUnicodeCharacter(uint32_t code_point,
-                                         std::string* output);
-
-// Appends the given code point as a UTF-16 character to the given 16-bit
-// string.  Returns the number of 16-bit values written.
-BASE_EXPORT size_t WriteUnicodeCharacter(uint32_t code_point, string16* output);
-
-#if defined(WCHAR_T_IS_UTF32)
-// Appends the given UTF-32 character to the given 32-bit string.  Returns the
-// number of 32-bit values written.
-inline size_t WriteUnicodeCharacter(uint32_t code_point, std::wstring* output) {
-  // This is the easy case, just append the character.
-  output->push_back(code_point);
-  return 1;
-}
-#endif  // defined(WCHAR_T_IS_UTF32)
-
-// Generalized Unicode converter -----------------------------------------------
-
-// Guesses the length of the output in UTF-8 in bytes, clears that output
-// string, and reserves that amount of space.  We assume that the input
-// character types are unsigned, which will be true for UTF-16 and -32 on our
-// systems.
-template<typename CHAR>
-void PrepareForUTF8Output(const CHAR* src, size_t src_len, std::string* output);
-
-// Prepares an output buffer (containing either UTF-16 or -32 data) given some
-// UTF-8 input that will be converted to it.  See PrepareForUTF8Output().
-template<typename STRING>
-void PrepareForUTF16Or32Output(const char* src, size_t src_len, STRING* output);
-
-}  // namespace base
-
-#endif  // BASE_STRINGS_UTF_STRING_CONVERSION_UTILS_H_
diff --git a/native/zucchini/vendor/libchrome/base/strings/utf_string_conversions.h b/native/zucchini/vendor/libchrome/base/strings/utf_string_conversions.h
deleted file mode 100644
index 14f94ac..0000000
--- a/native/zucchini/vendor/libchrome/base/strings/utf_string_conversions.h
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_STRINGS_UTF_STRING_CONVERSIONS_H_
-#define BASE_STRINGS_UTF_STRING_CONVERSIONS_H_
-
-#include <stddef.h>
-
-#include <string>
-
-#include "base/base_export.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_piece.h"
-
-namespace base {
-
-// These convert between UTF-8, -16, and -32 strings. They are potentially slow,
-// so avoid unnecessary conversions. The low-level versions return a boolean
-// indicating whether the conversion was 100% valid. In this case, it will still
-// do the best it can and put the result in the output buffer. The versions that
-// return strings ignore this error and just return the best conversion
-// possible.
-BASE_EXPORT bool WideToUTF8(const wchar_t* src, size_t src_len,
-                            std::string* output);
-BASE_EXPORT std::string WideToUTF8(WStringPiece wide);
-BASE_EXPORT bool UTF8ToWide(const char* src, size_t src_len,
-                            std::wstring* output);
-BASE_EXPORT std::wstring UTF8ToWide(StringPiece utf8);
-
-BASE_EXPORT bool WideToUTF16(const wchar_t* src, size_t src_len,
-                             string16* output);
-BASE_EXPORT string16 WideToUTF16(WStringPiece wide);
-BASE_EXPORT bool UTF16ToWide(const char16* src, size_t src_len,
-                             std::wstring* output);
-BASE_EXPORT std::wstring UTF16ToWide(StringPiece16 utf16);
-
-BASE_EXPORT bool UTF8ToUTF16(const char* src, size_t src_len, string16* output);
-BASE_EXPORT string16 UTF8ToUTF16(StringPiece utf8);
-BASE_EXPORT bool UTF16ToUTF8(const char16* src, size_t src_len,
-                             std::string* output);
-BASE_EXPORT std::string UTF16ToUTF8(StringPiece16 utf16);
-
-// This converts an ASCII string, typically a hardcoded constant, to a UTF16
-// string.
-BASE_EXPORT string16 ASCIIToUTF16(StringPiece ascii);
-
-// Converts to 7-bit ASCII by truncating. The result must be known to be ASCII
-// beforehand.
-BASE_EXPORT std::string UTF16ToASCII(StringPiece16 utf16);
-
-}  // namespace base
-
-#endif  // BASE_STRINGS_UTF_STRING_CONVERSIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/synchronization/lock.h b/native/zucchini/vendor/libchrome/base/synchronization/lock.h
deleted file mode 100644
index d1c647c..0000000
--- a/native/zucchini/vendor/libchrome/base/synchronization/lock.h
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_SYNCHRONIZATION_LOCK_H_
-#define BASE_SYNCHRONIZATION_LOCK_H_
-
-#include "base/base_export.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/synchronization/lock_impl.h"
-#include "base/threading/platform_thread.h"
-#include "build/build_config.h"
-
-namespace base {
-
-// A convenient wrapper for an OS specific critical section.  The only real
-// intelligence in this class is in debug mode for the support for the
-// AssertAcquired() method.
-class BASE_EXPORT Lock {
- public:
-#if !DCHECK_IS_ON()
-   // Optimized wrapper implementation
-  Lock() : lock_() {}
-  ~Lock() {}
-  void Acquire() { lock_.Lock(); }
-  void Release() { lock_.Unlock(); }
-
-  // If the lock is not held, take it and return true. If the lock is already
-  // held by another thread, immediately return false. This must not be called
-  // by a thread already holding the lock (what happens is undefined and an
-  // assertion may fail).
-  bool Try() { return lock_.Try(); }
-
-  // Null implementation if not debug.
-  void AssertAcquired() const {}
-#else
-  Lock();
-  ~Lock();
-
-  // NOTE: We do not permit recursive locks and will commonly fire a DCHECK() if
-  // a thread attempts to acquire the lock a second time (while already holding
-  // it).
-  void Acquire() {
-    lock_.Lock();
-    CheckUnheldAndMark();
-  }
-  void Release() {
-    CheckHeldAndUnmark();
-    lock_.Unlock();
-  }
-
-  bool Try() {
-    bool rv = lock_.Try();
-    if (rv) {
-      CheckUnheldAndMark();
-    }
-    return rv;
-  }
-
-  void AssertAcquired() const;
-#endif  // DCHECK_IS_ON()
-
-  // Whether Lock mitigates priority inversion when used from different thread
-  // priorities.
-  static bool HandlesMultipleThreadPriorities() {
-#if defined(OS_WIN)
-    // Windows mitigates priority inversion by randomly boosting the priority of
-    // ready threads.
-    // https://msdn.microsoft.com/library/windows/desktop/ms684831.aspx
-    return true;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-    // POSIX mitigates priority inversion by setting the priority of a thread
-    // holding a Lock to the maximum priority of any other thread waiting on it.
-    return internal::LockImpl::PriorityInheritanceAvailable();
-#else
-#error Unsupported platform
-#endif
-  }
-
-  // Both Windows and POSIX implementations of ConditionVariable need to be
-  // able to see our lock and tweak our debugging counters, as they release and
-  // acquire locks inside of their condition variable APIs.
-  friend class ConditionVariable;
-
- private:
-#if DCHECK_IS_ON()
-  // Members and routines taking care of locks assertions.
-  // Note that this checks for recursive locks and allows them
-  // if the variable is set.  This is allowed by the underlying implementation
-  // on windows but not on Posix, so we're doing unneeded checks on Posix.
-  // It's worth it to share the code.
-  void CheckHeldAndUnmark();
-  void CheckUnheldAndMark();
-
-  // All private data is implicitly protected by lock_.
-  // Be VERY careful to only access members under that lock.
-  base::PlatformThreadRef owning_thread_ref_;
-#endif  // DCHECK_IS_ON()
-
-  // Platform specific underlying lock implementation.
-  internal::LockImpl lock_;
-
-  DISALLOW_COPY_AND_ASSIGN(Lock);
-};
-
-// A helper class that acquires the given Lock while the AutoLock is in scope.
-class AutoLock {
- public:
-  struct AlreadyAcquired {};
-
-  explicit AutoLock(Lock& lock) : lock_(lock) {
-    lock_.Acquire();
-  }
-
-  AutoLock(Lock& lock, const AlreadyAcquired&) : lock_(lock) {
-    lock_.AssertAcquired();
-  }
-
-  ~AutoLock() {
-    lock_.AssertAcquired();
-    lock_.Release();
-  }
-
- private:
-  Lock& lock_;
-  DISALLOW_COPY_AND_ASSIGN(AutoLock);
-};
-
-// AutoUnlock is a helper that will Release() the |lock| argument in the
-// constructor, and re-Acquire() it in the destructor.
-class AutoUnlock {
- public:
-  explicit AutoUnlock(Lock& lock) : lock_(lock) {
-    // We require our caller to have the lock.
-    lock_.AssertAcquired();
-    lock_.Release();
-  }
-
-  ~AutoUnlock() {
-    lock_.Acquire();
-  }
-
- private:
-  Lock& lock_;
-  DISALLOW_COPY_AND_ASSIGN(AutoUnlock);
-};
-
-}  // namespace base
-
-#endif  // BASE_SYNCHRONIZATION_LOCK_H_
diff --git a/native/zucchini/vendor/libchrome/base/synchronization/lock_impl.h b/native/zucchini/vendor/libchrome/base/synchronization/lock_impl.h
deleted file mode 100644
index 221d763..0000000
--- a/native/zucchini/vendor/libchrome/base/synchronization/lock_impl.h
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_SYNCHRONIZATION_LOCK_IMPL_H_
-#define BASE_SYNCHRONIZATION_LOCK_IMPL_H_
-
-#include "base/base_export.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include "base/win/windows_types.h"
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <errno.h>
-#include <pthread.h>
-#endif
-
-namespace base {
-namespace internal {
-
-// This class implements the underlying platform-specific spin-lock mechanism
-// used for the Lock class.  Most users should not use LockImpl directly, but
-// should instead use Lock.
-class BASE_EXPORT LockImpl {
- public:
-#if defined(OS_WIN)
-  using NativeHandle = CHROME_SRWLOCK;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  using NativeHandle = pthread_mutex_t;
-#endif
-
-  LockImpl();
-  ~LockImpl();
-
-  // If the lock is not held, take it and return true.  If the lock is already
-  // held by something else, immediately return false.
-  bool Try();
-
-  // Take the lock, blocking until it is available if necessary.
-  void Lock();
-
-  // Release the lock.  This must only be called by the lock's holder: after
-  // a successful call to Try, or a call to Lock.
-  inline void Unlock();
-
-  // Return the native underlying lock.
-  // TODO(awalker): refactor lock and condition variables so that this is
-  // unnecessary.
-  NativeHandle* native_handle() { return &native_handle_; }
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-  // Whether this lock will attempt to use priority inheritance.
-  static bool PriorityInheritanceAvailable();
-#endif
-
- private:
-  NativeHandle native_handle_;
-
-  DISALLOW_COPY_AND_ASSIGN(LockImpl);
-};
-
-#if defined(OS_WIN)
-void LockImpl::Unlock() {
-  ::ReleaseSRWLockExclusive(reinterpret_cast<PSRWLOCK>(&native_handle_));
-}
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-void LockImpl::Unlock() {
-  int rv = pthread_mutex_unlock(&native_handle_);
-  DCHECK_EQ(rv, 0) << ". " << strerror(rv);
-}
-#endif
-
-}  // namespace internal
-}  // namespace base
-
-#endif  // BASE_SYNCHRONIZATION_LOCK_IMPL_H_
diff --git a/native/zucchini/vendor/libchrome/base/synchronization/lock_impl_posix.cc b/native/zucchini/vendor/libchrome/base/synchronization/lock_impl_posix.cc
deleted file mode 100644
index 7571f68..0000000
--- a/native/zucchini/vendor/libchrome/base/synchronization/lock_impl_posix.cc
+++ /dev/null
@@ -1,133 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/synchronization/lock_impl.h"
-
-#include <string>
-
-#include "base/debug/activity_tracker.h"
-#include "base/logging.h"
-#include "base/posix/safe_strerror.h"
-#include "base/strings/stringprintf.h"
-#include "base/synchronization/lock.h"
-#include "base/synchronization/synchronization_buildflags.h"
-#include "build/build_config.h"
-
-namespace base {
-namespace internal {
-
-namespace {
-
-#if DCHECK_IS_ON()
-const char* AdditionalHintForSystemErrorCode(int error_code) {
-  switch (error_code) {
-    case EINVAL:
-      return "Hint: This is often related to a use-after-free.";
-    default:
-      return "";
-  }
-}
-#endif  // DCHECK_IS_ON()
-
-std::string SystemErrorCodeToString(int error_code) {
-#if DCHECK_IS_ON()
-  return base::safe_strerror(error_code) + ". " +
-         AdditionalHintForSystemErrorCode(error_code);
-#else   // DCHECK_IS_ON()
-  return std::string();
-#endif  // DCHECK_IS_ON()
-}
-
-}  // namespace
-
-// Determines which platforms can consider using priority inheritance locks. Use
-// this define for platform code that may not compile if priority inheritance
-// locks aren't available. For this platform code,
-// PRIORITY_INHERITANCE_LOCKS_POSSIBLE() is a necessary but insufficient check.
-// Lock::PriorityInheritanceAvailable still must be checked as the code may
-// compile but the underlying platform still may not correctly support priority
-// inheritance locks.
-#if defined(OS_NACL) || defined(OS_ANDROID) || defined(OS_FUCHSIA)
-#define PRIORITY_INHERITANCE_LOCKS_POSSIBLE() 0
-#else
-#define PRIORITY_INHERITANCE_LOCKS_POSSIBLE() 1
-#endif
-
-LockImpl::LockImpl() {
-  pthread_mutexattr_t mta;
-  int rv = pthread_mutexattr_init(&mta);
-  DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
-#if PRIORITY_INHERITANCE_LOCKS_POSSIBLE()
-  if (PriorityInheritanceAvailable()) {
-    rv = pthread_mutexattr_setprotocol(&mta, PTHREAD_PRIO_INHERIT);
-    DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
-  }
-#endif
-#ifndef NDEBUG
-  // In debug, setup attributes for lock error checking.
-  rv = pthread_mutexattr_settype(&mta, PTHREAD_MUTEX_ERRORCHECK);
-  DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
-#endif
-  rv = pthread_mutex_init(&native_handle_, &mta);
-  DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
-  rv = pthread_mutexattr_destroy(&mta);
-  DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
-}
-
-LockImpl::~LockImpl() {
-  int rv = pthread_mutex_destroy(&native_handle_);
-  DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
-}
-
-bool LockImpl::Try() {
-  int rv = pthread_mutex_trylock(&native_handle_);
-  DCHECK(rv == 0 || rv == EBUSY) << ". " << SystemErrorCodeToString(rv);
-  return rv == 0;
-}
-
-void LockImpl::Lock() {
-  // The ScopedLockAcquireActivity below is relatively expensive and so its
-  // actions can become significant due to the very large number of locks
-  // that tend to be used throughout the build. To avoid this cost in the
-  // vast majority of the calls, simply "try" the lock first and only do the
-  // (tracked) blocking call if that fails. Since "try" itself is a system
-  // call, and thus also somewhat expensive, don't bother with it unless
-  // tracking is actually enabled.
-  if (base::debug::GlobalActivityTracker::IsEnabled())
-    if (Try())
-      return;
-
-  base::debug::ScopedLockAcquireActivity lock_activity(this);
-  int rv = pthread_mutex_lock(&native_handle_);
-  DCHECK_EQ(rv, 0) << ". " << SystemErrorCodeToString(rv);
-}
-
-// static
-bool LockImpl::PriorityInheritanceAvailable() {
-#if BUILDFLAG(ENABLE_MUTEX_PRIORITY_INHERITANCE)
-  return true;
-#elif PRIORITY_INHERITANCE_LOCKS_POSSIBLE() && defined(OS_MACOSX)
-  return true;
-#else
-  // Security concerns prevent the use of priority inheritance mutexes on Linux.
-  //   * CVE-2010-0622 - Linux < 2.6.33-rc7, wake_futex_pi possible DoS.
-  //     https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2010-0622
-  //   * CVE-2012-6647 - Linux < 3.5.1, futex_wait_requeue_pi possible DoS.
-  //     https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2012-6647
-  //   * CVE-2014-3153 - Linux <= 3.14.5, futex_requeue, privilege escalation.
-  //     https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2014-3153
-  //
-  // If the above were all addressed, we still need a runtime check to deal with
-  // the bug below.
-  //   * glibc Bug 14652: https://sourceware.org/bugzilla/show_bug.cgi?id=14652
-  //     Fixed in glibc 2.17.
-  //     Priority inheritance mutexes may deadlock with condition variables
-  //     during reacquisition of the mutex after the condition variable is
-  //     signalled.
-  return false;
-#endif
-}
-
-}  // namespace internal
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/synchronization/synchronization_buildflags.h b/native/zucchini/vendor/libchrome/base/synchronization/synchronization_buildflags.h
deleted file mode 100644
index 98941f4..0000000
--- a/native/zucchini/vendor/libchrome/base/synchronization/synchronization_buildflags.h
+++ /dev/null
@@ -1,4 +0,0 @@
-#ifndef BASE_SYNCHRONIZATION_BUILDFLAGS_H_
-#define BASE_SYNCHRONIZATION_BUILDFLAGS_H_
-#include "build/buildflag.h"
-#endif  // BASE_SYNCHRONIZATION_BUILDFLAGS_H_
diff --git a/native/zucchini/vendor/libchrome/base/sys_info.h b/native/zucchini/vendor/libchrome/base/sys_info.h
deleted file mode 100644
index 36bf565..0000000
--- a/native/zucchini/vendor/libchrome/base/sys_info.h
+++ /dev/null
@@ -1,179 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_SYS_INFO_H_
-#define BASE_SYS_INFO_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/files/file_path.h"
-#include "base/gtest_prod_util.h"
-#include "base/time/time.h"
-#include "build/build_config.h"
-
-namespace base {
-
-namespace debug {
-FORWARD_DECLARE_TEST(SystemMetricsTest, ParseMeminfo);
-}
-
-struct SystemMemoryInfoKB;
-
-class BASE_EXPORT SysInfo {
- public:
-  // Return the number of logical processors/cores on the current machine.
-  static int NumberOfProcessors();
-
-  // Return the number of bytes of physical memory on the current machine.
-  static int64_t AmountOfPhysicalMemory();
-
-  // Return the number of bytes of current available physical memory on the
-  // machine.
-  // (The amount of memory that can be allocated without any significant
-  // impact on the system. It can lead to freeing inactive file-backed
-  // and/or speculative file-backed memory).
-  static int64_t AmountOfAvailablePhysicalMemory();
-
-  // Return the number of bytes of virtual memory of this process. A return
-  // value of zero means that there is no limit on the available virtual
-  // memory.
-  static int64_t AmountOfVirtualMemory();
-
-  // Return the number of megabytes of physical memory on the current machine.
-  static int AmountOfPhysicalMemoryMB() {
-    return static_cast<int>(AmountOfPhysicalMemory() / 1024 / 1024);
-  }
-
-  // Return the number of megabytes of available virtual memory, or zero if it
-  // is unlimited.
-  static int AmountOfVirtualMemoryMB() {
-    return static_cast<int>(AmountOfVirtualMemory() / 1024 / 1024);
-  }
-
-  // Return the available disk space in bytes on the volume containing |path|,
-  // or -1 on failure.
-  static int64_t AmountOfFreeDiskSpace(const FilePath& path);
-
-  // Return the total disk space in bytes on the volume containing |path|, or -1
-  // on failure.
-  static int64_t AmountOfTotalDiskSpace(const FilePath& path);
-
-  // Returns system uptime.
-  static TimeDelta Uptime();
-
-  // Returns a descriptive string for the current machine model or an empty
-  // string if the machine model is unknown or an error occured.
-  // e.g. "MacPro1,1" on Mac, "iPhone9,3" on iOS or "Nexus 5" on Android. Only
-  // implemented on OS X, iOS, Android, and Chrome OS. This returns an empty
-  // string on other platforms.
-  static std::string HardwareModelName();
-
-  // Returns the name of the host operating system.
-  static std::string OperatingSystemName();
-
-  // Returns the version of the host operating system.
-  static std::string OperatingSystemVersion();
-
-  // Retrieves detailed numeric values for the OS version.
-  // DON'T USE THIS ON THE MAC OR WINDOWS to determine the current OS release
-  // for OS version-specific feature checks and workarounds. If you must use
-  // an OS version check instead of a feature check, use the base::mac::IsOS*
-  // family from base/mac/mac_util.h, or base::win::GetVersion from
-  // base/win/windows_version.h.
-  static void OperatingSystemVersionNumbers(int32_t* major_version,
-                                            int32_t* minor_version,
-                                            int32_t* bugfix_version);
-
-  // Returns the architecture of the running operating system.
-  // Exact return value may differ across platforms.
-  // e.g. a 32-bit x86 kernel on a 64-bit capable CPU will return "x86",
-  //      whereas a x86-64 kernel on the same CPU will return "x86_64"
-  static std::string OperatingSystemArchitecture();
-
-  // Avoid using this. Use base/cpu.h to get information about the CPU instead.
-  // http://crbug.com/148884
-  // Returns the CPU model name of the system. If it can not be figured out,
-  // an empty string is returned.
-  static std::string CPUModelName();
-
-  // Return the smallest amount of memory (in bytes) which the VM system will
-  // allocate.
-  static size_t VMAllocationGranularity();
-
-#if defined(OS_CHROMEOS)
-  typedef std::map<std::string, std::string> LsbReleaseMap;
-
-  // Returns the contents of /etc/lsb-release as a map.
-  static const LsbReleaseMap& GetLsbReleaseMap();
-
-  // If |key| is present in the LsbReleaseMap, sets |value| and returns true.
-  static bool GetLsbReleaseValue(const std::string& key, std::string* value);
-
-  // Convenience function for GetLsbReleaseValue("CHROMEOS_RELEASE_BOARD",...).
-  // Returns "unknown" if CHROMEOS_RELEASE_BOARD is not set. Otherwise, returns
-  // the full name of the board. Note that the returned value often differs
-  // between developers' systems and devices that use official builds. E.g. for
-  // a developer-built image, the function could return 'glimmer', while in an
-  // official build, it may be something like 'glimmer-signed-mp-v4keys'.
-  //
-  // NOTE: Strings returned by this function should be treated as opaque values
-  // within Chrome (e.g. for reporting metrics elsewhere). If you need to make
-  // Chrome behave differently for different Chrome OS devices, either directly
-  // check for the hardware feature that you care about (preferred) or add a
-  // command-line flag to Chrome and pass it from session_manager (based on
-  // whether a USE flag is set or not). See https://goo.gl/BbBkzg for more
-  // details.
-  static std::string GetLsbReleaseBoard();
-
-  // Returns the creation time of /etc/lsb-release. (Used to get the date and
-  // time of the Chrome OS build).
-  static Time GetLsbReleaseTime();
-
-  // Returns true when actually running in a Chrome OS environment.
-  static bool IsRunningOnChromeOS();
-
-  // Test method to force re-parsing of lsb-release.
-  static void SetChromeOSVersionInfoForTest(const std::string& lsb_release,
-                                            const Time& lsb_release_time);
-#endif  // defined(OS_CHROMEOS)
-
-#if defined(OS_ANDROID)
-  // Returns the Android build's codename.
-  static std::string GetAndroidBuildCodename();
-
-  // Returns the Android build ID.
-  static std::string GetAndroidBuildID();
-
-  static int DalvikHeapSizeMB();
-  static int DalvikHeapGrowthLimitMB();
-#endif  // defined(OS_ANDROID)
-
-  // Returns true if this is a low-end device.
-  // Low-end device refers to devices having a very low amount of total
-  // system memory, typically <= 1GB.
-  // See also SysUtils.java, method isLowEndDevice.
-  static bool IsLowEndDevice();
-
- private:
-  FRIEND_TEST_ALL_PREFIXES(SysInfoTest, AmountOfAvailablePhysicalMemory);
-  FRIEND_TEST_ALL_PREFIXES(debug::SystemMetricsTest, ParseMeminfo);
-
-  static int64_t AmountOfPhysicalMemoryImpl();
-  static int64_t AmountOfAvailablePhysicalMemoryImpl();
-  static bool IsLowEndDeviceImpl();
-
-#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_AIX)
-  static int64_t AmountOfAvailablePhysicalMemory(
-      const SystemMemoryInfoKB& meminfo);
-#endif
-};
-
-}  // namespace base
-
-#endif  // BASE_SYS_INFO_H_
diff --git a/native/zucchini/vendor/libchrome/base/task_runner.h b/native/zucchini/vendor/libchrome/base/task_runner.h
deleted file mode 100644
index 1d302ab..0000000
--- a/native/zucchini/vendor/libchrome/base/task_runner.h
+++ /dev/null
@@ -1,154 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TASK_RUNNER_H_
-#define BASE_TASK_RUNNER_H_
-
-#include <stddef.h>
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/location.h"
-#include "base/memory/ref_counted.h"
-#include "base/time/time.h"
-
-namespace base {
-
-struct TaskRunnerTraits;
-
-// A TaskRunner is an object that runs posted tasks (in the form of
-// Closure objects).  The TaskRunner interface provides a way of
-// decoupling task posting from the mechanics of how each task will be
-// run.  TaskRunner provides very weak guarantees as to how posted
-// tasks are run (or if they're run at all).  In particular, it only
-// guarantees:
-//
-//   - Posting a task will not run it synchronously.  That is, no
-//     Post*Task method will call task.Run() directly.
-//
-//   - Increasing the delay can only delay when the task gets run.
-//     That is, increasing the delay may not affect when the task gets
-//     run, or it could make it run later than it normally would, but
-//     it won't make it run earlier than it normally would.
-//
-// TaskRunner does not guarantee the order in which posted tasks are
-// run, whether tasks overlap, or whether they're run on a particular
-// thread.  Also it does not guarantee a memory model for shared data
-// between tasks.  (In other words, you should use your own
-// synchronization/locking primitives if you need to share data
-// between tasks.)
-//
-// Implementations of TaskRunner should be thread-safe in that all
-// methods must be safe to call on any thread.  Ownership semantics
-// for TaskRunners are in general not clear, which is why the
-// interface itself is RefCountedThreadSafe.
-//
-// Some theoretical implementations of TaskRunner:
-//
-//   - A TaskRunner that uses a thread pool to run posted tasks.
-//
-//   - A TaskRunner that, for each task, spawns a non-joinable thread
-//     to run that task and immediately quit.
-//
-//   - A TaskRunner that stores the list of posted tasks and has a
-//     method Run() that runs each runnable task in random order.
-class BASE_EXPORT TaskRunner
-    : public RefCountedThreadSafe<TaskRunner, TaskRunnerTraits> {
- public:
-  // Posts the given task to be run.  Returns true if the task may be
-  // run at some point in the future, and false if the task definitely
-  // will not be run.
-  //
-  // Equivalent to PostDelayedTask(from_here, task, 0).
-  bool PostTask(const Location& from_here, OnceClosure task);
-
-  // Like PostTask, but tries to run the posted task only after |delay_ms|
-  // has passed. Implementations should use a tick clock, rather than wall-
-  // clock time, to implement |delay|.
-  virtual bool PostDelayedTask(const Location& from_here,
-                               OnceClosure task,
-                               base::TimeDelta delay) = 0;
-
-  // Returns true iff tasks posted to this TaskRunner are sequenced
-  // with this call.
-  //
-  // In particular:
-  // - Returns true if this is a SequencedTaskRunner to which the
-  //   current task was posted.
-  // - Returns true if this is a SequencedTaskRunner bound to the
-  //   same sequence as the SequencedTaskRunner to which the current
-  //   task was posted.
-  // - Returns true if this is a SingleThreadTaskRunner bound to
-  //   the current thread.
-  // TODO(http://crbug.com/665062):
-  //   This API doesn't make sense for parallel TaskRunners.
-  //   Introduce alternate static APIs for documentation purposes of "this runs
-  //   in pool X", have RunsTasksInCurrentSequence() return false for parallel
-  //   TaskRunners, and ultimately move this method down to SequencedTaskRunner.
-  virtual bool RunsTasksInCurrentSequence() const = 0;
-
-  // Posts |task| on the current TaskRunner.  On completion, |reply|
-  // is posted to the thread that called PostTaskAndReply().  Both
-  // |task| and |reply| are guaranteed to be deleted on the thread
-  // from which PostTaskAndReply() is invoked.  This allows objects
-  // that must be deleted on the originating thread to be bound into
-  // the |task| and |reply| Closures.  In particular, it can be useful
-  // to use WeakPtr<> in the |reply| Closure so that the reply
-  // operation can be canceled. See the following pseudo-code:
-  //
-  // class DataBuffer : public RefCountedThreadSafe<DataBuffer> {
-  //  public:
-  //   // Called to add data into a buffer.
-  //   void AddData(void* buf, size_t length);
-  //   ...
-  // };
-  //
-  //
-  // class DataLoader : public SupportsWeakPtr<DataLoader> {
-  //  public:
-  //    void GetData() {
-  //      scoped_refptr<DataBuffer> buffer = new DataBuffer();
-  //      target_thread_.task_runner()->PostTaskAndReply(
-  //          FROM_HERE,
-  //          base::Bind(&DataBuffer::AddData, buffer),
-  //          base::Bind(&DataLoader::OnDataReceived, AsWeakPtr(), buffer));
-  //    }
-  //
-  //  private:
-  //    void OnDataReceived(scoped_refptr<DataBuffer> buffer) {
-  //      // Do something with buffer.
-  //    }
-  // };
-  //
-  //
-  // Things to notice:
-  //   * Results of |task| are shared with |reply| by binding a shared argument
-  //     (a DataBuffer instance).
-  //   * The DataLoader object has no special thread safety.
-  //   * The DataLoader object can be deleted while |task| is still running,
-  //     and the reply will cancel itself safely because it is bound to a
-  //     WeakPtr<>.
-  bool PostTaskAndReply(const Location& from_here,
-                        OnceClosure task,
-                        OnceClosure reply);
-
- protected:
-  friend struct TaskRunnerTraits;
-
-  TaskRunner();
-  virtual ~TaskRunner();
-
-  // Called when this object should be destroyed.  By default simply
-  // deletes |this|, but can be overridden to do something else, like
-  // delete on a certain thread.
-  virtual void OnDestruct() const;
-};
-
-struct BASE_EXPORT TaskRunnerTraits {
-  static void Destruct(const TaskRunner* task_runner);
-};
-
-}  // namespace base
-
-#endif  // BASE_TASK_RUNNER_H_
diff --git a/native/zucchini/vendor/libchrome/base/template_util.h b/native/zucchini/vendor/libchrome/base/template_util.h
deleted file mode 100644
index e4d03a2..0000000
--- a/native/zucchini/vendor/libchrome/base/template_util.h
+++ /dev/null
@@ -1,154 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TEMPLATE_UTIL_H_
-#define BASE_TEMPLATE_UTIL_H_
-
-#include <stddef.h>
-#include <iosfwd>
-#include <iterator>
-#include <type_traits>
-#include <utility>
-#include <vector>
-
-#include "build/build_config.h"
-
-// Some versions of libstdc++ have partial support for type_traits, but misses
-// a smaller subset while removing some of the older non-standard stuff. Assume
-// that all versions below 5.0 fall in this category, along with one 5.0
-// experimental release. Test for this by consulting compiler major version,
-// the only reliable option available, so theoretically this could fail should
-// you attempt to mix an earlier version of libstdc++ with >= GCC5. But
-// that's unlikely to work out, especially as GCC5 changed ABI.
-#define CR_GLIBCXX_5_0_0 20150123
-// `!defined(__clang__)` is a local android patch
-#if !defined(__clang__) && ((defined(__GNUC__) && __GNUC__ < 5) || \
-    (defined(__GLIBCXX__) && __GLIBCXX__ == CR_GLIBCXX_5_0_0))
-#define CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX
-#endif
-
-// This hacks around using gcc with libc++ which has some incompatibilies.
-// - is_trivially_* doesn't work: https://llvm.org/bugs/show_bug.cgi?id=27538
-// TODO(danakj): Remove this when android builders are all using a newer version
-// of gcc, or the android ndk is updated to a newer libc++ that works with older
-// gcc versions.
-#if !defined(__clang__) && defined(_LIBCPP_VERSION)
-#define CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
-#endif
-
-namespace base {
-
-template <class T> struct is_non_const_reference : std::false_type {};
-template <class T> struct is_non_const_reference<T&> : std::true_type {};
-template <class T> struct is_non_const_reference<const T&> : std::false_type {};
-
-namespace internal {
-
-// Implementation detail of base::void_t below.
-template <typename...>
-struct make_void {
-  using type = void;
-};
-
-}  // namespace internal
-
-// base::void_t is an implementation of std::void_t from C++17.
-//
-// We use |base::internal::make_void| as a helper struct to avoid a C++14
-// defect:
-//   http://en.cppreference.com/w/cpp/types/void_t
-//   http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#1558
-template <typename... Ts>
-using void_t = typename ::base::internal::make_void<Ts...>::type;
-
-namespace internal {
-
-// Uses expression SFINAE to detect whether using operator<< would work.
-template <typename T, typename = void>
-struct SupportsOstreamOperator : std::false_type {};
-template <typename T>
-struct SupportsOstreamOperator<T,
-                               decltype(void(std::declval<std::ostream&>()
-                                             << std::declval<T>()))>
-    : std::true_type {};
-
-// Used to detech whether the given type is an iterator.  This is normally used
-// with std::enable_if to provide disambiguation for functions that take
-// templatzed iterators as input.
-template <typename T, typename = void>
-struct is_iterator : std::false_type {};
-
-template <typename T>
-struct is_iterator<T,
-                   void_t<typename std::iterator_traits<T>::iterator_category>>
-    : std::true_type {};
-
-}  // namespace internal
-
-// is_trivially_copyable is especially hard to get right.
-// - Older versions of libstdc++ will fail to have it like they do for other
-//   type traits. This has become a subset of the second point, but used to be
-//   handled independently.
-// - An experimental release of gcc includes most of type_traits but misses
-//   is_trivially_copyable, so we still have to avoid using libstdc++ in this
-//   case, which is covered by CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX.
-// - When compiling libc++ from before r239653, with a gcc compiler, the
-//   std::is_trivially_copyable can fail. So we need to work around that by not
-//   using the one in libc++ in this case. This is covered by the
-//   CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX define, and is discussed in
-//   https://llvm.org/bugs/show_bug.cgi?id=27538#c1 where they point out that
-//   in libc++'s commit r239653 this is fixed by libc++ checking for gcc 5.1.
-// - In both of the above cases we are using the gcc compiler. When defining
-//   this ourselves on compiler intrinsics, the __is_trivially_copyable()
-//   intrinsic is not available on gcc before version 5.1 (see the discussion in
-//   https://llvm.org/bugs/show_bug.cgi?id=27538#c1 again), so we must check for
-//   that version.
-// - When __is_trivially_copyable() is not available because we are on gcc older
-//   than 5.1, we need to fall back to something, so we use __has_trivial_copy()
-//   instead based on what was done one-off in bit_cast() previously.
-
-// TODO(crbug.com/554293): Remove this when all platforms have this in the std
-// namespace and it works with gcc as needed.
-#if defined(CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX) || \
-    defined(CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX)
-template <typename T>
-struct is_trivially_copyable {
-// TODO(danakj): Remove this when android builders are all using a newer version
-// of gcc, or the android ndk is updated to a newer libc++ that does this for
-// us.
-#if _GNUC_VER >= 501
-  static constexpr bool value = __is_trivially_copyable(T);
-#else
-  static constexpr bool value =
-      __has_trivial_copy(T) && __has_trivial_destructor(T);
-#endif
-};
-#else
-template <class T>
-using is_trivially_copyable = std::is_trivially_copyable<T>;
-#endif
-
-#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 7
-// Workaround for g++7 and earlier family.
-// Due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80654, without this
-// Optional<std::vector<T>> where T is non-copyable causes a compile error.
-// As we know it is not trivially copy constructible, explicitly declare so.
-template <typename T>
-struct is_trivially_copy_constructible
-    : std::is_trivially_copy_constructible<T> {};
-
-template <typename... T>
-struct is_trivially_copy_constructible<std::vector<T...>> : std::false_type {};
-#else
-// Otherwise use std::is_trivially_copy_constructible as is.
-template <typename T>
-using is_trivially_copy_constructible = std::is_trivially_copy_constructible<T>;
-#endif
-
-}  // namespace base
-
-#undef CR_USE_FALLBACKS_FOR_GCC_WITH_LIBCXX
-#undef CR_USE_FALLBACKS_FOR_OLD_EXPERIMENTAL_GLIBCXX
-
-#endif  // BASE_TEMPLATE_UTIL_H_
diff --git a/native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE b/native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE
deleted file mode 100644
index 2882e4e..0000000
--- a/native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE
+++ /dev/null
@@ -1,76 +0,0 @@
-COPYRIGHT AND PERMISSION NOTICE (ICU 58 and later)
-
-Copyright © 1991-2017 Unicode, Inc. All rights reserved.
-Distributed under the Terms of Use in http://www.unicode.org/copyright.html
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of the Unicode data files and any associated documentation
-(the "Data Files") or Unicode software and any associated documentation
-(the "Software") to deal in the Data Files or Software
-without restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, and/or sell copies of
-the Data Files or Software, and to permit persons to whom the Data Files
-or Software are furnished to do so, provided that either
-(a) this copyright and permission notice appear with all copies
-of the Data Files or Software, or
-(b) this copyright and permission notice appear in associated
-Documentation.
-
-THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT OF THIRD PARTY RIGHTS.
-IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
-NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
-DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
-DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
-TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THE DATA FILES OR SOFTWARE.
-
-Except as contained in this notice, the name of a copyright holder
-shall not be used in advertising or otherwise to promote the sale,
-use or other dealings in these Data Files or Software without prior
-written authorization of the copyright holder.
-
----------------------
-
-Third-Party Software Licenses
-
-This section contains third-party software notices and/or additional
-terms for licensed third-party software components included within ICU
-libraries.
-
-1. ICU License - ICU 1.8.1 to ICU 57.1
-
-COPYRIGHT AND PERMISSION NOTICE
-
-Copyright (c) 1995-2016 International Business Machines Corporation and others
-All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, and/or sell copies of the Software, and to permit persons
-to whom the Software is furnished to do so, provided that the above
-copyright notice(s) and this permission notice appear in all copies of
-the Software and that both the above copyright notice(s) and this
-permission notice appear in supporting documentation.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY
-SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER
-RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
-CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
-CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-Except as contained in this notice, the name of a copyright holder
-shall not be used in advertising or otherwise to promote the sale, use
-or other dealings in this Software without prior written authorization
-of the copyright holder.
-
-All trademarks and registered trademarks mentioned herein are the
-property of their respective owners.
diff --git a/native/zucchini/vendor/libchrome/base/third_party/icu/icu_utf.h b/native/zucchini/vendor/libchrome/base/third_party/icu/icu_utf.h
deleted file mode 100644
index 2ba8231..0000000
--- a/native/zucchini/vendor/libchrome/base/third_party/icu/icu_utf.h
+++ /dev/null
@@ -1,442 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-*
-*   Copyright (C) 1999-2015, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-*
-******************************************************************************
-*/
-
-#ifndef BASE_THIRD_PARTY_ICU_ICU_UTF_H_
-#define BASE_THIRD_PARTY_ICU_ICU_UTF_H_
-
-#include <stdint.h>
-
-namespace base_icu {
-
-// source/common/unicode/umachine.h
-
-/** The ICU boolean type @stable ICU 2.0 */
-typedef int8_t UBool;
-
-/**
- * Define UChar32 as a type for single Unicode code points.
- * UChar32 is a signed 32-bit integer (same as int32_t).
- *
- * The Unicode code point range is 0..0x10ffff.
- * All other values (negative or >=0x110000) are illegal as Unicode code points.
- * They may be used as sentinel values to indicate "done", "error"
- * or similar non-code point conditions.
- *
- * Before ICU 2.4 (Jitterbug 2146), UChar32 was defined
- * to be wchar_t if that is 32 bits wide (wchar_t may be signed or unsigned)
- * or else to be uint32_t.
- * That is, the definition of UChar32 was platform-dependent.
- *
- * @see U_SENTINEL
- * @stable ICU 2.4
- */
-typedef int32_t UChar32;
-
-/**
- * This value is intended for sentinel values for APIs that
- * (take or) return single code points (UChar32).
- * It is outside of the Unicode code point range 0..0x10ffff.
- *
- * For example, a "done" or "error" value in a new API
- * could be indicated with U_SENTINEL.
- *
- * ICU APIs designed before ICU 2.4 usually define service-specific "done"
- * values, mostly 0xffff.
- * Those may need to be distinguished from
- * actual U+ffff text contents by calling functions like
- * CharacterIterator::hasNext() or UnicodeString::length().
- *
- * @return -1
- * @see UChar32
- * @stable ICU 2.4
- */
-#define CBU_SENTINEL (-1)
-
-// source/common/unicode/utf.h
-
-/**
- * Is this code point a Unicode noncharacter?
- * @param c 32-bit code point
- * @return TRUE or FALSE
- * @stable ICU 2.4
- */
-#define CBU_IS_UNICODE_NONCHAR(c) \
-    ((c)>=0xfdd0 && \
-     ((c)<=0xfdef || ((c)&0xfffe)==0xfffe) && (c)<=0x10ffff)
-
-/**
- * Is c a Unicode code point value (0..U+10ffff)
- * that can be assigned a character?
- *
- * Code points that are not characters include:
- * - single surrogate code points (U+d800..U+dfff, 2048 code points)
- * - the last two code points on each plane (U+__fffe and U+__ffff, 34 code points)
- * - U+fdd0..U+fdef (new with Unicode 3.1, 32 code points)
- * - the highest Unicode code point value is U+10ffff
- *
- * This means that all code points below U+d800 are character code points,
- * and that boundary is tested first for performance.
- *
- * @param c 32-bit code point
- * @return TRUE or FALSE
- * @stable ICU 2.4
- */
-#define CBU_IS_UNICODE_CHAR(c) \
-    ((uint32_t)(c)<0xd800 || \
-        (0xdfff<(c) && (c)<=0x10ffff && !CBU_IS_UNICODE_NONCHAR(c)))
-
-/**
- * Is this code point a surrogate (U+d800..U+dfff)?
- * @param c 32-bit code point
- * @return TRUE or FALSE
- * @stable ICU 2.4
- */
-#define CBU_IS_SURROGATE(c) (((c)&0xfffff800)==0xd800)
-
-/**
- * Assuming c is a surrogate code point (U_IS_SURROGATE(c)),
- * is it a lead surrogate?
- * @param c 32-bit code point
- * @return TRUE or FALSE
- * @stable ICU 2.4
- */
-#define CBU_IS_SURROGATE_LEAD(c) (((c)&0x400)==0)
-
-// source/common/unicode/utf8.h
-
-/**
- * Internal bit vector for 3-byte UTF-8 validity check, for use in U8_IS_VALID_LEAD3_AND_T1.
- * Each bit indicates whether one lead byte + first trail byte pair starts a valid sequence.
- * Lead byte E0..EF bits 3..0 are used as byte index,
- * first trail byte bits 7..5 are used as bit index into that byte.
- * @see U8_IS_VALID_LEAD3_AND_T1
- * @internal
- */
-#define CBU8_LEAD3_T1_BITS "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30"
-
-/**
- * Internal 3-byte UTF-8 validity check.
- * Non-zero if lead byte E0..EF and first trail byte 00..FF start a valid sequence.
- * @internal
- */
-#define CBU8_IS_VALID_LEAD3_AND_T1(lead, t1) (CBU8_LEAD3_T1_BITS[(lead)&0xf]&(1<<((uint8_t)(t1)>>5)))
-
-/**
- * Internal bit vector for 4-byte UTF-8 validity check, for use in U8_IS_VALID_LEAD4_AND_T1.
- * Each bit indicates whether one lead byte + first trail byte pair starts a valid sequence.
- * First trail byte bits 7..4 are used as byte index,
- * lead byte F0..F4 bits 2..0 are used as bit index into that byte.
- * @see U8_IS_VALID_LEAD4_AND_T1
- * @internal
- */
-#define CBU8_LEAD4_T1_BITS "\x00\x00\x00\x00\x00\x00\x00\x00\x1E\x0F\x0F\x0F\x00\x00\x00\x00"
-
-/**
- * Internal 4-byte UTF-8 validity check.
- * Non-zero if lead byte F0..F4 and first trail byte 00..FF start a valid sequence.
- * @internal
- */
-#define CBU8_IS_VALID_LEAD4_AND_T1(lead, t1) (CBU8_LEAD4_T1_BITS[(uint8_t)(t1)>>4]&(1<<((lead)&7)))
-
-/**
- * Function for handling "next code point" with error-checking.
- *
- * This is internal since it is not meant to be called directly by external clie
-nts;
- * however it is U_STABLE (not U_INTERNAL) since it is called by public macros i
-n this
- * file and thus must remain stable, and should not be hidden when other interna
-l
- * functions are hidden (otherwise public macros would fail to compile).
- * @internal
- */
-UChar32
-utf8_nextCharSafeBody(const uint8_t *s, int32_t *pi, int32_t length, ::base_icu::UChar32 c, ::base_icu::UBool strict);
-
-/**
- * Does this code unit (byte) encode a code point by itself (US-ASCII 0..0x7f)?
- * @param c 8-bit code unit (byte)
- * @return TRUE or FALSE
- * @stable ICU 2.4
- */
-#define CBU8_IS_SINGLE(c) (((c)&0x80)==0)
-
-/**
- * Is this code unit (byte) a UTF-8 lead byte? (0xC2..0xF4)
- * @param c 8-bit code unit (byte)
- * @return TRUE or FALSE
- * @stable ICU 2.4
- */
-#define CBU8_IS_LEAD(c) ((uint8_t)((c)-0xc2)<=0x32)
-
-/**
- * Is this code unit (byte) a UTF-8 trail byte? (0x80..0xBF)
- * @param c 8-bit code unit (byte)
- * @return TRUE or FALSE
- * @stable ICU 2.4
- */
-#define CBU8_IS_TRAIL(c) ((int8_t)(c)<-0x40)
-
-/**
- * How many code units (bytes) are used for the UTF-8 encoding
- * of this Unicode code point?
- * @param c 32-bit code point
- * @return 1..4, or 0 if c is a surrogate or not a Unicode code point
- * @stable ICU 2.4
- */
-#define CBU8_LENGTH(c) \
-    ((uint32_t)(c)<=0x7f ? 1 : \
-        ((uint32_t)(c)<=0x7ff ? 2 : \
-            ((uint32_t)(c)<=0xd7ff ? 3 : \
-                ((uint32_t)(c)<=0xdfff || (uint32_t)(c)>0x10ffff ? 0 : \
-                    ((uint32_t)(c)<=0xffff ? 3 : 4)\
-                ) \
-            ) \
-        ) \
-    )
-
-/**
- * The maximum number of UTF-8 code units (bytes) per Unicode code point (U+0000..U+10ffff).
- * @return 4
- * @stable ICU 2.4
- */
-#define CBU8_MAX_LENGTH 4
-
-/**
- * Get a code point from a string at a code point boundary offset,
- * and advance the offset to the next code point boundary.
- * (Post-incrementing forward iteration.)
- * "Safe" macro, checks for illegal sequences and for string boundaries.
- *
- * The length can be negative for a NUL-terminated string.
- *
- * The offset may point to the lead byte of a multi-byte sequence,
- * in which case the macro will read the whole sequence.
- * If the offset points to a trail byte or an illegal UTF-8 sequence, then
- * c is set to a negative value.
- *
- * @param s const uint8_t * string
- * @param i int32_t string offset, must be i<length
- * @param length int32_t string length
- * @param c output UChar32 variable, set to <0 in case of an error
- * @see U8_NEXT_UNSAFE
- * @stable ICU 2.4
- */
-#define CBU8_NEXT(s, i, length, c) { \
-    (c)=(uint8_t)(s)[(i)++]; \
-    if(!CBU8_IS_SINGLE(c)) { \
-        uint8_t __t1, __t2; \
-        if( /* handle U+0800..U+FFFF inline */ \
-                (0xe0<=(c) && (c)<0xf0) && \
-                (((i)+1)<(length) || (length)<0) && \
-                CBU8_IS_VALID_LEAD3_AND_T1((c), __t1=(s)[i]) && \
-                (__t2=(s)[(i)+1]-0x80)<=0x3f) { \
-            (c)=(((c)&0xf)<<12)|((__t1&0x3f)<<6)|__t2; \
-            (i)+=2; \
-        } else if( /* handle U+0080..U+07FF inline */ \
-                ((c)<0xe0 && (c)>=0xc2) && \
-                ((i)!=(length)) && \
-                (__t1=(s)[i]-0x80)<=0x3f) { \
-            (c)=(((c)&0x1f)<<6)|__t1; \
-            ++(i); \
-        } else { \
-            /* function call for "complicated" and error cases */ \
-            (c)=::base_icu::utf8_nextCharSafeBody((const uint8_t *)s, &(i), (length), c, -1); \
-        } \
-    } \
-}
-
-/**
- * Append a code point to a string, overwriting 1 to 4 bytes.
- * The offset points to the current end of the string contents
- * and is advanced (post-increment).
- * "Unsafe" macro, assumes a valid code point and sufficient space in the string.
- * Otherwise, the result is undefined.
- *
- * @param s const uint8_t * string buffer
- * @param i string offset
- * @param c code point to append
- * @see U8_APPEND
- * @stable ICU 2.4
- */
-#define CBU8_APPEND_UNSAFE(s, i, c) { \
-    if((uint32_t)(c)<=0x7f) { \
-        (s)[(i)++]=(uint8_t)(c); \
-    } else { \
-        if((uint32_t)(c)<=0x7ff) { \
-            (s)[(i)++]=(uint8_t)(((c)>>6)|0xc0); \
-        } else { \
-            if((uint32_t)(c)<=0xffff) { \
-                (s)[(i)++]=(uint8_t)(((c)>>12)|0xe0); \
-            } else { \
-                (s)[(i)++]=(uint8_t)(((c)>>18)|0xf0); \
-                (s)[(i)++]=(uint8_t)((((c)>>12)&0x3f)|0x80); \
-            } \
-            (s)[(i)++]=(uint8_t)((((c)>>6)&0x3f)|0x80); \
-        } \
-        (s)[(i)++]=(uint8_t)(((c)&0x3f)|0x80); \
-    } \
-}
-
-// source/common/unicode/utf16.h
-
-/**
- * Does this code unit alone encode a code point (BMP, not a surrogate)?
- * @param c 16-bit code unit
- * @return TRUE or FALSE
- * @stable ICU 2.4
- */
-#define CBU16_IS_SINGLE(c) !CBU_IS_SURROGATE(c)
-
-/**
- * Is this code unit a lead surrogate (U+d800..U+dbff)?
- * @param c 16-bit code unit
- * @return TRUE or FALSE
- * @stable ICU 2.4
- */
-#define CBU16_IS_LEAD(c) (((c)&0xfffffc00)==0xd800)
-
-/**
- * Is this code unit a trail surrogate (U+dc00..U+dfff)?
- * @param c 16-bit code unit
- * @return TRUE or FALSE
- * @stable ICU 2.4
- */
-#define CBU16_IS_TRAIL(c) (((c)&0xfffffc00)==0xdc00)
-
-/**
- * Is this code unit a surrogate (U+d800..U+dfff)?
- * @param c 16-bit code unit
- * @return TRUE or FALSE
- * @stable ICU 2.4
- */
-#define CBU16_IS_SURROGATE(c) CBU_IS_SURROGATE(c)
-
-/**
- * Assuming c is a surrogate code point (U16_IS_SURROGATE(c)),
- * is it a lead surrogate?
- * @param c 16-bit code unit
- * @return TRUE or FALSE
- * @stable ICU 2.4
- */
-#define CBU16_IS_SURROGATE_LEAD(c) (((c)&0x400)==0)
-
-/**
- * Helper constant for U16_GET_SUPPLEMENTARY.
- * @internal
- */
-#define CBU16_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000)
-
-/**
- * Get a supplementary code point value (U+10000..U+10ffff)
- * from its lead and trail surrogates.
- * The result is undefined if the input values are not
- * lead and trail surrogates.
- *
- * @param lead lead surrogate (U+d800..U+dbff)
- * @param trail trail surrogate (U+dc00..U+dfff)
- * @return supplementary code point (U+10000..U+10ffff)
- * @stable ICU 2.4
- */
-#define CBU16_GET_SUPPLEMENTARY(lead, trail) \
-    (((::base_icu::UChar32)(lead)<<10UL)+(::base_icu::UChar32)(trail)-CBU16_SURROGATE_OFFSET)
-
-/**
- * Get the lead surrogate (0xd800..0xdbff) for a
- * supplementary code point (0x10000..0x10ffff).
- * @param supplementary 32-bit code point (U+10000..U+10ffff)
- * @return lead surrogate (U+d800..U+dbff) for supplementary
- * @stable ICU 2.4
- */
-#define CBU16_LEAD(supplementary) (::base_icu::UChar)(((supplementary)>>10)+0xd7c0)
-
-/**
- * Get the trail surrogate (0xdc00..0xdfff) for a
- * supplementary code point (0x10000..0x10ffff).
- * @param supplementary 32-bit code point (U+10000..U+10ffff)
- * @return trail surrogate (U+dc00..U+dfff) for supplementary
- * @stable ICU 2.4
- */
-#define CBU16_TRAIL(supplementary) (::base_icu::UChar)(((supplementary)&0x3ff)|0xdc00)
-
-/**
- * How many 16-bit code units are used to encode this Unicode code point? (1 or 2)
- * The result is not defined if c is not a Unicode code point (U+0000..U+10ffff).
- * @param c 32-bit code point
- * @return 1 or 2
- * @stable ICU 2.4
- */
-#define CBU16_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2)
-
-/**
- * The maximum number of 16-bit code units per Unicode code point (U+0000..U+10ffff).
- * @return 2
- * @stable ICU 2.4
- */
-#define CBU16_MAX_LENGTH 2
-
-/**
- * Get a code point from a string at a code point boundary offset,
- * and advance the offset to the next code point boundary.
- * (Post-incrementing forward iteration.)
- * "Safe" macro, handles unpaired surrogates and checks for string boundaries.
- *
- * The length can be negative for a NUL-terminated string.
- *
- * The offset may point to the lead surrogate unit
- * for a supplementary code point, in which case the macro will read
- * the following trail surrogate as well.
- * If the offset points to a trail surrogate or
- * to a single, unpaired lead surrogate, then c is set to that unpaired surrogate.
- *
- * @param s const UChar * string
- * @param i string offset, must be i<length
- * @param length string length
- * @param c output UChar32 variable
- * @see U16_NEXT_UNSAFE
- * @stable ICU 2.4
- */
-#define CBU16_NEXT(s, i, length, c) { \
-    (c)=(s)[(i)++]; \
-    if(CBU16_IS_LEAD(c)) { \
-        uint16_t __c2; \
-        if((i)!=(length) && CBU16_IS_TRAIL(__c2=(s)[(i)])) { \
-            ++(i); \
-            (c)=CBU16_GET_SUPPLEMENTARY((c), __c2); \
-        } \
-    } \
-}
-
-/**
- * Append a code point to a string, overwriting 1 or 2 code units.
- * The offset points to the current end of the string contents
- * and is advanced (post-increment).
- * "Unsafe" macro, assumes a valid code point and sufficient space in the string.
- * Otherwise, the result is undefined.
- *
- * @param s const UChar * string buffer
- * @param i string offset
- * @param c code point to append
- * @see U16_APPEND
- * @stable ICU 2.4
- */
-#define CBU16_APPEND_UNSAFE(s, i, c) { \
-    if((uint32_t)(c)<=0xffff) { \
-        (s)[(i)++]=(uint16_t)(c); \
-    } else { \
-        (s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \
-        (s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \
-    } \
-}
-
-}  // namesapce base_icu
-
-#endif  // BASE_THIRD_PARTY_ICU_ICU_UTF_H_
diff --git a/native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE b/native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE
deleted file mode 100644
index eba7b77..0000000
--- a/native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE
+++ /dev/null
@@ -1,35 +0,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is the Netscape Portable Runtime (NSPR).
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998-2000
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
diff --git a/native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt b/native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
deleted file mode 100644
index 5669081..0000000
--- a/native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt
+++ /dev/null
@@ -1,469 +0,0 @@
-                          MOZILLA PUBLIC LICENSE
-                                Version 1.1
-
-                              ---------------
-
-1. Definitions.
-
-     1.0.1. "Commercial Use" means distribution or otherwise making the
-     Covered Code available to a third party.
-
-     1.1. "Contributor" means each entity that creates or contributes to
-     the creation of Modifications.
-
-     1.2. "Contributor Version" means the combination of the Original
-     Code, prior Modifications used by a Contributor, and the Modifications
-     made by that particular Contributor.
-
-     1.3. "Covered Code" means the Original Code or Modifications or the
-     combination of the Original Code and Modifications, in each case
-     including portions thereof.
-
-     1.4. "Electronic Distribution Mechanism" means a mechanism generally
-     accepted in the software development community for the electronic
-     transfer of data.
-
-     1.5. "Executable" means Covered Code in any form other than Source
-     Code.
-
-     1.6. "Initial Developer" means the individual or entity identified
-     as the Initial Developer in the Source Code notice required by Exhibit
-     A.
-
-     1.7. "Larger Work" means a work which combines Covered Code or
-     portions thereof with code not governed by the terms of this License.
-
-     1.8. "License" means this document.
-
-     1.8.1. "Licensable" means having the right to grant, to the maximum
-     extent possible, whether at the time of the initial grant or
-     subsequently acquired, any and all of the rights conveyed herein.
-
-     1.9. "Modifications" means any addition to or deletion from the
-     substance or structure of either the Original Code or any previous
-     Modifications. When Covered Code is released as a series of files, a
-     Modification is:
-          A. Any addition to or deletion from the contents of a file
-          containing Original Code or previous Modifications.
-
-          B. Any new file that contains any part of the Original Code or
-          previous Modifications.
-
-     1.10. "Original Code" means Source Code of computer software code
-     which is described in the Source Code notice required by Exhibit A as
-     Original Code, and which, at the time of its release under this
-     License is not already Covered Code governed by this License.
-
-     1.10.1. "Patent Claims" means any patent claim(s), now owned or
-     hereafter acquired, including without limitation,  method, process,
-     and apparatus claims, in any patent Licensable by grantor.
-
-     1.11. "Source Code" means the preferred form of the Covered Code for
-     making modifications to it, including all modules it contains, plus
-     any associated interface definition files, scripts used to control
-     compilation and installation of an Executable, or source code
-     differential comparisons against either the Original Code or another
-     well known, available Covered Code of the Contributor's choice. The
-     Source Code can be in a compressed or archival form, provided the
-     appropriate decompression or de-archiving software is widely available
-     for no charge.
-
-     1.12. "You" (or "Your")  means an individual or a legal entity
-     exercising rights under, and complying with all of the terms of, this
-     License or a future version of this License issued under Section 6.1.
-     For legal entities, "You" includes any entity which controls, is
-     controlled by, or is under common control with You. For purposes of
-     this definition, "control" means (a) the power, direct or indirect,
-     to cause the direction or management of such entity, whether by
-     contract or otherwise, or (b) ownership of more than fifty percent
-     (50%) of the outstanding shares or beneficial ownership of such
-     entity.
-
-2. Source Code License.
-
-     2.1. The Initial Developer Grant.
-     The Initial Developer hereby grants You a world-wide, royalty-free,
-     non-exclusive license, subject to third party intellectual property
-     claims:
-          (a)  under intellectual property rights (other than patent or
-          trademark) Licensable by Initial Developer to use, reproduce,
-          modify, display, perform, sublicense and distribute the Original
-          Code (or portions thereof) with or without Modifications, and/or
-          as part of a Larger Work; and
-
-          (b) under Patents Claims infringed by the making, using or
-          selling of Original Code, to make, have made, use, practice,
-          sell, and offer for sale, and/or otherwise dispose of the
-          Original Code (or portions thereof).
-
-          (c) the licenses granted in this Section 2.1(a) and (b) are
-          effective on the date Initial Developer first distributes
-          Original Code under the terms of this License.
-
-          (d) Notwithstanding Section 2.1(b) above, no patent license is
-          granted: 1) for code that You delete from the Original Code; 2)
-          separate from the Original Code;  or 3) for infringements caused
-          by: i) the modification of the Original Code or ii) the
-          combination of the Original Code with other software or devices.
-
-     2.2. Contributor Grant.
-     Subject to third party intellectual property claims, each Contributor
-     hereby grants You a world-wide, royalty-free, non-exclusive license
-
-          (a)  under intellectual property rights (other than patent or
-          trademark) Licensable by Contributor, to use, reproduce, modify,
-          display, perform, sublicense and distribute the Modifications
-          created by such Contributor (or portions thereof) either on an
-          unmodified basis, with other Modifications, as Covered Code
-          and/or as part of a Larger Work; and
-
-          (b) under Patent Claims infringed by the making, using, or
-          selling of  Modifications made by that Contributor either alone
-          and/or in combination with its Contributor Version (or portions
-          of such combination), to make, use, sell, offer for sale, have
-          made, and/or otherwise dispose of: 1) Modifications made by that
-          Contributor (or portions thereof); and 2) the combination of
-          Modifications made by that Contributor with its Contributor
-          Version (or portions of such combination).
-
-          (c) the licenses granted in Sections 2.2(a) and 2.2(b) are
-          effective on the date Contributor first makes Commercial Use of
-          the Covered Code.
-
-          (d)    Notwithstanding Section 2.2(b) above, no patent license is
-          granted: 1) for any code that Contributor has deleted from the
-          Contributor Version; 2)  separate from the Contributor Version;
-          3)  for infringements caused by: i) third party modifications of
-          Contributor Version or ii)  the combination of Modifications made
-          by that Contributor with other software  (except as part of the
-          Contributor Version) or other devices; or 4) under Patent Claims
-          infringed by Covered Code in the absence of Modifications made by
-          that Contributor.
-
-3. Distribution Obligations.
-
-     3.1. Application of License.
-     The Modifications which You create or to which You contribute are
-     governed by the terms of this License, including without limitation
-     Section 2.2. The Source Code version of Covered Code may be
-     distributed only under the terms of this License or a future version
-     of this License released under Section 6.1, and You must include a
-     copy of this License with every copy of the Source Code You
-     distribute. You may not offer or impose any terms on any Source Code
-     version that alters or restricts the applicable version of this
-     License or the recipients' rights hereunder. However, You may include
-     an additional document offering the additional rights described in
-     Section 3.5.
-
-     3.2. Availability of Source Code.
-     Any Modification which You create or to which You contribute must be
-     made available in Source Code form under the terms of this License
-     either on the same media as an Executable version or via an accepted
-     Electronic Distribution Mechanism to anyone to whom you made an
-     Executable version available; and if made available via Electronic
-     Distribution Mechanism, must remain available for at least twelve (12)
-     months after the date it initially became available, or at least six
-     (6) months after a subsequent version of that particular Modification
-     has been made available to such recipients. You are responsible for
-     ensuring that the Source Code version remains available even if the
-     Electronic Distribution Mechanism is maintained by a third party.
-
-     3.3. Description of Modifications.
-     You must cause all Covered Code to which You contribute to contain a
-     file documenting the changes You made to create that Covered Code and
-     the date of any change. You must include a prominent statement that
-     the Modification is derived, directly or indirectly, from Original
-     Code provided by the Initial Developer and including the name of the
-     Initial Developer in (a) the Source Code, and (b) in any notice in an
-     Executable version or related documentation in which You describe the
-     origin or ownership of the Covered Code.
-
-     3.4. Intellectual Property Matters
-          (a) Third Party Claims.
-          If Contributor has knowledge that a license under a third party's
-          intellectual property rights is required to exercise the rights
-          granted by such Contributor under Sections 2.1 or 2.2,
-          Contributor must include a text file with the Source Code
-          distribution titled "LEGAL" which describes the claim and the
-          party making the claim in sufficient detail that a recipient will
-          know whom to contact. If Contributor obtains such knowledge after
-          the Modification is made available as described in Section 3.2,
-          Contributor shall promptly modify the LEGAL file in all copies
-          Contributor makes available thereafter and shall take other steps
-          (such as notifying appropriate mailing lists or newsgroups)
-          reasonably calculated to inform those who received the Covered
-          Code that new knowledge has been obtained.
-
-          (b) Contributor APIs.
-          If Contributor's Modifications include an application programming
-          interface and Contributor has knowledge of patent licenses which
-          are reasonably necessary to implement that API, Contributor must
-          also include this information in the LEGAL file.
-
-               (c)    Representations.
-          Contributor represents that, except as disclosed pursuant to
-          Section 3.4(a) above, Contributor believes that Contributor's
-          Modifications are Contributor's original creation(s) and/or
-          Contributor has sufficient rights to grant the rights conveyed by
-          this License.
-
-     3.5. Required Notices.
-     You must duplicate the notice in Exhibit A in each file of the Source
-     Code.  If it is not possible to put such notice in a particular Source
-     Code file due to its structure, then You must include such notice in a
-     location (such as a relevant directory) where a user would be likely
-     to look for such a notice.  If You created one or more Modification(s)
-     You may add your name as a Contributor to the notice described in
-     Exhibit A.  You must also duplicate this License in any documentation
-     for the Source Code where You describe recipients' rights or ownership
-     rights relating to Covered Code.  You may choose to offer, and to
-     charge a fee for, warranty, support, indemnity or liability
-     obligations to one or more recipients of Covered Code. However, You
-     may do so only on Your own behalf, and not on behalf of the Initial
-     Developer or any Contributor. You must make it absolutely clear than
-     any such warranty, support, indemnity or liability obligation is
-     offered by You alone, and You hereby agree to indemnify the Initial
-     Developer and every Contributor for any liability incurred by the
-     Initial Developer or such Contributor as a result of warranty,
-     support, indemnity or liability terms You offer.
-
-     3.6. Distribution of Executable Versions.
-     You may distribute Covered Code in Executable form only if the
-     requirements of Section 3.1-3.5 have been met for that Covered Code,
-     and if You include a notice stating that the Source Code version of
-     the Covered Code is available under the terms of this License,
-     including a description of how and where You have fulfilled the
-     obligations of Section 3.2. The notice must be conspicuously included
-     in any notice in an Executable version, related documentation or
-     collateral in which You describe recipients' rights relating to the
-     Covered Code. You may distribute the Executable version of Covered
-     Code or ownership rights under a license of Your choice, which may
-     contain terms different from this License, provided that You are in
-     compliance with the terms of this License and that the license for the
-     Executable version does not attempt to limit or alter the recipient's
-     rights in the Source Code version from the rights set forth in this
-     License. If You distribute the Executable version under a different
-     license You must make it absolutely clear that any terms which differ
-     from this License are offered by You alone, not by the Initial
-     Developer or any Contributor. You hereby agree to indemnify the
-     Initial Developer and every Contributor for any liability incurred by
-     the Initial Developer or such Contributor as a result of any such
-     terms You offer.
-
-     3.7. Larger Works.
-     You may create a Larger Work by combining Covered Code with other code
-     not governed by the terms of this License and distribute the Larger
-     Work as a single product. In such a case, You must make sure the
-     requirements of this License are fulfilled for the Covered Code.
-
-4. Inability to Comply Due to Statute or Regulation.
-
-     If it is impossible for You to comply with any of the terms of this
-     License with respect to some or all of the Covered Code due to
-     statute, judicial order, or regulation then You must: (a) comply with
-     the terms of this License to the maximum extent possible; and (b)
-     describe the limitations and the code they affect. Such description
-     must be included in the LEGAL file described in Section 3.4 and must
-     be included with all distributions of the Source Code. Except to the
-     extent prohibited by statute or regulation, such description must be
-     sufficiently detailed for a recipient of ordinary skill to be able to
-     understand it.
-
-5. Application of this License.
-
-     This License applies to code to which the Initial Developer has
-     attached the notice in Exhibit A and to related Covered Code.
-
-6. Versions of the License.
-
-     6.1. New Versions.
-     Netscape Communications Corporation ("Netscape") may publish revised
-     and/or new versions of the License from time to time. Each version
-     will be given a distinguishing version number.
-
-     6.2. Effect of New Versions.
-     Once Covered Code has been published under a particular version of the
-     License, You may always continue to use it under the terms of that
-     version. You may also choose to use such Covered Code under the terms
-     of any subsequent version of the License published by Netscape. No one
-     other than Netscape has the right to modify the terms applicable to
-     Covered Code created under this License.
-
-     6.3. Derivative Works.
-     If You create or use a modified version of this License (which you may
-     only do in order to apply it to code which is not already Covered Code
-     governed by this License), You must (a) rename Your license so that
-     the phrases "Mozilla", "MOZILLAPL", "MOZPL", "Netscape",
-     "MPL", "NPL" or any confusingly similar phrase do not appear in your
-     license (except to note that your license differs from this License)
-     and (b) otherwise make it clear that Your version of the license
-     contains terms which differ from the Mozilla Public License and
-     Netscape Public License. (Filling in the name of the Initial
-     Developer, Original Code or Contributor in the notice described in
-     Exhibit A shall not of themselves be deemed to be modifications of
-     this License.)
-
-7. DISCLAIMER OF WARRANTY.
-
-     COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS,
-     WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
-     WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF
-     DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING.
-     THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE
-     IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT,
-     YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE
-     COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER
-     OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF
-     ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
-
-8. TERMINATION.
-
-     8.1.  This License and the rights granted hereunder will terminate
-     automatically if You fail to comply with terms herein and fail to cure
-     such breach within 30 days of becoming aware of the breach. All
-     sublicenses to the Covered Code which are properly granted shall
-     survive any termination of this License. Provisions which, by their
-     nature, must remain in effect beyond the termination of this License
-     shall survive.
-
-     8.2.  If You initiate litigation by asserting a patent infringement
-     claim (excluding declatory judgment actions) against Initial Developer
-     or a Contributor (the Initial Developer or Contributor against whom
-     You file such action is referred to as "Participant")  alleging that:
-
-     (a)  such Participant's Contributor Version directly or indirectly
-     infringes any patent, then any and all rights granted by such
-     Participant to You under Sections 2.1 and/or 2.2 of this License
-     shall, upon 60 days notice from Participant terminate prospectively,
-     unless if within 60 days after receipt of notice You either: (i)
-     agree in writing to pay Participant a mutually agreeable reasonable
-     royalty for Your past and future use of Modifications made by such
-     Participant, or (ii) withdraw Your litigation claim with respect to
-     the Contributor Version against such Participant.  If within 60 days
-     of notice, a reasonable royalty and payment arrangement are not
-     mutually agreed upon in writing by the parties or the litigation claim
-     is not withdrawn, the rights granted by Participant to You under
-     Sections 2.1 and/or 2.2 automatically terminate at the expiration of
-     the 60 day notice period specified above.
-
-     (b)  any software, hardware, or device, other than such Participant's
-     Contributor Version, directly or indirectly infringes any patent, then
-     any rights granted to You by such Participant under Sections 2.1(b)
-     and 2.2(b) are revoked effective as of the date You first made, used,
-     sold, distributed, or had made, Modifications made by that
-     Participant.
-
-     8.3.  If You assert a patent infringement claim against Participant
-     alleging that such Participant's Contributor Version directly or
-     indirectly infringes any patent where such claim is resolved (such as
-     by license or settlement) prior to the initiation of patent
-     infringement litigation, then the reasonable value of the licenses
-     granted by such Participant under Sections 2.1 or 2.2 shall be taken
-     into account in determining the amount or value of any payment or
-     license.
-
-     8.4.  In the event of termination under Sections 8.1 or 8.2 above,
-     all end user license agreements (excluding distributors and resellers)
-     which have been validly granted by You or any distributor hereunder
-     prior to termination shall survive termination.
-
-9. LIMITATION OF LIABILITY.
-
-     UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT
-     (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL
-     DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE,
-     OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR
-     ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY
-     CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL,
-     WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER
-     COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN
-     INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF
-     LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY
-     RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW
-     PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE
-     EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO
-     THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.
-
-10. U.S. GOVERNMENT END USERS.
-
-     The Covered Code is a "commercial item," as that term is defined in
-     48 C.F.R. 2.101 (Oct. 1995), consisting of "commercial computer
-     software" and "commercial computer software documentation," as such
-     terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48
-     C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995),
-     all U.S. Government End Users acquire Covered Code with only those
-     rights set forth herein.
-
-11. MISCELLANEOUS.
-
-     This License represents the complete agreement concerning subject
-     matter hereof. If any provision of this License is held to be
-     unenforceable, such provision shall be reformed only to the extent
-     necessary to make it enforceable. This License shall be governed by
-     California law provisions (except to the extent applicable law, if
-     any, provides otherwise), excluding its conflict-of-law provisions.
-     With respect to disputes in which at least one party is a citizen of,
-     or an entity chartered or registered to do business in the United
-     States of America, any litigation relating to this License shall be
-     subject to the jurisdiction of the Federal Courts of the Northern
-     District of California, with venue lying in Santa Clara County,
-     California, with the losing party responsible for costs, including
-     without limitation, court costs and reasonable attorneys' fees and
-     expenses. The application of the United Nations Convention on
-     Contracts for the International Sale of Goods is expressly excluded.
-     Any law or regulation which provides that the language of a contract
-     shall be construed against the drafter shall not apply to this
-     License.
-
-12. RESPONSIBILITY FOR CLAIMS.
-
-     As between Initial Developer and the Contributors, each party is
-     responsible for claims and damages arising, directly or indirectly,
-     out of its utilization of rights under this License and You agree to
-     work with Initial Developer and Contributors to distribute such
-     responsibility on an equitable basis. Nothing herein is intended or
-     shall be deemed to constitute any admission of liability.
-
-13. MULTIPLE-LICENSED CODE.
-
-     Initial Developer may designate portions of the Covered Code as
-     "Multiple-Licensed".  "Multiple-Licensed" means that the Initial
-     Developer permits you to utilize portions of the Covered Code under
-     Your choice of the MPL or the alternative licenses, if any, specified
-     by the Initial Developer in the file described in Exhibit A.
-
-EXHIBIT A -Mozilla Public License.
-
-     ``The contents of this file are subject to the Mozilla Public License
-     Version 1.1 (the "License"); you may not use this file except in
-     compliance with the License. You may obtain a copy of the License at
-     https://www.mozilla.org/MPL/
-
-     Software distributed under the License is distributed on an "AS IS"
-     basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
-     License for the specific language governing rights and limitations
-     under the License.
-
-     The Original Code is ______________________________________.
-
-     The Initial Developer of the Original Code is ________________________.
-     Portions created by ______________________ are Copyright (C) ______
-     _______________________. All Rights Reserved.
-
-     Contributor(s): ______________________________________.
-
-     Alternatively, the contents of this file may be used under the terms
-     of the _____ license (the  "[___] License"), in which case the
-     provisions of [______] License are applicable instead of those
-     above.  If you wish to allow use of your version of this file only
-     under the terms of the [____] License and not to allow others to use
-     your version of this file under the MPL, indicate your decision by
-     deleting  the provisions above and replace  them with the notice and
-     other provisions required by the [___] License.  If you do not delete
-     the provisions above, a recipient may use your version of this file
-     under either the MPL or the [___] License."
-
-     [NOTE: The text of this Exhibit A may differ slightly from the text of
-     the notices in the Source Code files of the Original Code. You should
-     use the text of this Exhibit A rather than the text found in the
-     Original Code Source Code for Your Modifications.]
diff --git a/native/zucchini/vendor/libchrome/base/third_party/nspr/prtime.h b/native/zucchini/vendor/libchrome/base/third_party/nspr/prtime.h
deleted file mode 100644
index 20bae38..0000000
--- a/native/zucchini/vendor/libchrome/base/third_party/nspr/prtime.h
+++ /dev/null
@@ -1,263 +0,0 @@
-/* Portions are Copyright (C) 2011 Google Inc */
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is the Netscape Portable Runtime (NSPR).
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998-2000
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-/*
- *---------------------------------------------------------------------------
- *
- * prtime.h --
- *
- *     NSPR date and time functions
- * CVS revision 3.10
- * This file contains definitions of NSPR's basic types required by
- * prtime.cc. These types have been copied over from the following NSPR
- * files prtime.h, prtypes.h(CVS revision 3.35), prlong.h(CVS revision 3.13)
- *
- *---------------------------------------------------------------------------
- */
-
-#ifndef BASE_PRTIME_H__
-#define BASE_PRTIME_H__
-
-#include <stdint.h>
-
-#include "base/base_export.h"
-
-typedef int8_t PRInt8;
-typedef int16_t PRInt16;
-typedef int32_t PRInt32;
-typedef int64_t PRInt64;
-typedef int PRIntn;
-
-typedef PRIntn PRBool;
-#define PR_TRUE 1
-#define PR_FALSE 0
-
-typedef enum { PR_FAILURE = -1, PR_SUCCESS = 0 } PRStatus;
-
-#define PR_ASSERT DCHECK
-#define PR_CALLBACK
-#define PR_INT16_MAX 32767
-#define NSPR_API(__type) extern __type
-
-/*
- * Long-long (64-bit signed integer type) support macros used by
- * PR_ImplodeTime().
- * See http://lxr.mozilla.org/nspr/source/pr/include/prlong.h
- */
-
-#define LL_I2L(l, i) ((l) = (PRInt64)(i))
-#define LL_MUL(r, a, b) ((r) = (a) * (b))
-#define LL_ADD(r, a, b) ((r) = (a) + (b))
-#define LL_SUB(r, a, b) ((r) = (a) - (b))
-
-/**********************************************************************/
-/************************* TYPES AND CONSTANTS ************************/
-/**********************************************************************/
-
-#define PR_MSEC_PER_SEC		1000UL
-#define PR_USEC_PER_SEC		1000000UL
-#define PR_NSEC_PER_SEC		1000000000UL
-#define PR_USEC_PER_MSEC	1000UL
-#define PR_NSEC_PER_MSEC	1000000UL
-
-/*
- * PRTime --
- *
- *     NSPR represents basic time as 64-bit signed integers relative
- *     to midnight (00:00:00), January 1, 1970 Greenwich Mean Time (GMT).
- *     (GMT is also known as Coordinated Universal Time, UTC.)
- *     The units of time are in microseconds. Negative times are allowed
- *     to represent times prior to the January 1970 epoch. Such values are
- *     intended to be exported to other systems or converted to human
- *     readable form.
- *
- *     Notes on porting: PRTime corresponds to time_t in ANSI C.  NSPR 1.0
- *     simply uses PRInt64.
- */
-
-typedef PRInt64 PRTime;
-
-/*
- * Time zone and daylight saving time corrections applied to GMT to
- * obtain the local time of some geographic location
- */
-
-typedef struct PRTimeParameters {
-    PRInt32 tp_gmt_offset;     /* the offset from GMT in seconds */
-    PRInt32 tp_dst_offset;     /* contribution of DST in seconds */
-} PRTimeParameters;
-
-/*
- * PRExplodedTime --
- *
- *     Time broken down into human-readable components such as year, month,
- *     day, hour, minute, second, and microsecond.  Time zone and daylight
- *     saving time corrections may be applied.  If they are applied, the
- *     offsets from the GMT must be saved in the 'tm_params' field so that
- *     all the information is available to reconstruct GMT.
- *
- *     Notes on porting: PRExplodedTime corrresponds to struct tm in
- *     ANSI C, with the following differences:
- *       - an additional field tm_usec;
- *       - replacing tm_isdst by tm_params;
- *       - the month field is spelled tm_month, not tm_mon;
- *       - we use absolute year, AD, not the year since 1900.
- *     The corresponding type in NSPR 1.0 is called PRTime.  Below is
- *     a table of date/time type correspondence in the three APIs:
- *         API          time since epoch          time in components
- *       ANSI C             time_t                  struct tm
- *       NSPR 1.0           PRInt64                   PRTime
- *       NSPR 2.0           PRTime                  PRExplodedTime
- */
-
-typedef struct PRExplodedTime {
-    PRInt32 tm_usec;		    /* microseconds past tm_sec (0-99999)  */
-    PRInt32 tm_sec;             /* seconds past tm_min (0-61, accomodating
-                                   up to two leap seconds) */	
-    PRInt32 tm_min;             /* minutes past tm_hour (0-59) */
-    PRInt32 tm_hour;            /* hours past tm_day (0-23) */
-    PRInt32 tm_mday;            /* days past tm_mon (1-31, note that it
-				                starts from 1) */
-    PRInt32 tm_month;           /* months past tm_year (0-11, Jan = 0) */
-    PRInt16 tm_year;            /* absolute year, AD (note that we do not
-				                count from 1900) */
-
-    PRInt8 tm_wday;		        /* calculated day of the week
-				                (0-6, Sun = 0) */
-    PRInt16 tm_yday;            /* calculated day of the year
-				                (0-365, Jan 1 = 0) */
-
-    PRTimeParameters tm_params;  /* time parameters used by conversion */
-} PRExplodedTime;
-
-/*
- * PRTimeParamFn --
- *
- *     A function of PRTimeParamFn type returns the time zone and
- *     daylight saving time corrections for some geographic location,
- *     given the current time in GMT.  The input argument gmt should
- *     point to a PRExplodedTime that is in GMT, i.e., whose
- *     tm_params contains all 0's.
- *
- *     For any time zone other than GMT, the computation is intended to
- *     consist of two steps:
- *       - Figure out the time zone correction, tp_gmt_offset.  This number
- *         usually depends on the geographic location only.  But it may
- *         also depend on the current time.  For example, all of China
- *         is one time zone right now.  But this situation may change
- *         in the future.
- *       - Figure out the daylight saving time correction, tp_dst_offset.
- *         This number depends on both the geographic location and the
- *         current time.  Most of the DST rules are expressed in local
- *         current time.  If so, one should apply the time zone correction
- *         to GMT before applying the DST rules.
- */
-
-typedef PRTimeParameters (PR_CALLBACK *PRTimeParamFn)(const PRExplodedTime *gmt);
-
-/**********************************************************************/
-/****************************** FUNCTIONS *****************************/
-/**********************************************************************/
-
-NSPR_API(PRTime)
-PR_ImplodeTime(const PRExplodedTime *exploded);
-
-/*
- * Adjust exploded time to normalize field overflows after manipulation.
- * Note that the following fields of PRExplodedTime should not be
- * manipulated:
- *   - tm_month and tm_year: because the number of days in a month and
- *     number of days in a year are not constant, it is ambiguous to
- *     manipulate the month and year fields, although one may be tempted
- *     to.  For example, what does "a month from January 31st" mean?
- *   - tm_wday and tm_yday: these fields are calculated by NSPR.  Users
- *     should treat them as "read-only".
- */
-
-NSPR_API(void) PR_NormalizeTime(
-    PRExplodedTime *exploded, PRTimeParamFn params);
-
-/**********************************************************************/
-/*********************** TIME PARAMETER FUNCTIONS *********************/
-/**********************************************************************/
-
-/* Time parameters that represent Greenwich Mean Time */
-NSPR_API(PRTimeParameters) PR_GMTParameters(const PRExplodedTime *gmt);
-
-/*
- * This parses a time/date string into a PRTime
- * (microseconds after "1-Jan-1970 00:00:00 GMT").
- * It returns PR_SUCCESS on success, and PR_FAILURE
- * if the time/date string can't be parsed.
- *
- * Many formats are handled, including:
- *
- *   14 Apr 89 03:20:12
- *   14 Apr 89 03:20 GMT
- *   Fri, 17 Mar 89 4:01:33
- *   Fri, 17 Mar 89 4:01 GMT
- *   Mon Jan 16 16:12 PDT 1989
- *   Mon Jan 16 16:12 +0130 1989
- *   6 May 1992 16:41-JST (Wednesday)
- *   22-AUG-1993 10:59:12.82
- *   22-AUG-1993 10:59pm
- *   22-AUG-1993 12:59am
- *   22-AUG-1993 12:59 PM
- *   Friday, August 04, 1995 3:54 PM
- *   06/21/95 04:24:34 PM
- *   20/06/95 21:07
- *   95-06-08 19:32:48 EDT
- *   1995-06-17T23:11:25.342156Z
- *
- * If the input string doesn't contain a description of the timezone,
- * we consult the `default_to_gmt' to decide whether the string should
- * be interpreted relative to the local time zone (PR_FALSE) or GMT (PR_TRUE).
- * The correct value for this argument depends on what standard specified
- * the time string which you are parsing.
- */
-
-/*
- * This is the only funtion that should be called from outside base, and only
- * from the unit test.
- */
-
-BASE_EXPORT PRStatus PR_ParseTimeString (
-	const char *string,
-	PRBool default_to_gmt,
-	PRTime *result);
-
-#endif  // BASE_PRTIME_H__
diff --git a/native/zucchini/vendor/libchrome/base/threading/platform_thread.h b/native/zucchini/vendor/libchrome/base/threading/platform_thread.h
deleted file mode 100644
index faeb858..0000000
--- a/native/zucchini/vendor/libchrome/base/threading/platform_thread.h
+++ /dev/null
@@ -1,240 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// WARNING: You should *NOT* be using this class directly.  PlatformThread is
-// the low-level platform-specific abstraction to the OS's threading interface.
-// You should instead be using a message-loop driven Thread, see thread.h.
-
-#ifndef BASE_THREADING_PLATFORM_THREAD_H_
-#define BASE_THREADING_PLATFORM_THREAD_H_
-
-#include <stddef.h>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/time/time.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include "base/win/windows_types.h"
-#elif defined(OS_FUCHSIA)
-#include <zircon/types.h>
-#elif defined(OS_MACOSX)
-#include <mach/mach_types.h>
-#elif defined(OS_POSIX)
-#include <pthread.h>
-#include <unistd.h>
-#endif
-
-namespace base {
-
-// Used for logging. Always an integer value.
-#if defined(OS_WIN)
-typedef DWORD PlatformThreadId;
-#elif defined(OS_FUCHSIA)
-typedef zx_handle_t PlatformThreadId;
-#elif defined(OS_MACOSX)
-typedef mach_port_t PlatformThreadId;
-#elif defined(OS_POSIX)
-typedef pid_t PlatformThreadId;
-#endif
-
-// Used for thread checking and debugging.
-// Meant to be as fast as possible.
-// These are produced by PlatformThread::CurrentRef(), and used to later
-// check if we are on the same thread or not by using ==. These are safe
-// to copy between threads, but can't be copied to another process as they
-// have no meaning there. Also, the internal identifier can be re-used
-// after a thread dies, so a PlatformThreadRef cannot be reliably used
-// to distinguish a new thread from an old, dead thread.
-class PlatformThreadRef {
- public:
-#if defined(OS_WIN)
-  typedef DWORD RefType;
-#else  //  OS_POSIX
-  typedef pthread_t RefType;
-#endif
-  constexpr PlatformThreadRef() : id_(0) {}
-
-  explicit constexpr PlatformThreadRef(RefType id) : id_(id) {}
-
-  bool operator==(PlatformThreadRef other) const {
-    return id_ == other.id_;
-  }
-
-  bool operator!=(PlatformThreadRef other) const { return id_ != other.id_; }
-
-  bool is_null() const {
-    return id_ == 0;
-  }
- private:
-  RefType id_;
-};
-
-// Used to operate on threads.
-class PlatformThreadHandle {
- public:
-#if defined(OS_WIN)
-  typedef void* Handle;
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  typedef pthread_t Handle;
-#endif
-
-  constexpr PlatformThreadHandle() : handle_(0) {}
-
-  explicit constexpr PlatformThreadHandle(Handle handle) : handle_(handle) {}
-
-  bool is_equal(const PlatformThreadHandle& other) const {
-    return handle_ == other.handle_;
-  }
-
-  bool is_null() const {
-    return !handle_;
-  }
-
-  Handle platform_handle() const {
-    return handle_;
-  }
-
- private:
-  Handle handle_;
-};
-
-const PlatformThreadId kInvalidThreadId(0);
-
-// Valid values for priority of Thread::Options and SimpleThread::Options, and
-// SetCurrentThreadPriority(), listed in increasing order of importance.
-enum class ThreadPriority : int {
-  // Suitable for threads that shouldn't disrupt high priority work.
-  BACKGROUND,
-  // Default priority level.
-  NORMAL,
-  // Suitable for threads which generate data for the display (at ~60Hz).
-  DISPLAY,
-  // Suitable for low-latency, glitch-resistant audio.
-  REALTIME_AUDIO,
-};
-
-// A namespace for low-level thread functions.
-class BASE_EXPORT PlatformThread {
- public:
-  // Implement this interface to run code on a background thread.  Your
-  // ThreadMain method will be called on the newly created thread.
-  class BASE_EXPORT Delegate {
-   public:
-    virtual void ThreadMain() = 0;
-
-   protected:
-    virtual ~Delegate() = default;
-  };
-
-  // Gets the current thread id, which may be useful for logging purposes.
-  static PlatformThreadId CurrentId();
-
-  // Gets the current thread reference, which can be used to check if
-  // we're on the right thread quickly.
-  static PlatformThreadRef CurrentRef();
-
-  // Get the handle representing the current thread. On Windows, this is a
-  // pseudo handle constant which will always represent the thread using it and
-  // hence should not be shared with other threads nor be used to differentiate
-  // the current thread from another.
-  static PlatformThreadHandle CurrentHandle();
-
-  // Yield the current thread so another thread can be scheduled.
-  static void YieldCurrentThread();
-
-  // Sleeps for the specified duration.
-  static void Sleep(base::TimeDelta duration);
-
-  // Sets the thread name visible to debuggers/tools. This will try to
-  // initialize the context for current thread unless it's a WorkerThread.
-  static void SetName(const std::string& name);
-
-  // Gets the thread name, if previously set by SetName.
-  static const char* GetName();
-
-  // Creates a new thread.  The |stack_size| parameter can be 0 to indicate
-  // that the default stack size should be used.  Upon success,
-  // |*thread_handle| will be assigned a handle to the newly created thread,
-  // and |delegate|'s ThreadMain method will be executed on the newly created
-  // thread.
-  // NOTE: When you are done with the thread handle, you must call Join to
-  // release system resources associated with the thread.  You must ensure that
-  // the Delegate object outlives the thread.
-  static bool Create(size_t stack_size,
-                     Delegate* delegate,
-                     PlatformThreadHandle* thread_handle) {
-    return CreateWithPriority(stack_size, delegate, thread_handle,
-                              ThreadPriority::NORMAL);
-  }
-
-  // CreateWithPriority() does the same thing as Create() except the priority of
-  // the thread is set based on |priority|.
-  static bool CreateWithPriority(size_t stack_size, Delegate* delegate,
-                                 PlatformThreadHandle* thread_handle,
-                                 ThreadPriority priority);
-
-  // CreateNonJoinable() does the same thing as Create() except the thread
-  // cannot be Join()'d.  Therefore, it also does not output a
-  // PlatformThreadHandle.
-  static bool CreateNonJoinable(size_t stack_size, Delegate* delegate);
-
-  // CreateNonJoinableWithPriority() does the same thing as CreateNonJoinable()
-  // except the priority of the thread is set based on |priority|.
-  static bool CreateNonJoinableWithPriority(size_t stack_size,
-                                            Delegate* delegate,
-                                            ThreadPriority priority);
-
-  // Joins with a thread created via the Create function.  This function blocks
-  // the caller until the designated thread exits.  This will invalidate
-  // |thread_handle|.
-  static void Join(PlatformThreadHandle thread_handle);
-
-  // Detaches and releases the thread handle. The thread is no longer joinable
-  // and |thread_handle| is invalidated after this call.
-  static void Detach(PlatformThreadHandle thread_handle);
-
-  // Returns true if SetCurrentThreadPriority() can be used to increase the
-  // priority of the current thread.
-  static bool CanIncreaseCurrentThreadPriority();
-
-  // Toggles the current thread's priority at runtime.
-  //
-  // A thread may not be able to raise its priority back up after lowering it if
-  // the process does not have a proper permission, e.g. CAP_SYS_NICE on Linux.
-  // A thread may not be able to lower its priority back down after raising it
-  // to REALTIME_AUDIO.
-  //
-  // This function must not be called from the main thread on Mac. This is to
-  // avoid performance regressions (https://crbug.com/601270).
-  //
-  // Since changing other threads' priority is not permitted in favor of
-  // security, this interface is restricted to change only the current thread
-  // priority (https://crbug.com/399473).
-  static void SetCurrentThreadPriority(ThreadPriority priority);
-
-  static ThreadPriority GetCurrentThreadPriority();
-
-#if defined(OS_LINUX)
-  // Toggles a specific thread's priority at runtime. This can be used to
-  // change the priority of a thread in a different process and will fail
-  // if the calling process does not have proper permissions. The
-  // SetCurrentThreadPriority() function above is preferred in favor of
-  // security but on platforms where sandboxed processes are not allowed to
-  // change priority this function exists to allow a non-sandboxed process
-  // to change the priority of sandboxed threads for improved performance.
-  // Warning: Don't use this for a main thread because that will change the
-  // whole thread group's (i.e. process) priority.
-  static void SetThreadPriority(PlatformThreadId thread_id,
-                                ThreadPriority priority);
-#endif
-
- private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(PlatformThread);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_PLATFORM_THREAD_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/platform_thread_internal_posix.h b/native/zucchini/vendor/libchrome/base/threading/platform_thread_internal_posix.h
deleted file mode 100644
index 5f4a215..0000000
--- a/native/zucchini/vendor/libchrome/base/threading/platform_thread_internal_posix.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_THREADING_PLATFORM_THREAD_INTERNAL_POSIX_H_
-#define BASE_THREADING_PLATFORM_THREAD_INTERNAL_POSIX_H_
-
-#include "base/base_export.h"
-#include "base/threading/platform_thread.h"
-
-namespace base {
-
-namespace internal {
-
-struct ThreadPriorityToNiceValuePair {
-  ThreadPriority priority;
-  int nice_value;
-};
-// The elements must be listed in the order of increasing priority (lowest
-// priority first), that is, in the order of decreasing nice values (highest
-// nice value first).
-BASE_EXPORT extern
-const ThreadPriorityToNiceValuePair kThreadPriorityToNiceValueMap[4];
-
-// Returns the nice value matching |priority| based on the platform-specific
-// implementation of kThreadPriorityToNiceValueMap.
-int ThreadPriorityToNiceValue(ThreadPriority priority);
-
-// Returns the ThreadPrioirty matching |nice_value| based on the platform-
-// specific implementation of kThreadPriorityToNiceValueMap.
-BASE_EXPORT ThreadPriority NiceValueToThreadPriority(int nice_value);
-
-// Allows platform specific tweaks to the generic POSIX solution for
-// SetCurrentThreadPriority. Returns true if the platform-specific
-// implementation handled this |priority| change, false if the generic
-// implementation should instead proceed.
-bool SetCurrentThreadPriorityForPlatform(ThreadPriority priority);
-
-// Returns true if there is a platform-specific ThreadPriority set on the
-// current thread (and returns the actual ThreadPriority via |priority|).
-// Returns false otherwise, leaving |priority| untouched.
-bool GetCurrentThreadPriorityForPlatform(ThreadPriority* priority);
-
-}  // namespace internal
-
-}  // namespace base
-
-#endif  // BASE_THREADING_PLATFORM_THREAD_INTERNAL_POSIX_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/platform_thread_posix.cc b/native/zucchini/vendor/libchrome/base/threading/platform_thread_posix.cc
deleted file mode 100644
index 2466b78..0000000
--- a/native/zucchini/vendor/libchrome/base/threading/platform_thread_posix.cc
+++ /dev/null
@@ -1,305 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/threading/platform_thread.h"
-
-#include <errno.h>
-#include <pthread.h>
-#include <sched.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <memory>
-
-#include "base/debug/activity_tracker.h"
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/threading/platform_thread_internal_posix.h"
-#include "base/threading/thread_id_name_manager.h"
-#include "base/threading/thread_restrictions.h"
-#include "build/build_config.h"
-
-#if defined(OS_LINUX)
-#include <sys/syscall.h>
-#endif
-
-#if defined(OS_FUCHSIA)
-#include <zircon/process.h>
-#else
-#include <sys/resource.h>
-#endif
-
-namespace base {
-
-void InitThreading();
-void TerminateOnThread();
-size_t GetDefaultThreadStackSize(const pthread_attr_t& attributes);
-
-namespace {
-
-struct ThreadParams {
-  ThreadParams()
-      : delegate(nullptr), joinable(false), priority(ThreadPriority::NORMAL) {}
-
-  PlatformThread::Delegate* delegate;
-  bool joinable;
-  ThreadPriority priority;
-};
-
-void* ThreadFunc(void* params) {
-  PlatformThread::Delegate* delegate = nullptr;
-
-  {
-    std::unique_ptr<ThreadParams> thread_params(
-        static_cast<ThreadParams*>(params));
-
-    delegate = thread_params->delegate;
-    if (!thread_params->joinable)
-      base::ThreadRestrictions::SetSingletonAllowed(false);
-
-#if !defined(OS_NACL)
-    // Threads on linux/android may inherit their priority from the thread
-    // where they were created. This explicitly sets the priority of all new
-    // threads.
-    PlatformThread::SetCurrentThreadPriority(thread_params->priority);
-#endif
-  }
-
-  ThreadIdNameManager::GetInstance()->RegisterThread(
-      PlatformThread::CurrentHandle().platform_handle(),
-      PlatformThread::CurrentId());
-
-  delegate->ThreadMain();
-
-  ThreadIdNameManager::GetInstance()->RemoveName(
-      PlatformThread::CurrentHandle().platform_handle(),
-      PlatformThread::CurrentId());
-
-  base::TerminateOnThread();
-  return nullptr;
-}
-
-bool CreateThread(size_t stack_size,
-                  bool joinable,
-                  PlatformThread::Delegate* delegate,
-                  PlatformThreadHandle* thread_handle,
-                  ThreadPriority priority) {
-  DCHECK(thread_handle);
-  base::InitThreading();
-
-  pthread_attr_t attributes;
-  pthread_attr_init(&attributes);
-
-  // Pthreads are joinable by default, so only specify the detached
-  // attribute if the thread should be non-joinable.
-  if (!joinable)
-    pthread_attr_setdetachstate(&attributes, PTHREAD_CREATE_DETACHED);
-
-  // Get a better default if available.
-  if (stack_size == 0)
-    stack_size = base::GetDefaultThreadStackSize(attributes);
-
-  if (stack_size > 0)
-    pthread_attr_setstacksize(&attributes, stack_size);
-
-  std::unique_ptr<ThreadParams> params(new ThreadParams);
-  params->delegate = delegate;
-  params->joinable = joinable;
-  params->priority = priority;
-
-  pthread_t handle;
-  int err = pthread_create(&handle, &attributes, ThreadFunc, params.get());
-  bool success = !err;
-  if (success) {
-    // ThreadParams should be deleted on the created thread after used.
-    ignore_result(params.release());
-  } else {
-    // Value of |handle| is undefined if pthread_create fails.
-    handle = 0;
-    errno = err;
-    PLOG(ERROR) << "pthread_create";
-  }
-  *thread_handle = PlatformThreadHandle(handle);
-
-  pthread_attr_destroy(&attributes);
-
-  return success;
-}
-
-}  // namespace
-
-// static
-PlatformThreadId PlatformThread::CurrentId() {
-  // Pthreads doesn't have the concept of a thread ID, so we have to reach down
-  // into the kernel.
-#if defined(OS_MACOSX)
-  return pthread_mach_thread_np(pthread_self());
-#elif defined(OS_LINUX)
-  return syscall(__NR_gettid);
-#elif defined(OS_ANDROID)
-  return gettid();
-#elif defined(OS_FUCHSIA)
-  return zx_thread_self();
-#elif defined(OS_SOLARIS) || defined(OS_QNX)
-  return pthread_self();
-#elif defined(OS_NACL) && defined(__GLIBC__)
-  return pthread_self();
-#elif defined(OS_NACL) && !defined(__GLIBC__)
-  // Pointers are 32-bits in NaCl.
-  return reinterpret_cast<int32_t>(pthread_self());
-#elif defined(OS_POSIX) && defined(OS_AIX)
-  return pthread_self();
-#elif defined(OS_POSIX) && !defined(OS_AIX)
-  return reinterpret_cast<int64_t>(pthread_self());
-#endif
-}
-
-// static
-PlatformThreadRef PlatformThread::CurrentRef() {
-  return PlatformThreadRef(pthread_self());
-}
-
-// static
-PlatformThreadHandle PlatformThread::CurrentHandle() {
-  return PlatformThreadHandle(pthread_self());
-}
-
-// static
-void PlatformThread::YieldCurrentThread() {
-  sched_yield();
-}
-
-// static
-void PlatformThread::Sleep(TimeDelta duration) {
-  struct timespec sleep_time, remaining;
-
-  // Break the duration into seconds and nanoseconds.
-  // NOTE: TimeDelta's microseconds are int64s while timespec's
-  // nanoseconds are longs, so this unpacking must prevent overflow.
-  sleep_time.tv_sec = duration.InSeconds();
-  duration -= TimeDelta::FromSeconds(sleep_time.tv_sec);
-  sleep_time.tv_nsec = duration.InMicroseconds() * 1000;  // nanoseconds
-
-  while (nanosleep(&sleep_time, &remaining) == -1 && errno == EINTR)
-    sleep_time = remaining;
-}
-
-// static
-const char* PlatformThread::GetName() {
-  return ThreadIdNameManager::GetInstance()->GetName(CurrentId());
-}
-
-// static
-bool PlatformThread::CreateWithPriority(size_t stack_size, Delegate* delegate,
-                                        PlatformThreadHandle* thread_handle,
-                                        ThreadPriority priority) {
-  return CreateThread(stack_size, true /* joinable thread */, delegate,
-                      thread_handle, priority);
-}
-
-// static
-bool PlatformThread::CreateNonJoinable(size_t stack_size, Delegate* delegate) {
-  return CreateNonJoinableWithPriority(stack_size, delegate,
-                                       ThreadPriority::NORMAL);
-}
-
-// static
-bool PlatformThread::CreateNonJoinableWithPriority(size_t stack_size,
-                                                   Delegate* delegate,
-                                                   ThreadPriority priority) {
-  PlatformThreadHandle unused;
-
-  bool result = CreateThread(stack_size, false /* non-joinable thread */,
-                             delegate, &unused, priority);
-  return result;
-}
-
-// static
-void PlatformThread::Join(PlatformThreadHandle thread_handle) {
-  // Record the event that this thread is blocking upon (for hang diagnosis).
-  base::debug::ScopedThreadJoinActivity thread_activity(&thread_handle);
-
-  // Joining another thread may block the current thread for a long time, since
-  // the thread referred to by |thread_handle| may still be running long-lived /
-  // blocking tasks.
-  AssertBlockingAllowed();
-  CHECK_EQ(0, pthread_join(thread_handle.platform_handle(), nullptr));
-}
-
-// static
-void PlatformThread::Detach(PlatformThreadHandle thread_handle) {
-  CHECK_EQ(0, pthread_detach(thread_handle.platform_handle()));
-}
-
-// Mac and Fuchsia have their own Set/GetCurrentThreadPriority()
-// implementations.
-#if !defined(OS_MACOSX) && !defined(OS_FUCHSIA)
-
-// static
-bool PlatformThread::CanIncreaseCurrentThreadPriority() {
-#if defined(OS_NACL)
-  return false;
-#else
-  // Only root can raise thread priority on POSIX environment. On Linux, users
-  // who have CAP_SYS_NICE permission also can raise the thread priority, but
-  // libcap.so would be needed to check the capability.
-  return geteuid() == 0;
-#endif  // defined(OS_NACL)
-}
-
-// static
-void PlatformThread::SetCurrentThreadPriority(ThreadPriority priority) {
-#if defined(OS_NACL)
-  NOTIMPLEMENTED();
-#else
-  if (internal::SetCurrentThreadPriorityForPlatform(priority))
-    return;
-
-  // setpriority(2) should change the whole thread group's (i.e. process)
-  // priority. However, as stated in the bugs section of
-  // http://man7.org/linux/man-pages/man2/getpriority.2.html: "under the current
-  // Linux/NPTL implementation of POSIX threads, the nice value is a per-thread
-  // attribute". Also, 0 is prefered to the current thread id since it is
-  // equivalent but makes sandboxing easier (https://crbug.com/399473).
-  const int nice_setting = internal::ThreadPriorityToNiceValue(priority);
-  if (setpriority(PRIO_PROCESS, 0, nice_setting)) {
-    DVPLOG(1) << "Failed to set nice value of thread ("
-              << PlatformThread::CurrentId() << ") to " << nice_setting;
-  }
-#endif  // defined(OS_NACL)
-}
-
-// static
-ThreadPriority PlatformThread::GetCurrentThreadPriority() {
-#if defined(OS_NACL)
-  NOTIMPLEMENTED();
-  return ThreadPriority::NORMAL;
-#else
-  // Mirrors SetCurrentThreadPriority()'s implementation.
-  ThreadPriority platform_specific_priority;
-  if (internal::GetCurrentThreadPriorityForPlatform(
-          &platform_specific_priority)) {
-    return platform_specific_priority;
-  }
-
-  // Need to clear errno before calling getpriority():
-  // http://man7.org/linux/man-pages/man2/getpriority.2.html
-  errno = 0;
-  int nice_value = getpriority(PRIO_PROCESS, 0);
-  if (errno != 0) {
-    DVPLOG(1) << "Failed to get nice value of thread ("
-              << PlatformThread::CurrentId() << ")";
-    return ThreadPriority::NORMAL;
-  }
-
-  return internal::NiceValueToThreadPriority(nice_value);
-#endif  // !defined(OS_NACL)
-}
-
-#endif  // !defined(OS_MACOSX) && !defined(OS_FUCHSIA)
-
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/threading/sequenced_task_runner_handle.h b/native/zucchini/vendor/libchrome/base/threading/sequenced_task_runner_handle.h
deleted file mode 100644
index f55cee5..0000000
--- a/native/zucchini/vendor/libchrome/base/threading/sequenced_task_runner_handle.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_THREADING_SEQUENCED_TASK_RUNNER_HANDLE_H_
-#define BASE_THREADING_SEQUENCED_TASK_RUNNER_HANDLE_H_
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/sequenced_task_runner.h"
-
-namespace base {
-
-class BASE_EXPORT SequencedTaskRunnerHandle {
- public:
-  // Returns a SequencedTaskRunner which guarantees that posted tasks will only
-  // run after the current task is finished and will satisfy a SequenceChecker.
-  // It should only be called if IsSet() returns true (see the comment there for
-  // the requirements).
-  static scoped_refptr<SequencedTaskRunner> Get();
-
-  // Returns true if one of the following conditions is fulfilled:
-  // a) A SequencedTaskRunner has been assigned to the current thread by
-  //    instantiating a SequencedTaskRunnerHandle.
-  // b) The current thread has a ThreadTaskRunnerHandle (which includes any
-  //    thread that has a MessageLoop associated with it).
-  static bool IsSet();
-
-  // Binds |task_runner| to the current thread.
-  explicit SequencedTaskRunnerHandle(
-      scoped_refptr<SequencedTaskRunner> task_runner);
-  ~SequencedTaskRunnerHandle();
-
- private:
-  scoped_refptr<SequencedTaskRunner> task_runner_;
-
-  DISALLOW_COPY_AND_ASSIGN(SequencedTaskRunnerHandle);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_SEQUENCED_TASK_RUNNER_HANDLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_collision_warner.h b/native/zucchini/vendor/libchrome/base/threading/thread_collision_warner.h
deleted file mode 100644
index b6993f6..0000000
--- a/native/zucchini/vendor/libchrome/base/threading/thread_collision_warner.h
+++ /dev/null
@@ -1,245 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_THREADING_THREAD_COLLISION_WARNER_H_
-#define BASE_THREADING_THREAD_COLLISION_WARNER_H_
-
-#include <memory>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-
-// A helper class alongside macros to be used to verify assumptions about thread
-// safety of a class.
-//
-// Example: Queue implementation non thread-safe but still usable if clients
-//          are synchronized somehow.
-//
-//          In this case the macro DFAKE_SCOPED_LOCK has to be
-//          used, it checks that if a thread is inside the push/pop then
-//          noone else is still inside the pop/push
-//
-// class NonThreadSafeQueue {
-//  public:
-//   ...
-//   void push(int) { DFAKE_SCOPED_LOCK(push_pop_); ... }
-//   int pop() { DFAKE_SCOPED_LOCK(push_pop_); ... }
-//   ...
-//  private:
-//   DFAKE_MUTEX(push_pop_);
-// };
-//
-//
-// Example: Queue implementation non thread-safe but still usable if clients
-//          are synchronized somehow, it calls a method to "protect" from
-//          a "protected" method
-//
-//          In this case the macro DFAKE_SCOPED_RECURSIVE_LOCK
-//          has to be used, it checks that if a thread is inside the push/pop
-//          then noone else is still inside the pop/push
-//
-// class NonThreadSafeQueue {
-//  public:
-//   void push(int) {
-//     DFAKE_SCOPED_LOCK(push_pop_);
-//     ...
-//   }
-//   int pop() {
-//     DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_);
-//     bar();
-//     ...
-//   }
-//   void bar() { DFAKE_SCOPED_RECURSIVE_LOCK(push_pop_); ... }
-//   ...
-//  private:
-//   DFAKE_MUTEX(push_pop_);
-// };
-//
-//
-// Example: Queue implementation not usable even if clients are synchronized,
-//          so only one thread in the class life cycle can use the two members
-//          push/pop.
-//
-//          In this case the macro DFAKE_SCOPED_LOCK_THREAD_LOCKED pins the
-//          specified
-//          critical section the first time a thread enters push or pop, from
-//          that time on only that thread is allowed to execute push or pop.
-//
-// class NonThreadSafeQueue {
-//  public:
-//   ...
-//   void push(int) { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
-//   int pop() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(push_pop_); ... }
-//   ...
-//  private:
-//   DFAKE_MUTEX(push_pop_);
-// };
-//
-//
-// Example: Class that has to be contructed/destroyed on same thread, it has
-//          a "shareable" method (with external synchronization) and a not
-//          shareable method (even with external synchronization).
-//
-//          In this case 3 Critical sections have to be defined
-//
-// class ExoticClass {
-//  public:
-//   ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
-//   ~ExoticClass() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
-//
-//   void Shareable() { DFAKE_SCOPED_LOCK(shareable_section_); ... }
-//   void NotShareable() { DFAKE_SCOPED_LOCK_THREAD_LOCKED(ctor_dtor_); ... }
-//   ...
-//  private:
-//   DFAKE_MUTEX(ctor_dtor_);
-//   DFAKE_MUTEX(shareable_section_);
-// };
-
-
-#if !defined(NDEBUG)
-
-// Defines a class member that acts like a mutex. It is used only as a
-// verification tool.
-#define DFAKE_MUTEX(obj) \
-     mutable base::ThreadCollisionWarner obj
-// Asserts the call is never called simultaneously in two threads. Used at
-// member function scope.
-#define DFAKE_SCOPED_LOCK(obj) \
-     base::ThreadCollisionWarner::ScopedCheck s_check_##obj(&obj)
-// Asserts the call is never called simultaneously in two threads. Used at
-// member function scope. Same as DFAKE_SCOPED_LOCK but allows recursive locks.
-#define DFAKE_SCOPED_RECURSIVE_LOCK(obj) \
-     base::ThreadCollisionWarner::ScopedRecursiveCheck sr_check_##obj(&obj)
-// Asserts the code is always executed in the same thread.
-#define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) \
-     base::ThreadCollisionWarner::Check check_##obj(&obj)
-
-#else
-
-#define DFAKE_MUTEX(obj) typedef void InternalFakeMutexType##obj
-#define DFAKE_SCOPED_LOCK(obj) ((void)0)
-#define DFAKE_SCOPED_RECURSIVE_LOCK(obj) ((void)0)
-#define DFAKE_SCOPED_LOCK_THREAD_LOCKED(obj) ((void)0)
-
-#endif
-
-namespace base {
-
-// The class ThreadCollisionWarner uses an Asserter to notify the collision
-// AsserterBase is the interfaces and DCheckAsserter is the default asserter
-// used. During the unit tests is used another class that doesn't "DCHECK"
-// in case of collision (check thread_collision_warner_unittests.cc)
-struct BASE_EXPORT AsserterBase {
-  virtual ~AsserterBase() = default;
-  virtual void warn() = 0;
-};
-
-struct BASE_EXPORT DCheckAsserter : public AsserterBase {
-  ~DCheckAsserter() override = default;
-  void warn() override;
-};
-
-class BASE_EXPORT ThreadCollisionWarner {
- public:
-  // The parameter asserter is there only for test purpose
-  explicit ThreadCollisionWarner(AsserterBase* asserter = new DCheckAsserter())
-      : valid_thread_id_(0),
-        counter_(0),
-        asserter_(asserter) {}
-
-  ~ThreadCollisionWarner() {
-    delete asserter_;
-  }
-
-  // This class is meant to be used through the macro
-  // DFAKE_SCOPED_LOCK_THREAD_LOCKED
-  // it doesn't leave the critical section, as opposed to ScopedCheck,
-  // because the critical section being pinned is allowed to be used only
-  // from one thread
-  class BASE_EXPORT Check {
-   public:
-    explicit Check(ThreadCollisionWarner* warner)
-        : warner_(warner) {
-      warner_->EnterSelf();
-    }
-
-    ~Check() = default;
-
-   private:
-    ThreadCollisionWarner* warner_;
-
-    DISALLOW_COPY_AND_ASSIGN(Check);
-  };
-
-  // This class is meant to be used through the macro
-  // DFAKE_SCOPED_LOCK
-  class BASE_EXPORT ScopedCheck {
-   public:
-    explicit ScopedCheck(ThreadCollisionWarner* warner)
-        : warner_(warner) {
-      warner_->Enter();
-    }
-
-    ~ScopedCheck() {
-      warner_->Leave();
-    }
-
-   private:
-    ThreadCollisionWarner* warner_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedCheck);
-  };
-
-  // This class is meant to be used through the macro
-  // DFAKE_SCOPED_RECURSIVE_LOCK
-  class BASE_EXPORT ScopedRecursiveCheck {
-   public:
-    explicit ScopedRecursiveCheck(ThreadCollisionWarner* warner)
-        : warner_(warner) {
-      warner_->EnterSelf();
-    }
-
-    ~ScopedRecursiveCheck() {
-      warner_->Leave();
-    }
-
-   private:
-    ThreadCollisionWarner* warner_;
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedRecursiveCheck);
-  };
-
- private:
-  // This method stores the current thread identifier and does a DCHECK
-  // if a another thread has already done it, it is safe if same thread
-  // calls this multiple time (recursion allowed).
-  void EnterSelf();
-
-  // Same as EnterSelf but recursion is not allowed.
-  void Enter();
-
-  // Removes the thread_id stored in order to allow other threads to
-  // call EnterSelf or Enter.
-  void Leave();
-
-  // This stores the thread id that is inside the critical section, if the
-  // value is 0 then no thread is inside.
-  volatile subtle::Atomic32 valid_thread_id_;
-
-  // Counter to trace how many time a critical section was "pinned"
-  // (when allowed) in order to unpin it when counter_ reaches 0.
-  volatile subtle::Atomic32 counter_;
-
-  // Here only for class unit tests purpose, during the test I need to not
-  // DCHECK but notify the collision with something else.
-  AsserterBase* asserter_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadCollisionWarner);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_THREAD_COLLISION_WARNER_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_id_name_manager.h b/native/zucchini/vendor/libchrome/base/threading/thread_id_name_manager.h
deleted file mode 100644
index f17dc1a..0000000
--- a/native/zucchini/vendor/libchrome/base/threading/thread_id_name_manager.h
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_THREADING_THREAD_ID_NAME_MANAGER_H_
-#define BASE_THREADING_THREAD_ID_NAME_MANAGER_H_
-
-#include <map>
-#include <string>
-
-#include "base/base_export.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/synchronization/lock.h"
-#include "base/threading/platform_thread.h"
-
-namespace base {
-
-template <typename T>
-struct DefaultSingletonTraits;
-
-class BASE_EXPORT ThreadIdNameManager {
- public:
-  static ThreadIdNameManager* GetInstance();
-
-  static const char* GetDefaultInternedString();
-
-  // Register the mapping between a thread |id| and |handle|.
-  void RegisterThread(PlatformThreadHandle::Handle handle, PlatformThreadId id);
-
-  // The callback is called on the thread, immediately after the name is set.
-  // |name| is a pointer to a C string that is guaranteed to remain valid for
-  // the duration of the process.
-  using SetNameCallback = base::RepeatingCallback<void(const char* name)>;
-  void InstallSetNameCallback(SetNameCallback callback);
-
-  // Set the name for the current thread.
-  void SetName(const std::string& name);
-
-  // Get the name for the given id.
-  const char* GetName(PlatformThreadId id);
-
-  // Unlike |GetName|, this method using TLS and avoids touching |lock_|.
-  const char* GetNameForCurrentThread();
-
-  // Remove the name for the given id.
-  void RemoveName(PlatformThreadHandle::Handle handle, PlatformThreadId id);
-
- private:
-  friend struct DefaultSingletonTraits<ThreadIdNameManager>;
-
-  typedef std::map<PlatformThreadId, PlatformThreadHandle::Handle>
-      ThreadIdToHandleMap;
-  typedef std::map<PlatformThreadHandle::Handle, std::string*>
-      ThreadHandleToInternedNameMap;
-  typedef std::map<std::string, std::string*> NameToInternedNameMap;
-
-  ThreadIdNameManager();
-  ~ThreadIdNameManager();
-
-  // lock_ protects the name_to_interned_name_, thread_id_to_handle_ and
-  // thread_handle_to_interned_name_ maps.
-  Lock lock_;
-
-  NameToInternedNameMap name_to_interned_name_;
-  ThreadIdToHandleMap thread_id_to_handle_;
-  ThreadHandleToInternedNameMap thread_handle_to_interned_name_;
-
-  // Treat the main process specially as there is no PlatformThreadHandle.
-  std::string* main_process_name_;
-  PlatformThreadId main_process_id_;
-
-  SetNameCallback set_name_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadIdNameManager);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_THREAD_ID_NAME_MANAGER_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_local.h b/native/zucchini/vendor/libchrome/base/threading/thread_local.h
deleted file mode 100644
index cad9add..0000000
--- a/native/zucchini/vendor/libchrome/base/threading/thread_local.h
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// WARNING: Thread local storage is a bit tricky to get right. Please make sure
-// that this is really the proper solution for what you're trying to achieve.
-// Don't prematurely optimize, most likely you can just use a Lock.
-//
-// These classes implement a wrapper around ThreadLocalStorage::Slot. On
-// construction, they will allocate a TLS slot, and free the TLS slot on
-// destruction. No memory management (creation or destruction) is handled. This
-// means for uses of ThreadLocalPointer, you must correctly manage the memory
-// yourself, these classes will not destroy the pointer for you. There are no
-// at-thread-exit actions taken by these classes.
-//
-// ThreadLocalPointer<Type> wraps a Type*. It performs no creation or
-// destruction, so memory management must be handled elsewhere. The first call
-// to Get() on a thread will return NULL. You can update the pointer with a call
-// to Set().
-//
-// ThreadLocalBoolean wraps a bool. It will default to false if it has never
-// been set otherwise with Set().
-//
-// Thread Safety: An instance of ThreadLocalStorage is completely thread safe
-// once it has been created. If you want to dynamically create an instance, you
-// must of course properly deal with safety and race conditions. This means a
-// function-level static initializer is generally inappropiate.
-//
-// In Android, the system TLS is limited.
-//
-// Example usage:
-//   // My class is logically attached to a single thread. We cache a pointer
-//   // on the thread it was created on, so we can implement current().
-//   MyClass::MyClass() {
-//     DCHECK(Singleton<ThreadLocalPointer<MyClass> >::get()->Get() == NULL);
-//     Singleton<ThreadLocalPointer<MyClass> >::get()->Set(this);
-//   }
-//
-//   MyClass::~MyClass() {
-//     DCHECK(Singleton<ThreadLocalPointer<MyClass> >::get()->Get() != NULL);
-//     Singleton<ThreadLocalPointer<MyClass> >::get()->Set(NULL);
-//   }
-//
-//   // Return the current MyClass associated with the calling thread, can be
-//   // NULL if there isn't a MyClass associated.
-//   MyClass* MyClass::current() {
-//     return Singleton<ThreadLocalPointer<MyClass> >::get()->Get();
-//   }
-
-#ifndef BASE_THREADING_THREAD_LOCAL_H_
-#define BASE_THREADING_THREAD_LOCAL_H_
-
-#include "base/macros.h"
-#include "base/threading/thread_local_storage.h"
-
-namespace base {
-
-template <typename Type>
-class ThreadLocalPointer {
- public:
-  ThreadLocalPointer() = default;
-  ~ThreadLocalPointer() = default;
-
-  Type* Get() {
-    return static_cast<Type*>(slot_.Get());
-  }
-
-  void Set(Type* ptr) {
-    slot_.Set(const_cast<void*>(static_cast<const void*>(ptr)));
-  }
-
- private:
-  ThreadLocalStorage::Slot slot_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadLocalPointer<Type>);
-};
-
-class ThreadLocalBoolean {
- public:
-  ThreadLocalBoolean() = default;
-  ~ThreadLocalBoolean() = default;
-
-  bool Get() {
-    return tlp_.Get() != nullptr;
-  }
-
-  void Set(bool val) {
-    tlp_.Set(val ? this : nullptr);
-  }
-
- private:
-  ThreadLocalPointer<void> tlp_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadLocalBoolean);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_THREAD_LOCAL_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_local_storage.cc b/native/zucchini/vendor/libchrome/base/threading/thread_local_storage.cc
deleted file mode 100644
index c9f8c62..0000000
--- a/native/zucchini/vendor/libchrome/base/threading/thread_local_storage.cc
+++ /dev/null
@@ -1,408 +0,0 @@
-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/threading/thread_local_storage.h"
-
-#include "base/atomicops.h"
-#include "base/logging.h"
-#include "base/synchronization/lock.h"
-#include "build/build_config.h"
-
-using base::internal::PlatformThreadLocalStorage;
-
-// Chrome Thread Local Storage (TLS)
-//
-// This TLS system allows Chrome to use a single OS level TLS slot process-wide,
-// and allows us to control the slot limits instead of being at the mercy of the
-// platform. To do this, Chrome TLS replicates an array commonly found in the OS
-// thread metadata.
-//
-// Overview:
-//
-// OS TLS Slots       Per-Thread                 Per-Process Global
-//     ...
-//     []             Chrome TLS Array           Chrome TLS Metadata
-//     [] ----------> [][][][][ ][][][][]        [][][][][ ][][][][]
-//     []                      |                          |
-//     ...                     V                          V
-//                      Metadata Version           Slot Information
-//                         Your Data!
-//
-// Using a single OS TLS slot, Chrome TLS allocates an array on demand for the
-// lifetime of each thread that requests Chrome TLS data. Each per-thread TLS
-// array matches the length of the per-process global metadata array.
-//
-// A per-process global TLS metadata array tracks information about each item in
-// the per-thread array:
-//   * Status: Tracks if the slot is allocated or free to assign.
-//   * Destructor: An optional destructor to call on thread destruction for that
-//                 specific slot.
-//   * Version: Tracks the current version of the TLS slot. Each TLS slot
-//              allocation is associated with a unique version number.
-//
-//              Most OS TLS APIs guarantee that a newly allocated TLS slot is
-//              initialized to 0 for all threads. The Chrome TLS system provides
-//              this guarantee by tracking the version for each TLS slot here
-//              on each per-thread Chrome TLS array entry. Threads that access
-//              a slot with a mismatched version will receive 0 as their value.
-//              The metadata version is incremented when the client frees a
-//              slot. The per-thread metadata version is updated when a client
-//              writes to the slot. This scheme allows for constant time
-//              invalidation and avoids the need to iterate through each Chrome
-//              TLS array to mark the slot as zero.
-//
-// Just like an OS TLS API, clients of the Chrome TLS are responsible for
-// managing any necessary lifetime of the data in their slots. The only
-// convenience provided is automatic destruction when a thread ends. If a client
-// frees a slot, that client is responsible for destroying the data in the slot.
-
-namespace {
-// In order to make TLS destructors work, we need to keep around a function
-// pointer to the destructor for each slot. We keep this array of pointers in a
-// global (static) array.
-// We use the single OS-level TLS slot (giving us one pointer per thread) to
-// hold a pointer to a per-thread array (table) of slots that we allocate to
-// Chromium consumers.
-
-// g_native_tls_key is the one native TLS that we use. It stores our table.
-base::subtle::Atomic32 g_native_tls_key =
-    PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES;
-
-// The OS TLS slot has three states:
-//   * kUninitialized: Any call to Slot::Get()/Set() will create the base
-//     per-thread TLS state. On POSIX, kUninitialized must be 0.
-//   * [Memory Address]: Raw pointer to the base per-thread TLS state.
-//   * kDestroyed: The base per-thread TLS state has been freed.
-//
-// Final States:
-//   * Windows: kDestroyed. Windows does not iterate through the OS TLS to clean
-//     up the values.
-//   * POSIX: kUninitialized. POSIX iterates through TLS until all slots contain
-//     nullptr.
-//
-// More details on this design:
-//   We need some type of thread-local state to indicate that the TLS system has
-//   been destroyed. To do so, we leverage the multi-pass nature of destruction
-//   of pthread_key.
-//
-//    a) After destruction of TLS system, we set the pthread_key to a sentinel
-//       kDestroyed.
-//    b) All calls to Slot::Get() DCHECK that the state is not kDestroyed, and
-//       any system which might potentially invoke Slot::Get() after destruction
-//       of TLS must check ThreadLocalStorage::ThreadIsBeingDestroyed().
-//    c) After a full pass of the pthread_keys, on the next invocation of
-//       ConstructTlsVector(), we'll then set the key to nullptr.
-//    d) At this stage, the TLS system is back in its uninitialized state.
-//    e) If in the second pass of destruction of pthread_keys something were to
-//       re-initialize TLS [this should never happen! Since the only code which
-//       uses Chrome TLS is Chrome controlled, we should really be striving for
-//       single-pass destruction], then TLS will be re-initialized and then go
-//       through the 2-pass destruction system again. Everything should just
-//       work (TM).
-
-// The consumers of kUninitialized and kDestroyed expect void*, since that's
-// what the API exposes on both POSIX and Windows.
-void* const kUninitialized = nullptr;
-
-// A sentinel value to indicate that the TLS system has been destroyed.
-void* const kDestroyed = reinterpret_cast<void*>(1);
-
-// The maximum number of slots in our thread local storage stack.
-constexpr int kThreadLocalStorageSize = 256;
-
-enum TlsStatus {
-  FREE,
-  IN_USE,
-};
-
-struct TlsMetadata {
-  TlsStatus status;
-  base::ThreadLocalStorage::TLSDestructorFunc destructor;
-  uint32_t version;
-};
-
-struct TlsVectorEntry {
-  void* data;
-  uint32_t version;
-};
-
-// This lock isn't needed until after we've constructed the per-thread TLS
-// vector, so it's safe to use.
-base::Lock* GetTLSMetadataLock() {
-  static auto* lock = new base::Lock();
-  return lock;
-}
-TlsMetadata g_tls_metadata[kThreadLocalStorageSize];
-size_t g_last_assigned_slot = 0;
-
-// The maximum number of times to try to clear slots by calling destructors.
-// Use pthread naming convention for clarity.
-constexpr int kMaxDestructorIterations = kThreadLocalStorageSize;
-
-// This function is called to initialize our entire Chromium TLS system.
-// It may be called very early, and we need to complete most all of the setup
-// (initialization) before calling *any* memory allocator functions, which may
-// recursively depend on this initialization.
-// As a result, we use Atomics, and avoid anything (like a singleton) that might
-// require memory allocations.
-TlsVectorEntry* ConstructTlsVector() {
-  PlatformThreadLocalStorage::TLSKey key =
-      base::subtle::NoBarrier_Load(&g_native_tls_key);
-  if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES) {
-    CHECK(PlatformThreadLocalStorage::AllocTLS(&key));
-
-    // The TLS_KEY_OUT_OF_INDEXES is used to find out whether the key is set or
-    // not in NoBarrier_CompareAndSwap, but Posix doesn't have invalid key, we
-    // define an almost impossible value be it.
-    // If we really get TLS_KEY_OUT_OF_INDEXES as value of key, just alloc
-    // another TLS slot.
-    if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES) {
-      PlatformThreadLocalStorage::TLSKey tmp = key;
-      CHECK(PlatformThreadLocalStorage::AllocTLS(&key) &&
-            key != PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES);
-      PlatformThreadLocalStorage::FreeTLS(tmp);
-    }
-    // Atomically test-and-set the tls_key. If the key is
-    // TLS_KEY_OUT_OF_INDEXES, go ahead and set it. Otherwise, do nothing, as
-    // another thread already did our dirty work.
-    if (PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES !=
-        static_cast<PlatformThreadLocalStorage::TLSKey>(
-            base::subtle::NoBarrier_CompareAndSwap(
-                &g_native_tls_key,
-                PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES, key))) {
-      // We've been shortcut. Another thread replaced g_native_tls_key first so
-      // we need to destroy our index and use the one the other thread got
-      // first.
-      PlatformThreadLocalStorage::FreeTLS(key);
-      key = base::subtle::NoBarrier_Load(&g_native_tls_key);
-    }
-  }
-  CHECK_EQ(PlatformThreadLocalStorage::GetTLSValue(key), kUninitialized);
-
-  // Some allocators, such as TCMalloc, make use of thread local storage. As a
-  // result, any attempt to call new (or malloc) will lazily cause such a system
-  // to initialize, which will include registering for a TLS key. If we are not
-  // careful here, then that request to create a key will call new back, and
-  // we'll have an infinite loop. We avoid that as follows: Use a stack
-  // allocated vector, so that we don't have dependence on our allocator until
-  // our service is in place. (i.e., don't even call new until after we're
-  // setup)
-  TlsVectorEntry stack_allocated_tls_data[kThreadLocalStorageSize];
-  memset(stack_allocated_tls_data, 0, sizeof(stack_allocated_tls_data));
-  // Ensure that any rentrant calls change the temp version.
-  PlatformThreadLocalStorage::SetTLSValue(key, stack_allocated_tls_data);
-
-  // Allocate an array to store our data.
-  TlsVectorEntry* tls_data = new TlsVectorEntry[kThreadLocalStorageSize];
-  memcpy(tls_data, stack_allocated_tls_data, sizeof(stack_allocated_tls_data));
-  PlatformThreadLocalStorage::SetTLSValue(key, tls_data);
-  return tls_data;
-}
-
-void OnThreadExitInternal(TlsVectorEntry* tls_data) {
-  // This branch is for POSIX, where this function is called twice. The first
-  // pass calls dtors and sets state to kDestroyed. The second pass sets
-  // kDestroyed to kUninitialized.
-  if (tls_data == kDestroyed) {
-    PlatformThreadLocalStorage::TLSKey key =
-        base::subtle::NoBarrier_Load(&g_native_tls_key);
-    PlatformThreadLocalStorage::SetTLSValue(key, kUninitialized);
-    return;
-  }
-
-  DCHECK(tls_data);
-  // Some allocators, such as TCMalloc, use TLS. As a result, when a thread
-  // terminates, one of the destructor calls we make may be to shut down an
-  // allocator. We have to be careful that after we've shutdown all of the known
-  // destructors (perchance including an allocator), that we don't call the
-  // allocator and cause it to resurrect itself (with no possibly destructor
-  // call to follow). We handle this problem as follows: Switch to using a stack
-  // allocated vector, so that we don't have dependence on our allocator after
-  // we have called all g_tls_metadata destructors. (i.e., don't even call
-  // delete[] after we're done with destructors.)
-  TlsVectorEntry stack_allocated_tls_data[kThreadLocalStorageSize];
-  memcpy(stack_allocated_tls_data, tls_data, sizeof(stack_allocated_tls_data));
-  // Ensure that any re-entrant calls change the temp version.
-  PlatformThreadLocalStorage::TLSKey key =
-      base::subtle::NoBarrier_Load(&g_native_tls_key);
-  PlatformThreadLocalStorage::SetTLSValue(key, stack_allocated_tls_data);
-  delete[] tls_data;  // Our last dependence on an allocator.
-
-  // Snapshot the TLS Metadata so we don't have to lock on every access.
-  TlsMetadata tls_metadata[kThreadLocalStorageSize];
-  {
-    base::AutoLock auto_lock(*GetTLSMetadataLock());
-    memcpy(tls_metadata, g_tls_metadata, sizeof(g_tls_metadata));
-  }
-
-  int remaining_attempts = kMaxDestructorIterations;
-  bool need_to_scan_destructors = true;
-  while (need_to_scan_destructors) {
-    need_to_scan_destructors = false;
-    // Try to destroy the first-created-slot (which is slot 1) in our last
-    // destructor call. That user was able to function, and define a slot with
-    // no other services running, so perhaps it is a basic service (like an
-    // allocator) and should also be destroyed last. If we get the order wrong,
-    // then we'll iterate several more times, so it is really not that critical
-    // (but it might help).
-    for (int slot = 0; slot < kThreadLocalStorageSize ; ++slot) {
-      void* tls_value = stack_allocated_tls_data[slot].data;
-      if (!tls_value || tls_metadata[slot].status == TlsStatus::FREE ||
-          stack_allocated_tls_data[slot].version != tls_metadata[slot].version)
-        continue;
-
-      base::ThreadLocalStorage::TLSDestructorFunc destructor =
-          tls_metadata[slot].destructor;
-      if (!destructor)
-        continue;
-      stack_allocated_tls_data[slot].data = nullptr;  // pre-clear the slot.
-      destructor(tls_value);
-      // Any destructor might have called a different service, which then set a
-      // different slot to a non-null value. Hence we need to check the whole
-      // vector again. This is a pthread standard.
-      need_to_scan_destructors = true;
-    }
-    if (--remaining_attempts <= 0) {
-      NOTREACHED();  // Destructors might not have been called.
-      break;
-    }
-  }
-
-  // Remove our stack allocated vector.
-  PlatformThreadLocalStorage::SetTLSValue(key, kDestroyed);
-}
-
-}  // namespace
-
-namespace base {
-
-namespace internal {
-
-#if defined(OS_WIN)
-void PlatformThreadLocalStorage::OnThreadExit() {
-  PlatformThreadLocalStorage::TLSKey key =
-      base::subtle::NoBarrier_Load(&g_native_tls_key);
-  if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES)
-    return;
-  void *tls_data = GetTLSValue(key);
-
-  // On Windows, thread destruction callbacks are only invoked once per module,
-  // so there should be no way that this could be invoked twice.
-  DCHECK_NE(tls_data, kDestroyed);
-
-  // Maybe we have never initialized TLS for this thread.
-  if (tls_data == kUninitialized)
-    return;
-  OnThreadExitInternal(static_cast<TlsVectorEntry*>(tls_data));
-}
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-void PlatformThreadLocalStorage::OnThreadExit(void* value) {
-  OnThreadExitInternal(static_cast<TlsVectorEntry*>(value));
-}
-
-// static
-void PlatformThreadLocalStorage::ForceFreeTLS() {
-  PlatformThreadLocalStorage::TLSKey key =
-      base::subtle::NoBarrier_AtomicExchange(
-          &g_native_tls_key,
-          PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES);
-  if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES)
-    return;
-  PlatformThreadLocalStorage::FreeTLS(key);
-}
-#endif  // defined(OS_WIN)
-
-}  // namespace internal
-
-bool ThreadLocalStorage::HasBeenDestroyed() {
-  PlatformThreadLocalStorage::TLSKey key =
-      base::subtle::NoBarrier_Load(&g_native_tls_key);
-  if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES)
-    return false;
-  return PlatformThreadLocalStorage::GetTLSValue(key) == kDestroyed;
-}
-
-void ThreadLocalStorage::Slot::Initialize(TLSDestructorFunc destructor) {
-  PlatformThreadLocalStorage::TLSKey key =
-      base::subtle::NoBarrier_Load(&g_native_tls_key);
-  if (key == PlatformThreadLocalStorage::TLS_KEY_OUT_OF_INDEXES ||
-      PlatformThreadLocalStorage::GetTLSValue(key) == kUninitialized) {
-    ConstructTlsVector();
-  }
-
-  // Grab a new slot.
-  {
-    base::AutoLock auto_lock(*GetTLSMetadataLock());
-    for (int i = 0; i < kThreadLocalStorageSize; ++i) {
-      // Tracking the last assigned slot is an attempt to find the next
-      // available slot within one iteration. Under normal usage, slots remain
-      // in use for the lifetime of the process (otherwise before we reclaimed
-      // slots, we would have run out of slots). This makes it highly likely the
-      // next slot is going to be a free slot.
-      size_t slot_candidate =
-          (g_last_assigned_slot + 1 + i) % kThreadLocalStorageSize;
-      if (g_tls_metadata[slot_candidate].status == TlsStatus::FREE) {
-        g_tls_metadata[slot_candidate].status = TlsStatus::IN_USE;
-        g_tls_metadata[slot_candidate].destructor = destructor;
-        g_last_assigned_slot = slot_candidate;
-        DCHECK_EQ(kInvalidSlotValue, slot_);
-        slot_ = slot_candidate;
-        version_ = g_tls_metadata[slot_candidate].version;
-        break;
-      }
-    }
-  }
-  CHECK_NE(slot_, kInvalidSlotValue);
-  CHECK_LT(slot_, kThreadLocalStorageSize);
-}
-
-void ThreadLocalStorage::Slot::Free() {
-  DCHECK_NE(slot_, kInvalidSlotValue);
-  DCHECK_LT(slot_, kThreadLocalStorageSize);
-  {
-    base::AutoLock auto_lock(*GetTLSMetadataLock());
-    g_tls_metadata[slot_].status = TlsStatus::FREE;
-    g_tls_metadata[slot_].destructor = nullptr;
-    ++(g_tls_metadata[slot_].version);
-  }
-  slot_ = kInvalidSlotValue;
-}
-
-void* ThreadLocalStorage::Slot::Get() const {
-  TlsVectorEntry* tls_data = static_cast<TlsVectorEntry*>(
-      PlatformThreadLocalStorage::GetTLSValue(
-          base::subtle::NoBarrier_Load(&g_native_tls_key)));
-  DCHECK_NE(tls_data, kDestroyed);
-  if (!tls_data)
-    return nullptr;
-  DCHECK_NE(slot_, kInvalidSlotValue);
-  DCHECK_LT(slot_, kThreadLocalStorageSize);
-  // Version mismatches means this slot was previously freed.
-  if (tls_data[slot_].version != version_)
-    return nullptr;
-  return tls_data[slot_].data;
-}
-
-void ThreadLocalStorage::Slot::Set(void* value) {
-  TlsVectorEntry* tls_data = static_cast<TlsVectorEntry*>(
-      PlatformThreadLocalStorage::GetTLSValue(
-          base::subtle::NoBarrier_Load(&g_native_tls_key)));
-  DCHECK_NE(tls_data, kDestroyed);
-  if (!tls_data)
-    tls_data = ConstructTlsVector();
-  DCHECK_NE(slot_, kInvalidSlotValue);
-  DCHECK_LT(slot_, kThreadLocalStorageSize);
-  tls_data[slot_].data = value;
-  tls_data[slot_].version = version_;
-}
-
-ThreadLocalStorage::Slot::Slot(TLSDestructorFunc destructor) {
-  Initialize(destructor);
-}
-
-ThreadLocalStorage::Slot::~Slot() {
-  Free();
-}
-
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_local_storage.h b/native/zucchini/vendor/libchrome/base/threading/thread_local_storage.h
deleted file mode 100644
index d6b62c1..0000000
--- a/native/zucchini/vendor/libchrome/base/threading/thread_local_storage.h
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_THREADING_THREAD_LOCAL_STORAGE_H_
-#define BASE_THREADING_THREAD_LOCAL_STORAGE_H_
-
-#include <stdint.h>
-
-#include "base/atomicops.h"
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "build/build_config.h"
-
-#if defined(OS_WIN)
-#include "base/win/windows_types.h"
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <pthread.h>
-#endif
-
-namespace heap_profiling {
-class ScopedAllowAlloc;
-}  // namespace heap_profiling
-
-namespace ui {
-class TLSDestructionCheckerForX11;
-}
-
-namespace base {
-
-class SamplingHeapProfiler;
-
-namespace debug {
-class GlobalActivityTracker;
-}  // namespace debug
-
-namespace trace_event {
-class MallocDumpProvider;
-}  // namespace trace_event
-
-namespace internal {
-
-class ThreadLocalStorageTestInternal;
-
-// WARNING: You should *NOT* use this class directly.
-// PlatformThreadLocalStorage is a low-level abstraction of the OS's TLS
-// interface. Instead, you should use one of the following:
-// * ThreadLocalBoolean (from thread_local.h) for booleans.
-// * ThreadLocalPointer (from thread_local.h) for pointers.
-// * ThreadLocalStorage::StaticSlot/Slot for more direct control of the slot.
-class BASE_EXPORT PlatformThreadLocalStorage {
- public:
-
-#if defined(OS_WIN)
-  typedef unsigned long TLSKey;
-  enum : unsigned { TLS_KEY_OUT_OF_INDEXES = TLS_OUT_OF_INDEXES };
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  typedef pthread_key_t TLSKey;
-  // The following is a "reserved key" which is used in our generic Chromium
-  // ThreadLocalStorage implementation.  We expect that an OS will not return
-  // such a key, but if it is returned (i.e., the OS tries to allocate it) we
-  // will just request another key.
-  enum { TLS_KEY_OUT_OF_INDEXES = 0x7FFFFFFF };
-#endif
-
-  // The following methods need to be supported on each OS platform, so that
-  // the Chromium ThreadLocalStore functionality can be constructed.
-  // Chromium will use these methods to acquire a single OS slot, and then use
-  // that to support a much larger number of Chromium slots (independent of the
-  // OS restrictions).
-  // The following returns true if it successfully is able to return an OS
-  // key in |key|.
-  static bool AllocTLS(TLSKey* key);
-  // Note: FreeTLS() doesn't have to be called, it is fine with this leak, OS
-  // might not reuse released slot, you might just reset the TLS value with
-  // SetTLSValue().
-  static void FreeTLS(TLSKey key);
-  static void SetTLSValue(TLSKey key, void* value);
-  static void* GetTLSValue(TLSKey key) {
-#if defined(OS_WIN)
-    return TlsGetValue(key);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-    return pthread_getspecific(key);
-#endif
-  }
-
-  // Each platform (OS implementation) is required to call this method on each
-  // terminating thread when the thread is about to terminate.  This method
-  // will then call all registered destructors for slots in Chromium
-  // ThreadLocalStorage, until there are no slot values remaining as having
-  // been set on this thread.
-  // Destructors may end up being called multiple times on a terminating
-  // thread, as other destructors may re-set slots that were previously
-  // destroyed.
-#if defined(OS_WIN)
-  // Since Windows which doesn't support TLS destructor, the implementation
-  // should use GetTLSValue() to retrieve the value of TLS slot.
-  static void OnThreadExit();
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  // |Value| is the data stored in TLS slot, The implementation can't use
-  // GetTLSValue() to retrieve the value of slot as it has already been reset
-  // in Posix.
-  static void OnThreadExit(void* value);
-  // Normally, Chrome runs as a process, so freeing the TLS is not needed since
-  // the OS will perform that while it's reclaiming the process' memory upon
-  // termination. If, however, this code is used inside a library that is
-  // dynamically loaded and unloaded, the consumer is responsible for calling
-  // this after all Chrome threads have stopped and prior to unloading the
-  // library.
-  static void ForceFreeTLS();
-#endif
-};
-
-}  // namespace internal
-
-// Wrapper for thread local storage.  This class doesn't do much except provide
-// an API for portability.
-class BASE_EXPORT ThreadLocalStorage {
- public:
-  // Prototype for the TLS destructor function, which can be optionally used to
-  // cleanup thread local storage on thread exit.  'value' is the data that is
-  // stored in thread local storage.
-  typedef void (*TLSDestructorFunc)(void* value);
-
-  // A key representing one value stored in TLS. Use as a class member or a
-  // local variable. If you need a static storage duration variable, use the
-  // following pattern with a NoDestructor<Slot>:
-  // void MyDestructorFunc(void* value);
-  // ThreadLocalStorage::Slot& ImportantContentTLS() {
-  //   static NoDestructor<ThreadLocalStorage::Slot> important_content_tls(
-  //       &MyDestructorFunc);
-  //   return *important_content_tls;
-  // }
-  class BASE_EXPORT Slot final {
-   public:
-    // |destructor| is a pointer to a function to perform per-thread cleanup of
-    // this object.  If set to nullptr, no cleanup is done for this TLS slot.
-    explicit Slot(TLSDestructorFunc destructor = nullptr);
-    // If a destructor was set for this slot, removes the destructor so that
-    // remaining threads exiting will not free data.
-    ~Slot();
-
-    // Get the thread-local value stored in slot 'slot'.
-    // Values are guaranteed to initially be zero.
-    void* Get() const;
-
-    // Set the thread-local value stored in slot 'slot' to
-    // value 'value'.
-    void Set(void* value);
-
-   private:
-    void Initialize(TLSDestructorFunc destructor);
-    void Free();
-
-    static constexpr int kInvalidSlotValue = -1;
-    int slot_ = kInvalidSlotValue;
-    uint32_t version_ = 0;
-
-    DISALLOW_COPY_AND_ASSIGN(Slot);
-  };
-
- private:
-  // In most cases, most callers should not need access to HasBeenDestroyed().
-  // If you are working in code that runs during thread destruction, contact the
-  // base OWNERs for advice and then make a friend request.
-  //
-  // Returns |true| if Chrome's implementation of TLS has been destroyed during
-  // thread destruction. Attempting to call Slot::Get() during destruction is
-  // disallowed and will hit a DCHECK. Any code that relies on TLS during thread
-  // destruction must first check this method before calling Slot::Get().
-  friend class base::SamplingHeapProfiler;
-  friend class base::internal::ThreadLocalStorageTestInternal;
-  friend class base::trace_event::MallocDumpProvider;
-  friend class debug::GlobalActivityTracker;
-  friend class heap_profiling::ScopedAllowAlloc;
-  friend class ui::TLSDestructionCheckerForX11;
-  static bool HasBeenDestroyed();
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadLocalStorage);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_THREAD_LOCAL_STORAGE_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_restrictions.h b/native/zucchini/vendor/libchrome/base/threading/thread_restrictions.h
deleted file mode 100644
index 705ba4d..0000000
--- a/native/zucchini/vendor/libchrome/base/threading/thread_restrictions.h
+++ /dev/null
@@ -1,536 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_THREADING_THREAD_RESTRICTIONS_H_
-#define BASE_THREADING_THREAD_RESTRICTIONS_H_
-
-#include "base/base_export.h"
-#include "base/gtest_prod_util.h"
-#include "base/logging.h"
-#include "base/macros.h"
-
-class BrowserProcessImpl;
-class HistogramSynchronizer;
-class NativeBackendKWallet;
-class KeyStorageLinux;
-
-namespace android_webview {
-class AwFormDatabaseService;
-class CookieManager;
-class ScopedAllowInitGLBindings;
-}
-
-namespace cc {
-class CompletionEvent;
-class SingleThreadTaskGraphRunner;
-}
-namespace chromeos {
-class BlockingMethodCaller;
-namespace system {
-class StatisticsProviderImpl;
-}
-}
-namespace chrome_browser_net {
-class Predictor;
-}
-namespace content {
-class BrowserGpuChannelHostFactory;
-class BrowserGpuMemoryBufferManager;
-class BrowserMainLoop;
-class BrowserProcessSubThread;
-class BrowserShutdownProfileDumper;
-class BrowserTestBase;
-class CategorizedWorkerPool;
-class GpuProcessTransportFactory;
-class NestedMessagePumpAndroid;
-class ScopedAllowWaitForAndroidLayoutTests;
-class ScopedAllowWaitForDebugURL;
-class SessionStorageDatabase;
-class SoftwareOutputDeviceMus;
-class ServiceWorkerSubresourceLoader;
-class SynchronousCompositor;
-class SynchronousCompositorHost;
-class SynchronousCompositorSyncCallBridge;
-class TextInputClientMac;
-}  // namespace content
-namespace cronet {
-class CronetPrefsManager;
-class CronetURLRequestContext;
-}  // namespace cronet
-namespace dbus {
-class Bus;
-}
-namespace disk_cache {
-class BackendImpl;
-class InFlightIO;
-}
-namespace functions {
-class ExecScriptScopedAllowBaseSyncPrimitives;
-}
-namespace gpu {
-class GpuChannelHost;
-}
-namespace leveldb {
-class LevelDBMojoProxy;
-}
-namespace media {
-class AudioInputDevice;
-class BlockingUrlProtocol;
-}
-namespace midi {
-class TaskService;  // https://crbug.com/796830
-}
-namespace mojo {
-class CoreLibraryInitializer;
-class SyncCallRestrictions;
-namespace core {
-class ScopedIPCSupport;
-}
-}
-namespace rlz_lib {
-class FinancialPing;
-}
-namespace ui {
-class CommandBufferClientImpl;
-class CommandBufferLocal;
-class GpuState;
-class MaterialDesignController;
-}
-namespace net {
-class MultiThreadedCertVerifierScopedAllowBaseSyncPrimitives;
-class NetworkChangeNotifierMac;
-namespace internal {
-class AddressTrackerLinux;
-}
-}
-
-namespace remoting {
-class AutoThread;
-}
-
-namespace resource_coordinator {
-class TabManagerDelegate;
-}
-
-namespace service_manager {
-class ServiceProcessLauncher;
-}
-
-namespace shell_integration {
-class LaunchXdgUtilityScopedAllowBaseSyncPrimitives;
-}
-
-namespace ui {
-class WindowResizeHelperMac;
-}
-
-namespace views {
-class ScreenMus;
-}
-
-namespace viz {
-class HostGpuMemoryBufferManager;
-}
-
-namespace webrtc {
-class DesktopConfigurationMonitor;
-}
-
-namespace base {
-
-namespace android {
-class JavaHandlerThread;
-}
-
-namespace internal {
-class TaskTracker;
-}
-
-class GetAppOutputScopedAllowBaseSyncPrimitives;
-class SimpleThread;
-class StackSamplingProfiler;
-class Thread;
-class ThreadTestHelper;
-
-#if DCHECK_IS_ON()
-#define INLINE_IF_DCHECK_IS_OFF BASE_EXPORT
-#define EMPTY_BODY_IF_DCHECK_IS_OFF
-#else
-#define INLINE_IF_DCHECK_IS_OFF inline
-#define EMPTY_BODY_IF_DCHECK_IS_OFF \
-  {}
-#endif
-
-// A "blocking call" refers to any call that causes the calling thread to wait
-// off-CPU. It includes but is not limited to calls that wait on synchronous
-// file I/O operations: read or write a file from disk, interact with a pipe or
-// a socket, rename or delete a file, enumerate files in a directory, etc.
-// Acquiring a low contention lock is not considered a blocking call.
-
-// Asserts that blocking calls are allowed in the current scope.
-//
-// Style tip: It's best if you put AssertBlockingAllowed() checks as close to
-// the blocking call as possible. For example:
-//
-// void ReadFile() {
-//   PreWork();
-//
-//   base::AssertBlockingAllowed();
-//   fopen(...);
-//
-//   PostWork();
-// }
-//
-// void Bar() {
-//   ReadFile();
-// }
-//
-// void Foo() {
-//   Bar();
-// }
-INLINE_IF_DCHECK_IS_OFF void AssertBlockingAllowed()
-    EMPTY_BODY_IF_DCHECK_IS_OFF;
-
-// Disallows blocking on the current thread.
-INLINE_IF_DCHECK_IS_OFF void DisallowBlocking() EMPTY_BODY_IF_DCHECK_IS_OFF;
-
-// Disallows blocking calls within its scope.
-class BASE_EXPORT ScopedDisallowBlocking {
- public:
-  ScopedDisallowBlocking() EMPTY_BODY_IF_DCHECK_IS_OFF;
-  ~ScopedDisallowBlocking() EMPTY_BODY_IF_DCHECK_IS_OFF;
-
- private:
-#if DCHECK_IS_ON()
-  const bool was_disallowed_;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedDisallowBlocking);
-};
-
-// ScopedAllowBlocking(ForTesting) allow blocking calls within a scope where
-// they are normally disallowed.
-//
-// Avoid using this. Prefer making blocking calls from tasks posted to
-// base::TaskScheduler with base::MayBlock().
-//
-// Where unavoidable, put ScopedAllow* instances in the narrowest scope possible
-// in the caller making the blocking call but no further down. That is: if a
-// Cleanup() method needs to do a blocking call, document Cleanup() as blocking
-// and add a ScopedAllowBlocking instance in callers that can't avoid making
-// this call from a context where blocking is banned, as such:
-//   void Client::MyMethod() {
-//     (...)
-//     {
-//       // Blocking is okay here because XYZ.
-//       ScopedAllowBlocking allow_blocking;
-//       my_foo_->Cleanup();
-//     }
-//     (...)
-//   }
-//
-//   // This method can block.
-//   void Foo::Cleanup() {
-//     // Do NOT add the ScopedAllowBlocking in Cleanup() directly as that hides
-//     // its blocking nature from unknowing callers and defeats the purpose of
-//     // these checks.
-//     FlushStateToDisk();
-//   }
-//
-// Note: In rare situations where the blocking call is an implementation detail
-// (i.e. the impl makes a call that invokes AssertBlockingAllowed() but it
-// somehow knows that in practice this will not block), it might be okay to hide
-// the ScopedAllowBlocking instance in the impl with a comment explaining why
-// that's okay.
-class BASE_EXPORT ScopedAllowBlocking {
- private:
-  // This can only be instantiated by friends. Use ScopedAllowBlockingForTesting
-  // in unit tests to avoid the friend requirement.
-  FRIEND_TEST_ALL_PREFIXES(ThreadRestrictionsTest, ScopedAllowBlocking);
-  friend class android_webview::ScopedAllowInitGLBindings;
-  friend class content::BrowserProcessSubThread;
-  friend class content::GpuProcessTransportFactory;
-  friend class cronet::CronetPrefsManager;
-  friend class cronet::CronetURLRequestContext;
-  friend class media::AudioInputDevice;
-  friend class mojo::CoreLibraryInitializer;
-  friend class resource_coordinator::TabManagerDelegate;  // crbug.com/778703
-  friend class ui::MaterialDesignController;
-  friend class ScopedAllowBlockingForTesting;
-  friend class StackSamplingProfiler;
-
-  ScopedAllowBlocking() EMPTY_BODY_IF_DCHECK_IS_OFF;
-  ~ScopedAllowBlocking() EMPTY_BODY_IF_DCHECK_IS_OFF;
-
-#if DCHECK_IS_ON()
-  const bool was_disallowed_;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedAllowBlocking);
-};
-
-class ScopedAllowBlockingForTesting {
- public:
-  ScopedAllowBlockingForTesting() {}
-  ~ScopedAllowBlockingForTesting() {}
-
- private:
-#if DCHECK_IS_ON()
-  ScopedAllowBlocking scoped_allow_blocking_;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedAllowBlockingForTesting);
-};
-
-// "Waiting on a //base sync primitive" refers to calling one of these methods:
-// - base::WaitableEvent::*Wait*
-// - base::ConditionVariable::*Wait*
-// - base::Process::WaitForExit*
-
-// Disallows waiting on a //base sync primitive on the current thread.
-INLINE_IF_DCHECK_IS_OFF void DisallowBaseSyncPrimitives()
-    EMPTY_BODY_IF_DCHECK_IS_OFF;
-
-// ScopedAllowBaseSyncPrimitives(ForTesting)(OutsideBlockingScope) allow waiting
-// on a //base sync primitive within a scope where this is normally disallowed.
-//
-// Avoid using this.
-//
-// Instead of waiting on a WaitableEvent or a ConditionVariable, put the work
-// that should happen after the wait in a callback and post that callback from
-// where the WaitableEvent or ConditionVariable would have been signaled. If
-// something needs to be scheduled after many tasks have executed, use
-// base::BarrierClosure.
-//
-// On Windows, join processes asynchronously using base::win::ObjectWatcher.
-
-// This can only be used in a scope where blocking is allowed.
-class BASE_EXPORT ScopedAllowBaseSyncPrimitives {
- private:
-  // This can only be instantiated by friends. Use
-  // ScopedAllowBaseSyncPrimitivesForTesting in unit tests to avoid the friend
-  // requirement.
-  FRIEND_TEST_ALL_PREFIXES(ThreadRestrictionsTest,
-                           ScopedAllowBaseSyncPrimitives);
-  FRIEND_TEST_ALL_PREFIXES(ThreadRestrictionsTest,
-                           ScopedAllowBaseSyncPrimitivesResetsState);
-  FRIEND_TEST_ALL_PREFIXES(ThreadRestrictionsTest,
-                           ScopedAllowBaseSyncPrimitivesWithBlockingDisallowed);
-  friend class base::GetAppOutputScopedAllowBaseSyncPrimitives;
-  friend class content::BrowserProcessSubThread;
-  friend class content::SessionStorageDatabase;
-  friend class functions::ExecScriptScopedAllowBaseSyncPrimitives;
-  friend class leveldb::LevelDBMojoProxy;
-  friend class media::BlockingUrlProtocol;
-  friend class mojo::core::ScopedIPCSupport;
-  friend class net::MultiThreadedCertVerifierScopedAllowBaseSyncPrimitives;
-  friend class rlz_lib::FinancialPing;
-  friend class shell_integration::LaunchXdgUtilityScopedAllowBaseSyncPrimitives;
-  friend class webrtc::DesktopConfigurationMonitor;
-  friend class content::ServiceWorkerSubresourceLoader;
-  friend class viz::HostGpuMemoryBufferManager;
-
-  ScopedAllowBaseSyncPrimitives() EMPTY_BODY_IF_DCHECK_IS_OFF;
-  ~ScopedAllowBaseSyncPrimitives() EMPTY_BODY_IF_DCHECK_IS_OFF;
-
-#if DCHECK_IS_ON()
-  const bool was_disallowed_;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedAllowBaseSyncPrimitives);
-};
-
-// This can be used in a scope where blocking is disallowed.
-class BASE_EXPORT ScopedAllowBaseSyncPrimitivesOutsideBlockingScope {
- private:
-  // This can only be instantiated by friends. Use
-  // ScopedAllowBaseSyncPrimitivesForTesting in unit tests to avoid the friend
-  // requirement.
-  FRIEND_TEST_ALL_PREFIXES(ThreadRestrictionsTest,
-                           ScopedAllowBaseSyncPrimitivesOutsideBlockingScope);
-  FRIEND_TEST_ALL_PREFIXES(
-      ThreadRestrictionsTest,
-      ScopedAllowBaseSyncPrimitivesOutsideBlockingScopeResetsState);
-  friend class ::KeyStorageLinux;
-  friend class content::SynchronousCompositor;
-  friend class content::SynchronousCompositorHost;
-  friend class content::SynchronousCompositorSyncCallBridge;
-  friend class midi::TaskService;  // https://crbug.com/796830
-  // Not used in production yet, https://crbug.com/844078.
-  friend class service_manager::ServiceProcessLauncher;
-
-  ScopedAllowBaseSyncPrimitivesOutsideBlockingScope()
-      EMPTY_BODY_IF_DCHECK_IS_OFF;
-  ~ScopedAllowBaseSyncPrimitivesOutsideBlockingScope()
-      EMPTY_BODY_IF_DCHECK_IS_OFF;
-
-#if DCHECK_IS_ON()
-  const bool was_disallowed_;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedAllowBaseSyncPrimitivesOutsideBlockingScope);
-};
-
-// This can be used in tests without being a friend of
-// ScopedAllowBaseSyncPrimitives(OutsideBlockingScope).
-class BASE_EXPORT ScopedAllowBaseSyncPrimitivesForTesting {
- public:
-  ScopedAllowBaseSyncPrimitivesForTesting() EMPTY_BODY_IF_DCHECK_IS_OFF;
-  ~ScopedAllowBaseSyncPrimitivesForTesting() EMPTY_BODY_IF_DCHECK_IS_OFF;
-
- private:
-#if DCHECK_IS_ON()
-  const bool was_disallowed_;
-#endif
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedAllowBaseSyncPrimitivesForTesting);
-};
-
-namespace internal {
-
-// Asserts that waiting on a //base sync primitive is allowed in the current
-// scope.
-INLINE_IF_DCHECK_IS_OFF void AssertBaseSyncPrimitivesAllowed()
-    EMPTY_BODY_IF_DCHECK_IS_OFF;
-
-// Resets all thread restrictions on the current thread.
-INLINE_IF_DCHECK_IS_OFF void ResetThreadRestrictionsForTesting()
-    EMPTY_BODY_IF_DCHECK_IS_OFF;
-
-}  // namespace internal
-
-class BASE_EXPORT ThreadRestrictions {
- public:
-  // Constructing a ScopedAllowIO temporarily allows IO for the current
-  // thread.  Doing this is almost certainly always incorrect.
-  //
-  // DEPRECATED. Use ScopedAllowBlocking(ForTesting).
-  class BASE_EXPORT ScopedAllowIO {
-   public:
-    ScopedAllowIO() EMPTY_BODY_IF_DCHECK_IS_OFF;
-    ~ScopedAllowIO() EMPTY_BODY_IF_DCHECK_IS_OFF;
-
-   private:
-#if DCHECK_IS_ON()
-    const bool was_allowed_;
-#endif
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedAllowIO);
-  };
-
-#if DCHECK_IS_ON()
-  // Set whether the current thread to make IO calls.
-  // Threads start out in the *allowed* state.
-  // Returns the previous value.
-  //
-  // DEPRECATED. Use ScopedAllowBlocking(ForTesting) or ScopedDisallowBlocking.
-  static bool SetIOAllowed(bool allowed);
-
-  // Set whether the current thread can use singletons.  Returns the previous
-  // value.
-  static bool SetSingletonAllowed(bool allowed);
-
-  // Check whether the current thread is allowed to use singletons (Singleton /
-  // LazyInstance).  DCHECKs if not.
-  static void AssertSingletonAllowed();
-
-  // Disable waiting on the current thread. Threads start out in the *allowed*
-  // state. Returns the previous value.
-  //
-  // DEPRECATED. Use DisallowBaseSyncPrimitives.
-  static void DisallowWaiting();
-#else
-  // Inline the empty definitions of these functions so that they can be
-  // compiled out.
-  static bool SetIOAllowed(bool allowed) { return true; }
-  static bool SetSingletonAllowed(bool allowed) { return true; }
-  static void AssertSingletonAllowed() {}
-  static void DisallowWaiting() {}
-#endif
-
- private:
-  // DO NOT ADD ANY OTHER FRIEND STATEMENTS.
-  // BEGIN ALLOWED USAGE.
-  friend class android_webview::AwFormDatabaseService;
-  friend class android_webview::CookieManager;
-  friend class base::StackSamplingProfiler;
-  friend class content::BrowserMainLoop;
-  friend class content::BrowserShutdownProfileDumper;
-  friend class content::BrowserTestBase;
-  friend class content::NestedMessagePumpAndroid;
-  friend class content::ScopedAllowWaitForAndroidLayoutTests;
-  friend class content::ScopedAllowWaitForDebugURL;
-  friend class ::HistogramSynchronizer;
-  friend class internal::TaskTracker;
-  friend class cc::CompletionEvent;
-  friend class cc::SingleThreadTaskGraphRunner;
-  friend class content::CategorizedWorkerPool;
-  friend class remoting::AutoThread;
-  friend class ui::WindowResizeHelperMac;
-  friend class MessagePumpDefault;
-  friend class SimpleThread;
-  friend class Thread;
-  friend class ThreadTestHelper;
-  friend class PlatformThread;
-  friend class android::JavaHandlerThread;
-  friend class mojo::SyncCallRestrictions;
-  friend class ui::CommandBufferClientImpl;
-  friend class ui::CommandBufferLocal;
-  friend class ui::GpuState;
-
-  // END ALLOWED USAGE.
-  // BEGIN USAGE THAT NEEDS TO BE FIXED.
-  friend class ::chromeos::BlockingMethodCaller;  // http://crbug.com/125360
-  friend class ::chromeos::system::StatisticsProviderImpl;  // http://crbug.com/125385
-  friend class chrome_browser_net::Predictor;     // http://crbug.com/78451
-  friend class
-      content::BrowserGpuChannelHostFactory;      // http://crbug.com/125248
-  friend class
-      content::BrowserGpuMemoryBufferManager;     // http://crbug.com/420368
-  friend class content::TextInputClientMac;       // http://crbug.com/121917
-  friend class dbus::Bus;                         // http://crbug.com/125222
-  friend class disk_cache::BackendImpl;           // http://crbug.com/74623
-  friend class disk_cache::InFlightIO;            // http://crbug.com/74623
-  friend class gpu::GpuChannelHost;               // http://crbug.com/125264
-  friend class net::internal::AddressTrackerLinux;  // http://crbug.com/125097
-  friend class net::NetworkChangeNotifierMac;     // http://crbug.com/125097
-  friend class ::BrowserProcessImpl;              // http://crbug.com/125207
-  friend class ::NativeBackendKWallet;            // http://crbug.com/125331
-#if !defined(OFFICIAL_BUILD)
-  friend class content::SoftwareOutputDeviceMus;  // Interim non-production code
-#endif
-  friend class views::ScreenMus;
-// END USAGE THAT NEEDS TO BE FIXED.
-
-#if DCHECK_IS_ON()
-  // DEPRECATED. Use ScopedAllowBaseSyncPrimitives.
-  static bool SetWaitAllowed(bool allowed);
-#else
-  static bool SetWaitAllowed(bool allowed) { return true; }
-#endif
-
-  // Constructing a ScopedAllowWait temporarily allows waiting on the current
-  // thread.  Doing this is almost always incorrect, which is why we limit who
-  // can use this through friend.
-  //
-  // DEPRECATED. Use ScopedAllowBaseSyncPrimitives.
-  class BASE_EXPORT ScopedAllowWait {
-   public:
-    ScopedAllowWait() EMPTY_BODY_IF_DCHECK_IS_OFF;
-    ~ScopedAllowWait() EMPTY_BODY_IF_DCHECK_IS_OFF;
-
-   private:
-#if DCHECK_IS_ON()
-    const bool was_allowed_;
-#endif
-
-    DISALLOW_COPY_AND_ASSIGN(ScopedAllowWait);
-  };
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(ThreadRestrictions);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_THREAD_RESTRICTIONS_H_
diff --git a/native/zucchini/vendor/libchrome/base/threading/thread_task_runner_handle.h b/native/zucchini/vendor/libchrome/base/threading/thread_task_runner_handle.h
deleted file mode 100644
index f6b71d7..0000000
--- a/native/zucchini/vendor/libchrome/base/threading/thread_task_runner_handle.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_THREADING_THREAD_TASK_RUNNER_HANDLE_H_
-#define BASE_THREADING_THREAD_TASK_RUNNER_HANDLE_H_
-
-#include "base/base_export.h"
-#include "base/callback_helpers.h"
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/single_thread_task_runner.h"
-
-namespace base {
-
-// ThreadTaskRunnerHandle stores a reference to a thread's TaskRunner
-// in thread-local storage.  Callers can then retrieve the TaskRunner
-// for the current thread by calling ThreadTaskRunnerHandle::Get().
-// At most one TaskRunner may be bound to each thread at a time.
-// Prefer SequencedTaskRunnerHandle to this unless thread affinity is required.
-class BASE_EXPORT ThreadTaskRunnerHandle {
- public:
-  // Gets the SingleThreadTaskRunner for the current thread.
-  static scoped_refptr<SingleThreadTaskRunner> Get();
-
-  // Returns true if the SingleThreadTaskRunner is already created for
-  // the current thread.
-  static bool IsSet();
-
-  // Overrides ThreadTaskRunnerHandle::Get()'s |task_runner_| to point at
-  // |overriding_task_runner| until the returned ScopedClosureRunner goes out of
-  // scope (instantiates a ThreadTaskRunnerHandle for that scope if |!IsSet()|).
-  // Nested overrides are allowed but callers must ensure the
-  // ScopedClosureRunners expire in LIFO (stack) order. Note: nesting
-  // ThreadTaskRunnerHandles isn't generally desired but it's useful in unit
-  // tests where multiple task runners can share the main thread for simplicity
-  // and determinism.
-  static ScopedClosureRunner OverrideForTesting(
-      scoped_refptr<SingleThreadTaskRunner> overriding_task_runner)
-      WARN_UNUSED_RESULT;
-
-  // Binds |task_runner| to the current thread. |task_runner| must belong
-  // to the current thread for this to succeed.
-  explicit ThreadTaskRunnerHandle(
-      scoped_refptr<SingleThreadTaskRunner> task_runner);
-  ~ThreadTaskRunnerHandle();
-
- private:
-  scoped_refptr<SingleThreadTaskRunner> task_runner_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThreadTaskRunnerHandle);
-};
-
-}  // namespace base
-
-#endif  // BASE_THREADING_THREAD_TASK_RUNNER_HANDLE_H_
diff --git a/native/zucchini/vendor/libchrome/base/time/time.cc b/native/zucchini/vendor/libchrome/base/time/time.cc
deleted file mode 100644
index 8529bb0..0000000
--- a/native/zucchini/vendor/libchrome/base/time/time.cc
+++ /dev/null
@@ -1,420 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/time/time.h"
-
-#include <cmath>
-#include <ios>
-#include <limits>
-#include <ostream>
-#include <sstream>
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/no_destructor.h"
-#include "base/strings/stringprintf.h"
-#include "base/third_party/nspr/prtime.h"
-#include "base/time/time_override.h"
-#include "build/build_config.h"
-
-namespace base {
-
-namespace internal {
-
-TimeNowFunction g_time_now_function = &subtle::TimeNowIgnoringOverride;
-
-TimeNowFunction g_time_now_from_system_time_function =
-    &subtle::TimeNowFromSystemTimeIgnoringOverride;
-
-TimeTicksNowFunction g_time_ticks_now_function =
-    &subtle::TimeTicksNowIgnoringOverride;
-
-ThreadTicksNowFunction g_thread_ticks_now_function =
-    &subtle::ThreadTicksNowIgnoringOverride;
-
-}  // namespace internal
-
-// TimeDelta ------------------------------------------------------------------
-
-int TimeDelta::InDays() const {
-  if (is_max()) {
-    // Preserve max to prevent overflow.
-    return std::numeric_limits<int>::max();
-  }
-  return static_cast<int>(delta_ / Time::kMicrosecondsPerDay);
-}
-
-int TimeDelta::InDaysFloored() const {
-  if (is_max()) {
-    // Preserve max to prevent overflow.
-    return std::numeric_limits<int>::max();
-  }
-  int result = delta_ / Time::kMicrosecondsPerDay;
-  int64_t remainder = delta_ - (result * Time::kMicrosecondsPerDay);
-  if (remainder < 0) {
-    --result;  // Use floor(), not trunc() rounding behavior.
-  }
-  return result;
-}
-
-int TimeDelta::InHours() const {
-  if (is_max()) {
-    // Preserve max to prevent overflow.
-    return std::numeric_limits<int>::max();
-  }
-  return static_cast<int>(delta_ / Time::kMicrosecondsPerHour);
-}
-
-int TimeDelta::InMinutes() const {
-  if (is_max()) {
-    // Preserve max to prevent overflow.
-    return std::numeric_limits<int>::max();
-  }
-  return static_cast<int>(delta_ / Time::kMicrosecondsPerMinute);
-}
-
-double TimeDelta::InSecondsF() const {
-  if (is_max()) {
-    // Preserve max to prevent overflow.
-    return std::numeric_limits<double>::infinity();
-  }
-  return static_cast<double>(delta_) / Time::kMicrosecondsPerSecond;
-}
-
-int64_t TimeDelta::InSeconds() const {
-  if (is_max()) {
-    // Preserve max to prevent overflow.
-    return std::numeric_limits<int64_t>::max();
-  }
-  return delta_ / Time::kMicrosecondsPerSecond;
-}
-
-double TimeDelta::InMillisecondsF() const {
-  if (is_max()) {
-    // Preserve max to prevent overflow.
-    return std::numeric_limits<double>::infinity();
-  }
-  return static_cast<double>(delta_) / Time::kMicrosecondsPerMillisecond;
-}
-
-int64_t TimeDelta::InMilliseconds() const {
-  if (is_max()) {
-    // Preserve max to prevent overflow.
-    return std::numeric_limits<int64_t>::max();
-  }
-  return delta_ / Time::kMicrosecondsPerMillisecond;
-}
-
-int64_t TimeDelta::InMillisecondsRoundedUp() const {
-  if (is_max()) {
-    // Preserve max to prevent overflow.
-    return std::numeric_limits<int64_t>::max();
-  }
-  int64_t result = delta_ / Time::kMicrosecondsPerMillisecond;
-  int64_t remainder = delta_ - (result * Time::kMicrosecondsPerMillisecond);
-  if (remainder > 0) {
-    ++result;  // Use ceil(), not trunc() rounding behavior.
-  }
-  return result;
-}
-
-int64_t TimeDelta::InMicroseconds() const {
-  if (is_max()) {
-    // Preserve max to prevent overflow.
-    return std::numeric_limits<int64_t>::max();
-  }
-  return delta_;
-}
-
-double TimeDelta::InMicrosecondsF() const {
-  if (is_max()) {
-    // Preserve max to prevent overflow.
-    return std::numeric_limits<double>::infinity();
-  }
-  return static_cast<double>(delta_);
-}
-
-int64_t TimeDelta::InNanoseconds() const {
-  if (is_max()) {
-    // Preserve max to prevent overflow.
-    return std::numeric_limits<int64_t>::max();
-  }
-  return delta_ * Time::kNanosecondsPerMicrosecond;
-}
-
-namespace time_internal {
-
-int64_t SaturatedAdd(TimeDelta delta, int64_t value) {
-  CheckedNumeric<int64_t> rv(delta.delta_);
-  rv += value;
-  if (rv.IsValid())
-    return rv.ValueOrDie();
-  // Positive RHS overflows. Negative RHS underflows.
-  if (value < 0)
-    return std::numeric_limits<int64_t>::min();
-  return std::numeric_limits<int64_t>::max();
-}
-
-int64_t SaturatedSub(TimeDelta delta, int64_t value) {
-  CheckedNumeric<int64_t> rv(delta.delta_);
-  rv -= value;
-  if (rv.IsValid())
-    return rv.ValueOrDie();
-  // Negative RHS overflows. Positive RHS underflows.
-  if (value < 0)
-    return std::numeric_limits<int64_t>::max();
-  return std::numeric_limits<int64_t>::min();
-}
-
-}  // namespace time_internal
-
-std::ostream& operator<<(std::ostream& os, TimeDelta time_delta) {
-  return os << time_delta.InSecondsF() << " s";
-}
-
-// Time -----------------------------------------------------------------------
-
-// static
-Time Time::Now() {
-  return internal::g_time_now_function();
-}
-
-// static
-Time Time::NowFromSystemTime() {
-  // Just use g_time_now_function because it returns the system time.
-  return internal::g_time_now_from_system_time_function();
-}
-
-// static
-Time Time::FromDeltaSinceWindowsEpoch(TimeDelta delta) {
-  return Time(delta.InMicroseconds());
-}
-
-TimeDelta Time::ToDeltaSinceWindowsEpoch() const {
-  return TimeDelta::FromMicroseconds(us_);
-}
-
-// static
-Time Time::FromTimeT(time_t tt) {
-  if (tt == 0)
-    return Time();  // Preserve 0 so we can tell it doesn't exist.
-  if (tt == std::numeric_limits<time_t>::max())
-    return Max();
-  return Time(kTimeTToMicrosecondsOffset) + TimeDelta::FromSeconds(tt);
-}
-
-time_t Time::ToTimeT() const {
-  if (is_null())
-    return 0;  // Preserve 0 so we can tell it doesn't exist.
-  if (is_max()) {
-    // Preserve max without offset to prevent overflow.
-    return std::numeric_limits<time_t>::max();
-  }
-  if (std::numeric_limits<int64_t>::max() - kTimeTToMicrosecondsOffset <= us_) {
-    DLOG(WARNING) << "Overflow when converting base::Time with internal " <<
-                     "value " << us_ << " to time_t.";
-    return std::numeric_limits<time_t>::max();
-  }
-  return (us_ - kTimeTToMicrosecondsOffset) / kMicrosecondsPerSecond;
-}
-
-// static
-Time Time::FromDoubleT(double dt) {
-  if (dt == 0 || std::isnan(dt))
-    return Time();  // Preserve 0 so we can tell it doesn't exist.
-  return Time(kTimeTToMicrosecondsOffset) + TimeDelta::FromSecondsD(dt);
-}
-
-double Time::ToDoubleT() const {
-  if (is_null())
-    return 0;  // Preserve 0 so we can tell it doesn't exist.
-  if (is_max()) {
-    // Preserve max without offset to prevent overflow.
-    return std::numeric_limits<double>::infinity();
-  }
-  return (static_cast<double>(us_ - kTimeTToMicrosecondsOffset) /
-          static_cast<double>(kMicrosecondsPerSecond));
-}
-
-#if defined(OS_POSIX)
-// static
-Time Time::FromTimeSpec(const timespec& ts) {
-  return FromDoubleT(ts.tv_sec +
-                     static_cast<double>(ts.tv_nsec) /
-                         base::Time::kNanosecondsPerSecond);
-}
-#endif
-
-// static
-Time Time::FromJsTime(double ms_since_epoch) {
-  // The epoch is a valid time, so this constructor doesn't interpret
-  // 0 as the null time.
-  return Time(kTimeTToMicrosecondsOffset) +
-         TimeDelta::FromMillisecondsD(ms_since_epoch);
-}
-
-double Time::ToJsTime() const {
-  if (is_null()) {
-    // Preserve 0 so the invalid result doesn't depend on the platform.
-    return 0;
-  }
-  if (is_max()) {
-    // Preserve max without offset to prevent overflow.
-    return std::numeric_limits<double>::infinity();
-  }
-  return (static_cast<double>(us_ - kTimeTToMicrosecondsOffset) /
-          kMicrosecondsPerMillisecond);
-}
-
-Time Time::FromJavaTime(int64_t ms_since_epoch) {
-  return base::Time::UnixEpoch() +
-         base::TimeDelta::FromMilliseconds(ms_since_epoch);
-}
-
-int64_t Time::ToJavaTime() const {
-  if (is_null()) {
-    // Preserve 0 so the invalid result doesn't depend on the platform.
-    return 0;
-  }
-  if (is_max()) {
-    // Preserve max without offset to prevent overflow.
-    return std::numeric_limits<int64_t>::max();
-  }
-  return ((us_ - kTimeTToMicrosecondsOffset) /
-          kMicrosecondsPerMillisecond);
-}
-
-// static
-Time Time::UnixEpoch() {
-  Time time;
-  time.us_ = kTimeTToMicrosecondsOffset;
-  return time;
-}
-
-Time Time::LocalMidnight() const {
-  Exploded exploded;
-  LocalExplode(&exploded);
-  exploded.hour = 0;
-  exploded.minute = 0;
-  exploded.second = 0;
-  exploded.millisecond = 0;
-  Time out_time;
-  if (FromLocalExploded(exploded, &out_time))
-    return out_time;
-  // This function must not fail.
-  NOTREACHED();
-  return Time();
-}
-
-// static
-bool Time::FromStringInternal(const char* time_string,
-                              bool is_local,
-                              Time* parsed_time) {
-  DCHECK((time_string != nullptr) && (parsed_time != nullptr));
-
-  if (time_string[0] == '\0')
-    return false;
-
-  PRTime result_time = 0;
-  PRStatus result = PR_ParseTimeString(time_string,
-                                       is_local ? PR_FALSE : PR_TRUE,
-                                       &result_time);
-  if (PR_SUCCESS != result)
-    return false;
-
-  result_time += kTimeTToMicrosecondsOffset;
-  *parsed_time = Time(result_time);
-  return true;
-}
-
-// static
-bool Time::ExplodedMostlyEquals(const Exploded& lhs, const Exploded& rhs) {
-  return lhs.year == rhs.year && lhs.month == rhs.month &&
-         lhs.day_of_month == rhs.day_of_month && lhs.hour == rhs.hour &&
-         lhs.minute == rhs.minute && lhs.second == rhs.second &&
-         lhs.millisecond == rhs.millisecond;
-}
-
-std::ostream& operator<<(std::ostream& os, Time time) {
-  Time::Exploded exploded;
-  time.UTCExplode(&exploded);
-  // Use StringPrintf because iostreams formatting is painful.
-  return os << StringPrintf("%04d-%02d-%02d %02d:%02d:%02d.%03d UTC",
-                            exploded.year,
-                            exploded.month,
-                            exploded.day_of_month,
-                            exploded.hour,
-                            exploded.minute,
-                            exploded.second,
-                            exploded.millisecond);
-}
-
-// TimeTicks ------------------------------------------------------------------
-
-// static
-TimeTicks TimeTicks::Now() {
-  return internal::g_time_ticks_now_function();
-}
-
-// static
-TimeTicks TimeTicks::UnixEpoch() {
-  static const base::NoDestructor<base::TimeTicks> epoch([]() {
-    return subtle::TimeTicksNowIgnoringOverride() -
-           (subtle::TimeNowIgnoringOverride() - Time::UnixEpoch());
-  }());
-  return *epoch;
-}
-
-TimeTicks TimeTicks::SnappedToNextTick(TimeTicks tick_phase,
-                                       TimeDelta tick_interval) const {
-  // |interval_offset| is the offset from |this| to the next multiple of
-  // |tick_interval| after |tick_phase|, possibly negative if in the past.
-  TimeDelta interval_offset = (tick_phase - *this) % tick_interval;
-  // If |this| is exactly on the interval (i.e. offset==0), don't adjust.
-  // Otherwise, if |tick_phase| was in the past, adjust forward to the next
-  // tick after |this|.
-  if (!interval_offset.is_zero() && tick_phase < *this)
-    interval_offset += tick_interval;
-  return *this + interval_offset;
-}
-
-std::ostream& operator<<(std::ostream& os, TimeTicks time_ticks) {
-  // This function formats a TimeTicks object as "bogo-microseconds".
-  // The origin and granularity of the count are platform-specific, and may very
-  // from run to run. Although bogo-microseconds usually roughly correspond to
-  // real microseconds, the only real guarantee is that the number never goes
-  // down during a single run.
-  const TimeDelta as_time_delta = time_ticks - TimeTicks();
-  return os << as_time_delta.InMicroseconds() << " bogo-microseconds";
-}
-
-// ThreadTicks ----------------------------------------------------------------
-
-// static
-ThreadTicks ThreadTicks::Now() {
-  return internal::g_thread_ticks_now_function();
-}
-
-std::ostream& operator<<(std::ostream& os, ThreadTicks thread_ticks) {
-  const TimeDelta as_time_delta = thread_ticks - ThreadTicks();
-  return os << as_time_delta.InMicroseconds() << " bogo-thread-microseconds";
-}
-
-// Time::Exploded -------------------------------------------------------------
-
-inline bool is_in_range(int value, int lo, int hi) {
-  return lo <= value && value <= hi;
-}
-
-bool Time::Exploded::HasValidValues() const {
-  return is_in_range(month, 1, 12) &&
-         is_in_range(day_of_week, 0, 6) &&
-         is_in_range(day_of_month, 1, 31) &&
-         is_in_range(hour, 0, 23) &&
-         is_in_range(minute, 0, 59) &&
-         is_in_range(second, 0, 60) &&
-         is_in_range(millisecond, 0, 999);
-}
-
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/time/time.h b/native/zucchini/vendor/libchrome/base/time/time.h
deleted file mode 100644
index c7e8123..0000000
--- a/native/zucchini/vendor/libchrome/base/time/time.h
+++ /dev/null
@@ -1,993 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Time represents an absolute point in coordinated universal time (UTC),
-// internally represented as microseconds (s/1,000,000) since the Windows epoch
-// (1601-01-01 00:00:00 UTC). System-dependent clock interface routines are
-// defined in time_PLATFORM.cc. Note that values for Time may skew and jump
-// around as the operating system makes adjustments to synchronize (e.g., with
-// NTP servers). Thus, client code that uses the Time class must account for
-// this.
-//
-// TimeDelta represents a duration of time, internally represented in
-// microseconds.
-//
-// TimeTicks and ThreadTicks represent an abstract time that is most of the time
-// incrementing, for use in measuring time durations. Internally, they are
-// represented in microseconds. They cannot be converted to a human-readable
-// time, but are guaranteed not to decrease (unlike the Time class). Note that
-// TimeTicks may "stand still" (e.g., if the computer is suspended), and
-// ThreadTicks will "stand still" whenever the thread has been de-scheduled by
-// the operating system.
-//
-// All time classes are copyable, assignable, and occupy 64-bits per instance.
-// As a result, prefer passing them by value:
-//   void MyFunction(TimeDelta arg);
-// If circumstances require, you may also pass by const reference:
-//   void MyFunction(const TimeDelta& arg);  // Not preferred.
-//
-// Definitions of operator<< are provided to make these types work with
-// DCHECK_EQ() and other log macros. For human-readable formatting, see
-// "base/i18n/time_formatting.h".
-//
-// So many choices!  Which time class should you use?  Examples:
-//
-//   Time:        Interpreting the wall-clock time provided by a remote system.
-//                Detecting whether cached resources have expired. Providing the
-//                user with a display of the current date and time. Determining
-//                the amount of time between events across re-boots of the
-//                machine.
-//
-//   TimeTicks:   Tracking the amount of time a task runs. Executing delayed
-//                tasks at the right time. Computing presentation timestamps.
-//                Synchronizing audio and video using TimeTicks as a common
-//                reference clock (lip-sync). Measuring network round-trip
-//                latency.
-//
-//   ThreadTicks: Benchmarking how long the current thread has been doing actual
-//                work.
-
-#ifndef BASE_TIME_TIME_H_
-#define BASE_TIME_TIME_H_
-
-#include <stdint.h>
-#include <time.h>
-
-#include <iosfwd>
-#include <limits>
-
-#include "base/base_export.h"
-#include "base/compiler_specific.h"
-#include "base/logging.h"
-#include "base/numerics/safe_math.h"
-#include "build/build_config.h"
-
-#if defined(OS_FUCHSIA)
-#include <zircon/types.h>
-#endif
-
-#if defined(OS_MACOSX)
-#include <CoreFoundation/CoreFoundation.h>
-// Avoid Mac system header macro leak.
-#undef TYPE_BOOL
-#endif
-
-#if defined(OS_ANDROID)
-#include <jni.h>
-#endif
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-#include <unistd.h>
-#include <sys/time.h>
-#endif
-
-#if defined(OS_WIN)
-#include "base/gtest_prod_util.h"
-#include "base/win/windows_types.h"
-#endif
-
-namespace base {
-
-class PlatformThreadHandle;
-class TimeDelta;
-
-// The functions in the time_internal namespace are meant to be used only by the
-// time classes and functions.  Please use the math operators defined in the
-// time classes instead.
-namespace time_internal {
-
-// Add or subtract |value| from a TimeDelta. The int64_t argument and return
-// value are in terms of a microsecond timebase.
-BASE_EXPORT int64_t SaturatedAdd(TimeDelta delta, int64_t value);
-BASE_EXPORT int64_t SaturatedSub(TimeDelta delta, int64_t value);
-
-}  // namespace time_internal
-
-// TimeDelta ------------------------------------------------------------------
-
-class BASE_EXPORT TimeDelta {
- public:
-  constexpr TimeDelta() : delta_(0) {}
-
-  // Converts units of time to TimeDeltas.
-  static constexpr TimeDelta FromDays(int days);
-  static constexpr TimeDelta FromHours(int hours);
-  static constexpr TimeDelta FromMinutes(int minutes);
-  static constexpr TimeDelta FromSeconds(int64_t secs);
-  static constexpr TimeDelta FromMilliseconds(int64_t ms);
-  static constexpr TimeDelta FromMicroseconds(int64_t us);
-  static constexpr TimeDelta FromNanoseconds(int64_t ns);
-  static constexpr TimeDelta FromSecondsD(double secs);
-  static constexpr TimeDelta FromMillisecondsD(double ms);
-  static constexpr TimeDelta FromMicrosecondsD(double us);
-  static constexpr TimeDelta FromNanosecondsD(double ns);
-#if defined(OS_WIN)
-  static TimeDelta FromQPCValue(LONGLONG qpc_value);
-  static TimeDelta FromFileTime(FILETIME ft);
-#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
-  static TimeDelta FromTimeSpec(const timespec& ts);
-#endif
-
-  // Converts an integer value representing TimeDelta to a class. This is used
-  // when deserializing a |TimeDelta| structure, using a value known to be
-  // compatible. It is not provided as a constructor because the integer type
-  // may be unclear from the perspective of a caller.
-  //
-  // DEPRECATED - Do not use in new code. http://crbug.com/634507
-  static constexpr TimeDelta FromInternalValue(int64_t delta) {
-    return TimeDelta(delta);
-  }
-
-  // Returns the maximum time delta, which should be greater than any reasonable
-  // time delta we might compare it to. Adding or subtracting the maximum time
-  // delta to a time or another time delta has an undefined result.
-  static constexpr TimeDelta Max();
-
-  // Returns the minimum time delta, which should be less than than any
-  // reasonable time delta we might compare it to. Adding or subtracting the
-  // minimum time delta to a time or another time delta has an undefined result.
-  static constexpr TimeDelta Min();
-
-  // Returns the internal numeric value of the TimeDelta object. Please don't
-  // use this and do arithmetic on it, as it is more error prone than using the
-  // provided operators.
-  // For serializing, use FromInternalValue to reconstitute.
-  //
-  // DEPRECATED - Do not use in new code. http://crbug.com/634507
-  constexpr int64_t ToInternalValue() const { return delta_; }
-
-  // Returns the magnitude (absolute value) of this TimeDelta.
-  constexpr TimeDelta magnitude() const {
-    // Some toolchains provide an incomplete C++11 implementation and lack an
-    // int64_t overload for std::abs().  The following is a simple branchless
-    // implementation:
-    const int64_t mask = delta_ >> (sizeof(delta_) * 8 - 1);
-    return TimeDelta((delta_ + mask) ^ mask);
-  }
-
-  // Returns true if the time delta is zero.
-  constexpr bool is_zero() const { return delta_ == 0; }
-
-  // Returns true if the time delta is the maximum/minimum time delta.
-  constexpr bool is_max() const {
-    return delta_ == std::numeric_limits<int64_t>::max();
-  }
-  constexpr bool is_min() const {
-    return delta_ == std::numeric_limits<int64_t>::min();
-  }
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-  struct timespec ToTimeSpec() const;
-#endif
-
-  // Returns the time delta in some unit. The InXYZF versions return a floating
-  // point value. The InXYZ versions return a truncated value (aka rounded
-  // towards zero, std::trunc() behavior). The InXYZFloored() versions round to
-  // lesser integers (std::floor() behavior). The XYZRoundedUp() versions round
-  // up to greater integers (std::ceil() behavior).
-  int InDays() const;
-  int InDaysFloored() const;
-  int InHours() const;
-  int InMinutes() const;
-  double InSecondsF() const;
-  int64_t InSeconds() const;
-  double InMillisecondsF() const;
-  int64_t InMilliseconds() const;
-  int64_t InMillisecondsRoundedUp() const;
-  int64_t InMicroseconds() const;
-  double InMicrosecondsF() const;
-  int64_t InNanoseconds() const;
-
-  constexpr TimeDelta& operator=(const TimeDelta&) = default;
-  constexpr TimeDelta(const TimeDelta&) = default;
-
-  // Computations with other deltas. Can easily be made constexpr with C++17 but
-  // hard to do until then per limitations around
-  // __builtin_(add|sub)_overflow in safe_math_clang_gcc_impl.h :
-  // https://chromium-review.googlesource.com/c/chromium/src/+/873352#message-59594ab70827795a67e0780404adf37b4b6c2f14
-  TimeDelta operator+(TimeDelta other) const {
-    return TimeDelta(time_internal::SaturatedAdd(*this, other.delta_));
-  }
-  TimeDelta operator-(TimeDelta other) const {
-    return TimeDelta(time_internal::SaturatedSub(*this, other.delta_));
-  }
-
-  TimeDelta& operator+=(TimeDelta other) {
-    return *this = (*this + other);
-  }
-  TimeDelta& operator-=(TimeDelta other) {
-    return *this = (*this - other);
-  }
-  constexpr TimeDelta operator-() const { return TimeDelta(-delta_); }
-
-  // Computations with numeric types. operator*() isn't constexpr because of a
-  // limitation around __builtin_mul_overflow (but operator/(1.0/a) works for
-  // |a|'s of "reasonable" size -- i.e. that don't risk overflow).
-  template <typename T>
-  TimeDelta operator*(T a) const {
-    CheckedNumeric<int64_t> rv(delta_);
-    rv *= a;
-    if (rv.IsValid())
-      return TimeDelta(rv.ValueOrDie());
-    // Matched sign overflows. Mismatched sign underflows.
-    if ((delta_ < 0) ^ (a < 0))
-      return TimeDelta(std::numeric_limits<int64_t>::min());
-    return TimeDelta(std::numeric_limits<int64_t>::max());
-  }
-  template <typename T>
-  constexpr TimeDelta operator/(T a) const {
-    CheckedNumeric<int64_t> rv(delta_);
-    rv /= a;
-    if (rv.IsValid())
-      return TimeDelta(rv.ValueOrDie());
-    // Matched sign overflows. Mismatched sign underflows.
-    // Special case to catch divide by zero.
-    if ((delta_ < 0) ^ (a <= 0))
-      return TimeDelta(std::numeric_limits<int64_t>::min());
-    return TimeDelta(std::numeric_limits<int64_t>::max());
-  }
-  template <typename T>
-  TimeDelta& operator*=(T a) {
-    return *this = (*this * a);
-  }
-  template <typename T>
-  constexpr TimeDelta& operator/=(T a) {
-    return *this = (*this / a);
-  }
-
-  constexpr int64_t operator/(TimeDelta a) const { return delta_ / a.delta_; }
-  constexpr TimeDelta operator%(TimeDelta a) const {
-    return TimeDelta(delta_ % a.delta_);
-  }
-
-  // Comparison operators.
-  constexpr bool operator==(TimeDelta other) const {
-    return delta_ == other.delta_;
-  }
-  constexpr bool operator!=(TimeDelta other) const {
-    return delta_ != other.delta_;
-  }
-  constexpr bool operator<(TimeDelta other) const {
-    return delta_ < other.delta_;
-  }
-  constexpr bool operator<=(TimeDelta other) const {
-    return delta_ <= other.delta_;
-  }
-  constexpr bool operator>(TimeDelta other) const {
-    return delta_ > other.delta_;
-  }
-  constexpr bool operator>=(TimeDelta other) const {
-    return delta_ >= other.delta_;
-  }
-
-#if defined(OS_WIN)
-  // This works around crbug.com/635974
-  constexpr TimeDelta(const TimeDelta& other) : delta_(other.delta_) {}
-#endif
-
- private:
-  friend int64_t time_internal::SaturatedAdd(TimeDelta delta, int64_t value);
-  friend int64_t time_internal::SaturatedSub(TimeDelta delta, int64_t value);
-
-  // Constructs a delta given the duration in microseconds. This is private
-  // to avoid confusion by callers with an integer constructor. Use
-  // FromSeconds, FromMilliseconds, etc. instead.
-  constexpr explicit TimeDelta(int64_t delta_us) : delta_(delta_us) {}
-
-  // Private method to build a delta from a double.
-  static constexpr TimeDelta FromDouble(double value);
-
-  // Private method to build a delta from the product of a user-provided value
-  // and a known-positive value.
-  static constexpr TimeDelta FromProduct(int64_t value, int64_t positive_value);
-
-  // Delta in microseconds.
-  int64_t delta_;
-};
-
-template <typename T>
-TimeDelta operator*(T a, TimeDelta td) {
-  return td * a;
-}
-
-// For logging use only.
-BASE_EXPORT std::ostream& operator<<(std::ostream& os, TimeDelta time_delta);
-
-// Do not reference the time_internal::TimeBase template class directly.  Please
-// use one of the time subclasses instead, and only reference the public
-// TimeBase members via those classes.
-namespace time_internal {
-
-// TimeBase--------------------------------------------------------------------
-
-// Provides value storage and comparison/math operations common to all time
-// classes. Each subclass provides for strong type-checking to ensure
-// semantically meaningful comparison/math of time values from the same clock
-// source or timeline.
-template<class TimeClass>
-class TimeBase {
- public:
-  static const int64_t kHoursPerDay = 24;
-  static const int64_t kMillisecondsPerSecond = 1000;
-  static const int64_t kMillisecondsPerDay =
-      kMillisecondsPerSecond * 60 * 60 * kHoursPerDay;
-  static const int64_t kMicrosecondsPerMillisecond = 1000;
-  static const int64_t kMicrosecondsPerSecond =
-      kMicrosecondsPerMillisecond * kMillisecondsPerSecond;
-  static const int64_t kMicrosecondsPerMinute = kMicrosecondsPerSecond * 60;
-  static const int64_t kMicrosecondsPerHour = kMicrosecondsPerMinute * 60;
-  static const int64_t kMicrosecondsPerDay =
-      kMicrosecondsPerHour * kHoursPerDay;
-  static const int64_t kMicrosecondsPerWeek = kMicrosecondsPerDay * 7;
-  static const int64_t kNanosecondsPerMicrosecond = 1000;
-  static const int64_t kNanosecondsPerSecond =
-      kNanosecondsPerMicrosecond * kMicrosecondsPerSecond;
-
-  // Returns true if this object has not been initialized.
-  //
-  // Warning: Be careful when writing code that performs math on time values,
-  // since it's possible to produce a valid "zero" result that should not be
-  // interpreted as a "null" value.
-  bool is_null() const {
-    return us_ == 0;
-  }
-
-  // Returns true if this object represents the maximum/minimum time.
-  bool is_max() const { return us_ == std::numeric_limits<int64_t>::max(); }
-  bool is_min() const { return us_ == std::numeric_limits<int64_t>::min(); }
-
-  // Returns the maximum/minimum times, which should be greater/less than than
-  // any reasonable time with which we might compare it.
-  static TimeClass Max() {
-    return TimeClass(std::numeric_limits<int64_t>::max());
-  }
-
-  static TimeClass Min() {
-    return TimeClass(std::numeric_limits<int64_t>::min());
-  }
-
-  // For serializing only. Use FromInternalValue() to reconstitute. Please don't
-  // use this and do arithmetic on it, as it is more error prone than using the
-  // provided operators.
-  //
-  // DEPRECATED - Do not use in new code. For serializing Time values, prefer
-  // Time::ToDeltaSinceWindowsEpoch().InMicroseconds(). http://crbug.com/634507
-  int64_t ToInternalValue() const { return us_; }
-
-  // The amount of time since the origin (or "zero") point. This is a syntactic
-  // convenience to aid in code readability, mainly for debugging/testing use
-  // cases.
-  //
-  // Warning: While the Time subclass has a fixed origin point, the origin for
-  // the other subclasses can vary each time the application is restarted.
-  TimeDelta since_origin() const { return TimeDelta::FromMicroseconds(us_); }
-
-  TimeClass& operator=(TimeClass other) {
-    us_ = other.us_;
-    return *(static_cast<TimeClass*>(this));
-  }
-
-  // Compute the difference between two times.
-  TimeDelta operator-(TimeClass other) const {
-    return TimeDelta::FromMicroseconds(us_ - other.us_);
-  }
-
-  // Return a new time modified by some delta.
-  TimeClass operator+(TimeDelta delta) const {
-    return TimeClass(time_internal::SaturatedAdd(delta, us_));
-  }
-  TimeClass operator-(TimeDelta delta) const {
-    return TimeClass(-time_internal::SaturatedSub(delta, us_));
-  }
-
-  // Modify by some time delta.
-  TimeClass& operator+=(TimeDelta delta) {
-    return static_cast<TimeClass&>(*this = (*this + delta));
-  }
-  TimeClass& operator-=(TimeDelta delta) {
-    return static_cast<TimeClass&>(*this = (*this - delta));
-  }
-
-  // Comparison operators
-  bool operator==(TimeClass other) const {
-    return us_ == other.us_;
-  }
-  bool operator!=(TimeClass other) const {
-    return us_ != other.us_;
-  }
-  bool operator<(TimeClass other) const {
-    return us_ < other.us_;
-  }
-  bool operator<=(TimeClass other) const {
-    return us_ <= other.us_;
-  }
-  bool operator>(TimeClass other) const {
-    return us_ > other.us_;
-  }
-  bool operator>=(TimeClass other) const {
-    return us_ >= other.us_;
-  }
-
- protected:
-  constexpr explicit TimeBase(int64_t us) : us_(us) {}
-
-  // Time value in a microsecond timebase.
-  int64_t us_;
-};
-
-}  // namespace time_internal
-
-template<class TimeClass>
-inline TimeClass operator+(TimeDelta delta, TimeClass t) {
-  return t + delta;
-}
-
-// Time -----------------------------------------------------------------------
-
-// Represents a wall clock time in UTC. Values are not guaranteed to be
-// monotonically non-decreasing and are subject to large amounts of skew.
-class BASE_EXPORT Time : public time_internal::TimeBase<Time> {
- public:
-  // Offset of UNIX epoch (1970-01-01 00:00:00 UTC) from Windows FILETIME epoch
-  // (1601-01-01 00:00:00 UTC), in microseconds. This value is derived from the
-  // following: ((1970-1601)*365+89)*24*60*60*1000*1000, where 89 is the number
-  // of leap year days between 1601 and 1970: (1970-1601)/4 excluding 1700,
-  // 1800, and 1900.
-  static constexpr int64_t kTimeTToMicrosecondsOffset =
-      INT64_C(11644473600000000);
-
-#if defined(OS_WIN)
-  // To avoid overflow in QPC to Microseconds calculations, since we multiply
-  // by kMicrosecondsPerSecond, then the QPC value should not exceed
-  // (2^63 - 1) / 1E6. If it exceeds that threshold, we divide then multiply.
-  static constexpr int64_t kQPCOverflowThreshold = INT64_C(0x8637BD05AF7);
-#endif
-
-// kExplodedMinYear and kExplodedMaxYear define the platform-specific limits
-// for values passed to FromUTCExploded() and FromLocalExploded(). Those
-// functions will return false if passed values outside these limits. The limits
-// are inclusive, meaning that the API should support all dates within a given
-// limit year.
-#if defined(OS_WIN)
-  static constexpr int kExplodedMinYear = 1601;
-  static constexpr int kExplodedMaxYear = 30827;
-#elif defined(OS_IOS)
-  static constexpr int kExplodedMinYear = std::numeric_limits<int>::min();
-  static constexpr int kExplodedMaxYear = std::numeric_limits<int>::max();
-#elif defined(OS_MACOSX)
-  static constexpr int kExplodedMinYear = 1902;
-  static constexpr int kExplodedMaxYear = std::numeric_limits<int>::max();
-#elif defined(OS_ANDROID)
-  // Though we use 64-bit time APIs on both 32 and 64 bit Android, some OS
-  // versions like KitKat (ARM but not x86 emulator) can't handle some early
-  // dates (e.g. before 1170). So we set min conservatively here.
-  static constexpr int kExplodedMinYear = 1902;
-  static constexpr int kExplodedMaxYear = std::numeric_limits<int>::max();
-#else
-  static constexpr int kExplodedMinYear =
-      (sizeof(time_t) == 4 ? 1902 : std::numeric_limits<int>::min());
-  static constexpr int kExplodedMaxYear =
-      (sizeof(time_t) == 4 ? 2037 : std::numeric_limits<int>::max());
-#endif
-
-  // Represents an exploded time that can be formatted nicely. This is kind of
-  // like the Win32 SYSTEMTIME structure or the Unix "struct tm" with a few
-  // additions and changes to prevent errors.
-  struct BASE_EXPORT Exploded {
-    int year;          // Four digit year "2007"
-    int month;         // 1-based month (values 1 = January, etc.)
-    int day_of_week;   // 0-based day of week (0 = Sunday, etc.)
-    int day_of_month;  // 1-based day of month (1-31)
-    int hour;          // Hour within the current day (0-23)
-    int minute;        // Minute within the current hour (0-59)
-    int second;        // Second within the current minute (0-59 plus leap
-                       //   seconds which may take it up to 60).
-    int millisecond;   // Milliseconds within the current second (0-999)
-
-    // A cursory test for whether the data members are within their
-    // respective ranges. A 'true' return value does not guarantee the
-    // Exploded value can be successfully converted to a Time value.
-    bool HasValidValues() const;
-  };
-
-  // Contains the NULL time. Use Time::Now() to get the current time.
-  constexpr Time() : TimeBase(0) {}
-
-  // Returns the time for epoch in Unix-like system (Jan 1, 1970).
-  static Time UnixEpoch();
-
-  // Returns the current time. Watch out, the system might adjust its clock
-  // in which case time will actually go backwards. We don't guarantee that
-  // times are increasing, or that two calls to Now() won't be the same.
-  static Time Now();
-
-  // Returns the current time. Same as Now() except that this function always
-  // uses system time so that there are no discrepancies between the returned
-  // time and system time even on virtual environments including our test bot.
-  // For timing sensitive unittests, this function should be used.
-  static Time NowFromSystemTime();
-
-  // Converts to/from TimeDeltas relative to the Windows epoch (1601-01-01
-  // 00:00:00 UTC). Prefer these methods for opaque serialization and
-  // deserialization of time values, e.g.
-  //
-  //   // Serialization:
-  //   base::Time last_updated = ...;
-  //   SaveToDatabase(last_updated.ToDeltaSinceWindowsEpoch().InMicroseconds());
-  //
-  //   // Deserialization:
-  //   base::Time last_updated = base::Time::FromDeltaSinceWindowsEpoch(
-  //       base::TimeDelta::FromMicroseconds(LoadFromDatabase()));
-  static Time FromDeltaSinceWindowsEpoch(TimeDelta delta);
-  TimeDelta ToDeltaSinceWindowsEpoch() const;
-
-  // Converts to/from time_t in UTC and a Time class.
-  static Time FromTimeT(time_t tt);
-  time_t ToTimeT() const;
-
-  // Converts time to/from a double which is the number of seconds since epoch
-  // (Jan 1, 1970).  Webkit uses this format to represent time.
-  // Because WebKit initializes double time value to 0 to indicate "not
-  // initialized", we map it to empty Time object that also means "not
-  // initialized".
-  static Time FromDoubleT(double dt);
-  double ToDoubleT() const;
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-  // Converts the timespec structure to time. MacOS X 10.8.3 (and tentatively,
-  // earlier versions) will have the |ts|'s tv_nsec component zeroed out,
-  // having a 1 second resolution, which agrees with
-  // https://developer.apple.com/legacy/library/#technotes/tn/tn1150.html#HFSPlusDates.
-  static Time FromTimeSpec(const timespec& ts);
-#endif
-
-  // Converts to/from the Javascript convention for times, a number of
-  // milliseconds since the epoch:
-  // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Date/getTime.
-  static Time FromJsTime(double ms_since_epoch);
-  double ToJsTime() const;
-
-  // Converts to/from Java convention for times, a number of milliseconds since
-  // the epoch. Because the Java format has less resolution, converting to Java
-  // time is a lossy operation.
-  static Time FromJavaTime(int64_t ms_since_epoch);
-  int64_t ToJavaTime() const;
-
-#if defined(OS_POSIX) || defined(OS_FUCHSIA)
-  static Time FromTimeVal(struct timeval t);
-  struct timeval ToTimeVal() const;
-#endif
-
-#if defined(OS_MACOSX)
-  static Time FromCFAbsoluteTime(CFAbsoluteTime t);
-  CFAbsoluteTime ToCFAbsoluteTime() const;
-#endif
-
-#if defined(OS_WIN)
-  static Time FromFileTime(FILETIME ft);
-  FILETIME ToFileTime() const;
-
-  // The minimum time of a low resolution timer.  This is basically a windows
-  // constant of ~15.6ms.  While it does vary on some older OS versions, we'll
-  // treat it as static across all windows versions.
-  static const int kMinLowResolutionThresholdMs = 16;
-
-  // Enable or disable Windows high resolution timer.
-  static void EnableHighResolutionTimer(bool enable);
-
-  // Activates or deactivates the high resolution timer based on the |activate|
-  // flag.  If the HighResolutionTimer is not Enabled (see
-  // EnableHighResolutionTimer), this function will return false.  Otherwise
-  // returns true.  Each successful activate call must be paired with a
-  // subsequent deactivate call.
-  // All callers to activate the high resolution timer must eventually call
-  // this function to deactivate the high resolution timer.
-  static bool ActivateHighResolutionTimer(bool activate);
-
-  // Returns true if the high resolution timer is both enabled and activated.
-  // This is provided for testing only, and is not tracked in a thread-safe
-  // way.
-  static bool IsHighResolutionTimerInUse();
-
-  // The following two functions are used to report the fraction of elapsed time
-  // that the high resolution timer is activated.
-  // ResetHighResolutionTimerUsage() resets the cumulative usage and starts the
-  // measurement interval and GetHighResolutionTimerUsage() returns the
-  // percentage of time since the reset that the high resolution timer was
-  // activated.
-  // ResetHighResolutionTimerUsage() must be called at least once before calling
-  // GetHighResolutionTimerUsage(); otherwise the usage result would be
-  // undefined.
-  static void ResetHighResolutionTimerUsage();
-  static double GetHighResolutionTimerUsage();
-#endif  // defined(OS_WIN)
-
-  // Converts an exploded structure representing either the local time or UTC
-  // into a Time class. Returns false on a failure when, for example, a day of
-  // month is set to 31 on a 28-30 day month. Returns Time(0) on overflow.
-  static bool FromUTCExploded(const Exploded& exploded,
-                              Time* time) WARN_UNUSED_RESULT {
-    return FromExploded(false, exploded, time);
-  }
-  static bool FromLocalExploded(const Exploded& exploded,
-                                Time* time) WARN_UNUSED_RESULT {
-    return FromExploded(true, exploded, time);
-  }
-
-  // Converts a string representation of time to a Time object.
-  // An example of a time string which is converted is as below:-
-  // "Tue, 15 Nov 1994 12:45:26 GMT". If the timezone is not specified
-  // in the input string, FromString assumes local time and FromUTCString
-  // assumes UTC. A timezone that cannot be parsed (e.g. "UTC" which is not
-  // specified in RFC822) is treated as if the timezone is not specified.
-  // TODO(iyengar) Move the FromString/FromTimeT/ToTimeT/FromFileTime to
-  // a new time converter class.
-  static bool FromString(const char* time_string,
-                         Time* parsed_time) WARN_UNUSED_RESULT {
-    return FromStringInternal(time_string, true, parsed_time);
-  }
-  static bool FromUTCString(const char* time_string,
-                            Time* parsed_time) WARN_UNUSED_RESULT {
-    return FromStringInternal(time_string, false, parsed_time);
-  }
-
-  // Fills the given exploded structure with either the local time or UTC from
-  // this time structure (containing UTC).
-  void UTCExplode(Exploded* exploded) const {
-    return Explode(false, exploded);
-  }
-  void LocalExplode(Exploded* exploded) const {
-    return Explode(true, exploded);
-  }
-
-  // Rounds this time down to the nearest day in local time. It will represent
-  // midnight on that day.
-  Time LocalMidnight() const;
-
-  // Converts an integer value representing Time to a class. This may be used
-  // when deserializing a |Time| structure, using a value known to be
-  // compatible. It is not provided as a constructor because the integer type
-  // may be unclear from the perspective of a caller.
-  //
-  // DEPRECATED - Do not use in new code. For deserializing Time values, prefer
-  // Time::FromDeltaSinceWindowsEpoch(). http://crbug.com/634507
-  static constexpr Time FromInternalValue(int64_t us) { return Time(us); }
-
- private:
-  friend class time_internal::TimeBase<Time>;
-
-  constexpr explicit Time(int64_t us) : TimeBase(us) {}
-
-  // Explodes the given time to either local time |is_local = true| or UTC
-  // |is_local = false|.
-  void Explode(bool is_local, Exploded* exploded) const;
-
-  // Unexplodes a given time assuming the source is either local time
-  // |is_local = true| or UTC |is_local = false|. Function returns false on
-  // failure and sets |time| to Time(0). Otherwise returns true and sets |time|
-  // to non-exploded time.
-  static bool FromExploded(bool is_local,
-                           const Exploded& exploded,
-                           Time* time) WARN_UNUSED_RESULT;
-
-  // Converts a string representation of time to a Time object.
-  // An example of a time string which is converted is as below:-
-  // "Tue, 15 Nov 1994 12:45:26 GMT". If the timezone is not specified
-  // in the input string, local time |is_local = true| or
-  // UTC |is_local = false| is assumed. A timezone that cannot be parsed
-  // (e.g. "UTC" which is not specified in RFC822) is treated as if the
-  // timezone is not specified.
-  static bool FromStringInternal(const char* time_string,
-                                 bool is_local,
-                                 Time* parsed_time) WARN_UNUSED_RESULT;
-
-  // Comparison does not consider |day_of_week| when doing the operation.
-  static bool ExplodedMostlyEquals(const Exploded& lhs,
-                                   const Exploded& rhs) WARN_UNUSED_RESULT;
-};
-
-// static
-constexpr TimeDelta TimeDelta::FromDays(int days) {
-  return days == std::numeric_limits<int>::max()
-             ? Max()
-             : TimeDelta(days * Time::kMicrosecondsPerDay);
-}
-
-// static
-constexpr TimeDelta TimeDelta::FromHours(int hours) {
-  return hours == std::numeric_limits<int>::max()
-             ? Max()
-             : TimeDelta(hours * Time::kMicrosecondsPerHour);
-}
-
-// static
-constexpr TimeDelta TimeDelta::FromMinutes(int minutes) {
-  return minutes == std::numeric_limits<int>::max()
-             ? Max()
-             : TimeDelta(minutes * Time::kMicrosecondsPerMinute);
-}
-
-// static
-constexpr TimeDelta TimeDelta::FromSeconds(int64_t secs) {
-  return FromProduct(secs, Time::kMicrosecondsPerSecond);
-}
-
-// static
-constexpr TimeDelta TimeDelta::FromMilliseconds(int64_t ms) {
-  return FromProduct(ms, Time::kMicrosecondsPerMillisecond);
-}
-
-// static
-constexpr TimeDelta TimeDelta::FromMicroseconds(int64_t us) {
-  return TimeDelta(us);
-}
-
-// static
-constexpr TimeDelta TimeDelta::FromNanoseconds(int64_t ns) {
-  return TimeDelta(ns / Time::kNanosecondsPerMicrosecond);
-}
-
-// static
-constexpr TimeDelta TimeDelta::FromSecondsD(double secs) {
-  return FromDouble(secs * Time::kMicrosecondsPerSecond);
-}
-
-// static
-constexpr TimeDelta TimeDelta::FromMillisecondsD(double ms) {
-  return FromDouble(ms * Time::kMicrosecondsPerMillisecond);
-}
-
-// static
-constexpr TimeDelta TimeDelta::FromMicrosecondsD(double us) {
-  return FromDouble(us);
-}
-
-// static
-constexpr TimeDelta TimeDelta::FromNanosecondsD(double ns) {
-  return FromDouble(ns / Time::kNanosecondsPerMicrosecond);
-}
-
-// static
-constexpr TimeDelta TimeDelta::Max() {
-  return TimeDelta(std::numeric_limits<int64_t>::max());
-}
-
-// static
-constexpr TimeDelta TimeDelta::Min() {
-  return TimeDelta(std::numeric_limits<int64_t>::min());
-}
-
-// static
-constexpr TimeDelta TimeDelta::FromDouble(double value) {
-  return TimeDelta(saturated_cast<int64_t>(value));
-}
-
-// static
-constexpr TimeDelta TimeDelta::FromProduct(int64_t value,
-                                           int64_t positive_value) {
-  DCHECK(positive_value > 0);
-  return value > std::numeric_limits<int64_t>::max() / positive_value
-             ? Max()
-             : value < std::numeric_limits<int64_t>::min() / positive_value
-                   ? Min()
-                   : TimeDelta(value * positive_value);
-}
-
-// For logging use only.
-BASE_EXPORT std::ostream& operator<<(std::ostream& os, Time time);
-
-// TimeTicks ------------------------------------------------------------------
-
-// Represents monotonically non-decreasing clock time.
-class BASE_EXPORT TimeTicks : public time_internal::TimeBase<TimeTicks> {
- public:
-  // The underlying clock used to generate new TimeTicks.
-  enum class Clock {
-    FUCHSIA_ZX_CLOCK_MONOTONIC,
-    LINUX_CLOCK_MONOTONIC,
-    IOS_CF_ABSOLUTE_TIME_MINUS_KERN_BOOTTIME,
-    MAC_MACH_ABSOLUTE_TIME,
-    WIN_QPC,
-    WIN_ROLLOVER_PROTECTED_TIME_GET_TIME
-  };
-
-  constexpr TimeTicks() : TimeBase(0) {}
-
-  // Platform-dependent tick count representing "right now." When
-  // IsHighResolution() returns false, the resolution of the clock could be
-  // as coarse as ~15.6ms. Otherwise, the resolution should be no worse than one
-  // microsecond.
-  static TimeTicks Now();
-
-  // Returns true if the high resolution clock is working on this system and
-  // Now() will return high resolution values. Note that, on systems where the
-  // high resolution clock works but is deemed inefficient, the low resolution
-  // clock will be used instead.
-  static bool IsHighResolution() WARN_UNUSED_RESULT;
-
-  // Returns true if TimeTicks is consistent across processes, meaning that
-  // timestamps taken on different processes can be safely compared with one
-  // another. (Note that, even on platforms where this returns true, time values
-  // from different threads that are within one tick of each other must be
-  // considered to have an ambiguous ordering.)
-  static bool IsConsistentAcrossProcesses() WARN_UNUSED_RESULT;
-
-#if defined(OS_FUCHSIA)
-  // Converts between TimeTicks and an ZX_CLOCK_MONOTONIC zx_time_t value.
-  static TimeTicks FromZxTime(zx_time_t nanos_since_boot);
-  zx_time_t ToZxTime() const;
-#endif
-
-#if defined(OS_WIN)
-  // Translates an absolute QPC timestamp into a TimeTicks value. The returned
-  // value has the same origin as Now(). Do NOT attempt to use this if
-  // IsHighResolution() returns false.
-  static TimeTicks FromQPCValue(LONGLONG qpc_value);
-#endif
-
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  static TimeTicks FromMachAbsoluteTime(uint64_t mach_absolute_time);
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
-
-#if defined(OS_ANDROID)
-  // Converts to TimeTicks the value obtained from SystemClock.uptimeMillis().
-  // Note: this convertion may be non-monotonic in relation to previously
-  // obtained TimeTicks::Now() values because of the truncation (to
-  // milliseconds) performed by uptimeMillis().
-  static TimeTicks FromUptimeMillis(jlong uptime_millis_value);
-#endif
-
-  // Get an estimate of the TimeTick value at the time of the UnixEpoch. Because
-  // Time and TimeTicks respond differently to user-set time and NTP
-  // adjustments, this number is only an estimate. Nevertheless, this can be
-  // useful when you need to relate the value of TimeTicks to a real time and
-  // date. Note: Upon first invocation, this function takes a snapshot of the
-  // realtime clock to establish a reference point.  This function will return
-  // the same value for the duration of the application, but will be different
-  // in future application runs.
-  static TimeTicks UnixEpoch();
-
-  // Returns |this| snapped to the next tick, given a |tick_phase| and
-  // repeating |tick_interval| in both directions. |this| may be before,
-  // after, or equal to the |tick_phase|.
-  TimeTicks SnappedToNextTick(TimeTicks tick_phase,
-                              TimeDelta tick_interval) const;
-
-  // Returns an enum indicating the underlying clock being used to generate
-  // TimeTicks timestamps. This function should only be used for debugging and
-  // logging purposes.
-  static Clock GetClock();
-
-  // Converts an integer value representing TimeTicks to a class. This may be
-  // used when deserializing a |TimeTicks| structure, using a value known to be
-  // compatible. It is not provided as a constructor because the integer type
-  // may be unclear from the perspective of a caller.
-  //
-  // DEPRECATED - Do not use in new code. For deserializing TimeTicks values,
-  // prefer TimeTicks + TimeDelta(). http://crbug.com/634507
-  static constexpr TimeTicks FromInternalValue(int64_t us) {
-    return TimeTicks(us);
-  }
-
-#if defined(OS_WIN)
- protected:
-  typedef DWORD (*TickFunctionType)(void);
-  static TickFunctionType SetMockTickFunction(TickFunctionType ticker);
-#endif
-
- private:
-  friend class time_internal::TimeBase<TimeTicks>;
-
-  // Please use Now() to create a new object. This is for internal use
-  // and testing.
-  constexpr explicit TimeTicks(int64_t us) : TimeBase(us) {}
-};
-
-// For logging use only.
-BASE_EXPORT std::ostream& operator<<(std::ostream& os, TimeTicks time_ticks);
-
-// ThreadTicks ----------------------------------------------------------------
-
-// Represents a clock, specific to a particular thread, than runs only while the
-// thread is running.
-class BASE_EXPORT ThreadTicks : public time_internal::TimeBase<ThreadTicks> {
- public:
-  ThreadTicks() : TimeBase(0) {
-  }
-
-  // Returns true if ThreadTicks::Now() is supported on this system.
-  static bool IsSupported() WARN_UNUSED_RESULT {
-#if (defined(_POSIX_THREAD_CPUTIME) && (_POSIX_THREAD_CPUTIME >= 0)) || \
-    (defined(OS_MACOSX) && !defined(OS_IOS)) || defined(OS_ANDROID) ||  \
-    defined(OS_FUCHSIA)
-    return true;
-#elif defined(OS_WIN)
-    return IsSupportedWin();
-#else
-    return false;
-#endif
-  }
-
-  // Waits until the initialization is completed. Needs to be guarded with a
-  // call to IsSupported().
-  static void WaitUntilInitialized() {
-#if defined(OS_WIN)
-    WaitUntilInitializedWin();
-#endif
-  }
-
-  // Returns thread-specific CPU-time on systems that support this feature.
-  // Needs to be guarded with a call to IsSupported(). Use this timer
-  // to (approximately) measure how much time the calling thread spent doing
-  // actual work vs. being de-scheduled. May return bogus results if the thread
-  // migrates to another CPU between two calls. Returns an empty ThreadTicks
-  // object until the initialization is completed. If a clock reading is
-  // absolutely needed, call WaitUntilInitialized() before this method.
-  static ThreadTicks Now();
-
-#if defined(OS_WIN)
-  // Similar to Now() above except this returns thread-specific CPU time for an
-  // arbitrary thread. All comments for Now() method above apply apply to this
-  // method as well.
-  static ThreadTicks GetForThread(const PlatformThreadHandle& thread_handle);
-#endif
-
-  // Converts an integer value representing ThreadTicks to a class. This may be
-  // used when deserializing a |ThreadTicks| structure, using a value known to
-  // be compatible. It is not provided as a constructor because the integer type
-  // may be unclear from the perspective of a caller.
-  //
-  // DEPRECATED - Do not use in new code. For deserializing ThreadTicks values,
-  // prefer ThreadTicks + TimeDelta(). http://crbug.com/634507
-  static constexpr ThreadTicks FromInternalValue(int64_t us) {
-    return ThreadTicks(us);
-  }
-
- private:
-  friend class time_internal::TimeBase<ThreadTicks>;
-
-  // Please use Now() or GetForThread() to create a new object. This is for
-  // internal use and testing.
-  constexpr explicit ThreadTicks(int64_t us) : TimeBase(us) {}
-
-#if defined(OS_WIN)
-  FRIEND_TEST_ALL_PREFIXES(TimeTicks, TSCTicksPerSecond);
-
-  // Returns the frequency of the TSC in ticks per second, or 0 if it hasn't
-  // been measured yet. Needs to be guarded with a call to IsSupported().
-  // This method is declared here rather than in the anonymous namespace to
-  // allow testing.
-  static double TSCTicksPerSecond();
-
-  static bool IsSupportedWin() WARN_UNUSED_RESULT;
-  static void WaitUntilInitializedWin();
-#endif
-};
-
-// For logging use only.
-BASE_EXPORT std::ostream& operator<<(std::ostream& os, ThreadTicks time_ticks);
-
-}  // namespace base
-
-#endif  // BASE_TIME_TIME_H_
diff --git a/native/zucchini/vendor/libchrome/base/time/time_now_posix.cc b/native/zucchini/vendor/libchrome/base/time/time_now_posix.cc
deleted file mode 100644
index 5427836..0000000
--- a/native/zucchini/vendor/libchrome/base/time/time_now_posix.cc
+++ /dev/null
@@ -1,123 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/time/time.h"
-
-#include <stdint.h>
-#include <sys/time.h>
-#include <time.h>
-#if defined(OS_ANDROID) && !defined(__LP64__)
-#include <time64.h>
-#endif
-#include <unistd.h>
-
-#include "base/logging.h"
-#include "base/numerics/safe_math.h"
-#include "base/time/time_override.h"
-#include "build/build_config.h"
-
-// Ensure the Fuchsia and Mac builds do not include this module. Instead,
-// non-POSIX implementation is used for sampling the system clocks.
-#if defined(OS_FUCHSIA) || defined(OS_MACOSX)
-#error "This implementation is for POSIX platforms other than Fuchsia or Mac."
-#endif
-
-namespace {
-
-int64_t ConvertTimespecToMicros(const struct timespec& ts) {
-  // On 32-bit systems, the calculation cannot overflow int64_t.
-  // 2**32 * 1000000 + 2**64 / 1000 < 2**63
-  if (sizeof(ts.tv_sec) <= 4 && sizeof(ts.tv_nsec) <= 8) {
-    int64_t result = ts.tv_sec;
-    result *= base::Time::kMicrosecondsPerSecond;
-    result += (ts.tv_nsec / base::Time::kNanosecondsPerMicrosecond);
-    return result;
-  } else {
-    base::CheckedNumeric<int64_t> result(ts.tv_sec);
-    result *= base::Time::kMicrosecondsPerSecond;
-    result += (ts.tv_nsec / base::Time::kNanosecondsPerMicrosecond);
-    return result.ValueOrDie();
-  }
-}
-
-// Helper function to get results from clock_gettime() and convert to a
-// microsecond timebase. Minimum requirement is MONOTONIC_CLOCK to be supported
-// on the system. FreeBSD 6 has CLOCK_MONOTONIC but defines
-// _POSIX_MONOTONIC_CLOCK to -1.
-#if (defined(OS_POSIX) && defined(_POSIX_MONOTONIC_CLOCK) && \
-     _POSIX_MONOTONIC_CLOCK >= 0) ||                         \
-    defined(OS_BSD) || defined(OS_ANDROID)
-int64_t ClockNow(clockid_t clk_id) {
-  struct timespec ts;
-  CHECK(clock_gettime(clk_id, &ts) == 0);
-  return ConvertTimespecToMicros(ts);
-}
-#else  // _POSIX_MONOTONIC_CLOCK
-#error No usable tick clock function on this platform.
-#endif  // _POSIX_MONOTONIC_CLOCK
-
-}  // namespace
-
-namespace base {
-
-// Time -----------------------------------------------------------------------
-
-namespace subtle {
-Time TimeNowIgnoringOverride() {
-  struct timeval tv;
-  struct timezone tz = {0, 0};  // UTC
-  CHECK(gettimeofday(&tv, &tz) == 0);
-  // Combine seconds and microseconds in a 64-bit field containing microseconds
-  // since the epoch.  That's enough for nearly 600 centuries.  Adjust from
-  // Unix (1970) to Windows (1601) epoch.
-  return Time() + TimeDelta::FromMicroseconds(
-                      (tv.tv_sec * Time::kMicrosecondsPerSecond + tv.tv_usec) +
-                      Time::kTimeTToMicrosecondsOffset);
-}
-
-Time TimeNowFromSystemTimeIgnoringOverride() {
-  // Just use TimeNowIgnoringOverride() because it returns the system time.
-  return TimeNowIgnoringOverride();
-}
-}  // namespace subtle
-
-// TimeTicks ------------------------------------------------------------------
-
-namespace subtle {
-TimeTicks TimeTicksNowIgnoringOverride() {
-  return TimeTicks() + TimeDelta::FromMicroseconds(ClockNow(CLOCK_MONOTONIC));
-}
-}  // namespace subtle
-
-// static
-TimeTicks::Clock TimeTicks::GetClock() {
-  return Clock::LINUX_CLOCK_MONOTONIC;
-}
-
-// static
-bool TimeTicks::IsHighResolution() {
-  return true;
-}
-
-// static
-bool TimeTicks::IsConsistentAcrossProcesses() {
-  return true;
-}
-
-// ThreadTicks ----------------------------------------------------------------
-
-namespace subtle {
-ThreadTicks ThreadTicksNowIgnoringOverride() {
-#if (defined(_POSIX_THREAD_CPUTIME) && (_POSIX_THREAD_CPUTIME >= 0)) || \
-    defined(OS_ANDROID)
-  return ThreadTicks() +
-         TimeDelta::FromMicroseconds(ClockNow(CLOCK_THREAD_CPUTIME_ID));
-#else
-  NOTREACHED();
-  return ThreadTicks();
-#endif
-}
-}  // namespace subtle
-
-}  // namespace base
diff --git a/native/zucchini/vendor/libchrome/base/time/time_override.h b/native/zucchini/vendor/libchrome/base/time/time_override.h
deleted file mode 100644
index 1586a87..0000000
--- a/native/zucchini/vendor/libchrome/base/time/time_override.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TIME_TIME_OVERRIDE_H_
-#define BASE_TIME_TIME_OVERRIDE_H_
-
-#include "base/base_export.h"
-#include "base/time/time.h"
-
-namespace base {
-
-using TimeNowFunction = decltype(&Time::Now);
-using TimeTicksNowFunction = decltype(&TimeTicks::Now);
-using ThreadTicksNowFunction = decltype(&ThreadTicks::Now);
-
-// Time overrides should be used with extreme caution. Discuss with //base/time
-// OWNERS before adding a new one.
-namespace subtle {
-
-// Override the return value of Time::Now and Time::NowFromSystemTime /
-// TimeTicks::Now / ThreadTicks::Now to emulate time, e.g. for tests or to
-// modify progression of time. Note that the override should be set while
-// single-threaded and before the first call to Now() to avoid threading issues
-// and inconsistencies in returned values. Nested overrides are not allowed.
-class BASE_EXPORT ScopedTimeClockOverrides {
- public:
-  // Pass |nullptr| for any override if it shouldn't be overriden.
-  ScopedTimeClockOverrides(TimeNowFunction time_override,
-                           TimeTicksNowFunction time_ticks_override,
-                           ThreadTicksNowFunction thread_ticks_override);
-
-  // Restores the platform default Now() functions.
-  ~ScopedTimeClockOverrides();
-
- private:
-#if DCHECK_IS_ON()
-  static bool overrides_active_;
-#endif
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedTimeClockOverrides);
-};
-
-// These methods return the platform default Time::Now / TimeTicks::Now /
-// ThreadTicks::Now values even while an override is in place. These methods
-// should only be used in places where emulated time should be disregarded. For
-// example, they can be used to implement test timeouts for tests that may
-// override time.
-BASE_EXPORT Time TimeNowIgnoringOverride();
-BASE_EXPORT Time TimeNowFromSystemTimeIgnoringOverride();
-BASE_EXPORT TimeTicks TimeTicksNowIgnoringOverride();
-BASE_EXPORT ThreadTicks ThreadTicksNowIgnoringOverride();
-
-}  // namespace subtle
-
-namespace internal {
-
-// These function pointers are used by platform-independent implementations of
-// the Now() methods and ScopedTimeClockOverrides. They are set to point to the
-// respective NowIgnoringOverride functions by default, but can also be set by
-// platform-specific code to select a default implementation at runtime, thereby
-// avoiding the indirection via the NowIgnoringOverride functions. Note that the
-// pointers can be overridden and later reset to the NowIgnoringOverride
-// functions by ScopedTimeClockOverrides.
-extern TimeNowFunction g_time_now_function;
-extern TimeNowFunction g_time_now_from_system_time_function;
-extern TimeTicksNowFunction g_time_ticks_now_function;
-extern ThreadTicksNowFunction g_thread_ticks_now_function;
-
-}  // namespace internal
-
-}  // namespace base
-
-#endif  // BASE_TIME_TIME_OVERRIDE_H_
diff --git a/native/zucchini/vendor/libchrome/base/token.h b/native/zucchini/vendor/libchrome/base/token.h
deleted file mode 100644
index f12277e..0000000
--- a/native/zucchini/vendor/libchrome/base/token.h
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_TOKEN_H_
-#define BASE_TOKEN_H_
-
-#include <stdint.h>
-
-#include <iosfwd>
-#include <tuple>
-
-#include "base/base_export.h"
-#include "base/hash.h"
-
-namespace base {
-
-// A Token is a randomly chosen 128-bit integer. This class supports generation
-// from a cryptographically strong random source, or constexpr construction over
-// fixed values (e.g. to store a pre-generated constant value). Tokens are
-// similar in spirit and purpose to UUIDs, without many of the constraints and
-// expectations (such as byte layout and string representation) clasically
-// associated with UUIDs.
-class BASE_EXPORT Token {
- public:
-  // Constructs a zero Token.
-  constexpr Token() : high_(0), low_(0) {}
-
-  // Constructs a Token with |high| and |low| as its contents.
-  constexpr Token(uint64_t high, uint64_t low) : high_(high), low_(low) {}
-
-  // Constructs a new Token with random |high| and |low| values taken from a
-  // cryptographically strong random source.
-  static Token CreateRandom();
-
-  // The high and low 64 bits of this Token.
-  uint64_t high() const { return high_; }
-  uint64_t low() const { return low_; }
-
-  bool is_zero() const { return high_ == 0 && low_ == 0; }
-
-  bool operator==(const Token& other) const {
-    return high_ == other.high_ && low_ == other.low_;
-  }
-
-  bool operator!=(const Token& other) const { return !(*this == other); }
-
-  bool operator<(const Token& other) const {
-    return std::tie(high_, low_) < std::tie(other.high_, other.low_);
-  }
-
-  // Generates a string representation of this Token useful for e.g. logging.
-  std::string ToString() const;
-
- private:
-  // Note: Two uint64_t are used instead of uint8_t[16] in order to have a
-  // simpler implementation, paricularly for |ToString()|, |is_zero()|, and
-  // constexpr value construction.
-  uint64_t high_;
-  uint64_t low_;
-};
-
-// For use in std::unordered_map.
-struct TokenHash {
-  size_t operator()(const base::Token& token) const {
-    return base::HashInts64(token.high(), token.low());
-  }
-};
-
-}  // namespace base
-
-#endif  // BASE_TOKEN_H_
\ No newline at end of file
diff --git a/native/zucchini/vendor/libchrome/base/unguessable_token.h b/native/zucchini/vendor/libchrome/base/unguessable_token.h
deleted file mode 100644
index 7f7b59a..0000000
--- a/native/zucchini/vendor/libchrome/base/unguessable_token.h
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_UNGUESSABLE_TOKEN_H_
-#define BASE_UNGUESSABLE_TOKEN_H_
-
-#include <stdint.h>
-#include <string.h>
-#include <iosfwd>
-#include <tuple>
-
-#include "base/base_export.h"
-#include "base/hash.h"
-#include "base/logging.h"
-#include "base/token.h"
-
-namespace base {
-
-struct UnguessableTokenHash;
-
-// UnguessableToken is, like Token, a randomly chosen 128-bit value. Unlike
-// Token however, a new UnguessableToken must always be generated at runtime
-// from a cryptographically strong random source (or copied or serialized and
-// deserialized from another such UnguessableToken). It can be used as part of a
-// larger aggregate type, or as an ID in and of itself.
-//
-// UnguessableToken can be used to implement "Capability-Based Security".
-// In other words, UnguessableToken can be used when the resource associated
-// with the ID needs to be protected against manipulation by other untrusted
-// agents in the system, and there is no other convenient way to verify the
-// authority of the agent to do so (because the resource is part of a table
-// shared across processes, for instance). In such a scheme, knowledge of the
-// token value in and of itself is sufficient proof of authority to carry out
-// an operation against the associated resource.
-//
-// Use Create() for creating new UnguessableTokens.
-//
-// NOTE: It is illegal to send empty UnguessableTokens across processes, and
-// sending/receiving empty tokens should be treated as a security issue.
-// If there is a valid scenario for sending "no token" across processes,
-// base::Optional should be used instead of an empty token.
-class BASE_EXPORT UnguessableToken {
- public:
-  // Create a unique UnguessableToken.
-  static UnguessableToken Create();
-
-  // Returns a reference to a global null UnguessableToken. This should only be
-  // used for functions that need to return a reference to an UnguessableToken,
-  // and should not be used as a general-purpose substitute for invoking the
-  // default constructor.
-  static const UnguessableToken& Null();
-
-  // Return a UnguessableToken built from the high/low bytes provided.
-  // It should only be used in deserialization scenarios.
-  //
-  // NOTE: If the deserialized token is empty, it means that it was never
-  // initialized via Create(). This is a security issue, and should be handled.
-  static UnguessableToken Deserialize(uint64_t high, uint64_t low);
-
-  // Creates an empty UnguessableToken.
-  // Assign to it with Create() before using it.
-  constexpr UnguessableToken() = default;
-
-  // NOTE: Serializing an empty UnguessableToken is an illegal operation.
-  uint64_t GetHighForSerialization() const {
-    DCHECK(!is_empty());
-    return token_.high();
-  }
-
-  // NOTE: Serializing an empty UnguessableToken is an illegal operation.
-  uint64_t GetLowForSerialization() const {
-    DCHECK(!is_empty());
-    return token_.low();
-  }
-
-  bool is_empty() const { return token_.is_zero(); }
-
-  // Hex representation of the unguessable token.
-  std::string ToString() const { return token_.ToString(); }
-
-  explicit operator bool() const { return !is_empty(); }
-
-  bool operator<(const UnguessableToken& other) const {
-    return token_ < other.token_;
-  }
-
-  bool operator==(const UnguessableToken& other) const {
-    return token_ == other.token_;
-  }
-
-  bool operator!=(const UnguessableToken& other) const {
-    return !(*this == other);
-  }
-
- private:
-  friend struct UnguessableTokenHash;
-  explicit UnguessableToken(const Token& token);
-
-  base::Token token_;
-};
-
-BASE_EXPORT std::ostream& operator<<(std::ostream& out,
-                                     const UnguessableToken& token);
-
-// For use in std::unordered_map.
-struct UnguessableTokenHash {
-  size_t operator()(const base::UnguessableToken& token) const {
-    DCHECK(token);
-    return TokenHash()(token.token_);
-  }
-};
-
-}  // namespace base
-
-#endif  // BASE_UNGUESSABLE_TOKEN_H_
diff --git a/native/zucchini/vendor/libchrome/base/vlog.h b/native/zucchini/vendor/libchrome/base/vlog.h
deleted file mode 100644
index 2950904..0000000
--- a/native/zucchini/vendor/libchrome/base/vlog.h
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BASE_VLOG_H_
-#define BASE_VLOG_H_
-
-#include <string>
-#include <vector>
-
-#include "base/base_export.h"
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-
-namespace logging {
-
-// A helper class containing all the settings for vlogging.
-class BASE_EXPORT VlogInfo {
- public:
-  static const int kDefaultVlogLevel;
-
-  // |v_switch| gives the default maximal active V-logging level; 0 is
-  // the default.  Normally positive values are used for V-logging
-  // levels.
-  //
-  // |vmodule_switch| gives the per-module maximal V-logging levels to
-  // override the value given by |v_switch|.
-  // E.g. "my_module=2,foo*=3" would change the logging level for all
-  // code in source files "my_module.*" and "foo*.*" ("-inl" suffixes
-  // are also disregarded for this matching).
-  //
-  // |log_severity| points to an int that stores the log level. If a valid
-  // |v_switch| is provided, it will set the log level, and the default
-  // vlog severity will be read from there..
-  //
-  // Any pattern containing a forward or backward slash will be tested
-  // against the whole pathname and not just the module.  E.g.,
-  // "*/foo/bar/*=2" would change the logging level for all code in
-  // source files under a "foo/bar" directory.
-  VlogInfo(const std::string& v_switch,
-           const std::string& vmodule_switch,
-           int* min_log_level);
-  ~VlogInfo();
-
-  // Returns the vlog level for a given file (usually taken from
-  // __FILE__).
-  int GetVlogLevel(const base::StringPiece& file) const;
-
- private:
-  void SetMaxVlogLevel(int level);
-  int GetMaxVlogLevel() const;
-
-  // VmodulePattern holds all the information for each pattern parsed
-  // from |vmodule_switch|.
-  struct VmodulePattern;
-  std::vector<VmodulePattern> vmodule_levels_;
-  int* min_log_level_;
-
-  DISALLOW_COPY_AND_ASSIGN(VlogInfo);
-};
-
-// Returns true if the string passed in matches the vlog pattern.  The
-// vlog pattern string can contain wildcards like * and ?.  ? matches
-// exactly one character while * matches 0 or more characters.  Also,
-// as a special case, a / or \ character matches either / or \.
-//
-// Examples:
-//   "kh?n" matches "khan" but not "khn" or "khaan"
-//   "kh*n" matches "khn", "khan", or even "khaaaaan"
-//   "/foo\bar" matches "/foo/bar", "\foo\bar", or "/foo\bar"
-//     (disregarding C escaping rules)
-BASE_EXPORT bool MatchVlogPattern(const base::StringPiece& string,
-                                  const base::StringPiece& vlog_pattern);
-
-}  // namespace logging
-
-#endif  // BASE_VLOG_H_
diff --git a/native/zucchini/vendor/libchrome/build/build_config.h b/native/zucchini/vendor/libchrome/build/build_config.h
deleted file mode 100644
index 4dbc69d..0000000
--- a/native/zucchini/vendor/libchrome/build/build_config.h
+++ /dev/null
@@ -1,263 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This file adds defines about the platform we're currently building on.
-//  Operating System:
-//    OS_WIN / OS_MACOSX / OS_LINUX / OS_POSIX (MACOSX or LINUX) /
-//    OS_NACL (NACL_SFI or NACL_NONSFI) / OS_NACL_SFI / OS_NACL_NONSFI
-//    OS_CHROMEOS is set by the build system
-//  Compiler:
-//    COMPILER_MSVC / COMPILER_GCC
-//  Processor:
-//    ARCH_CPU_ARM64 / ARCH_CPU_ARMEL / ARCH_CPU_LOONG32 / ARCH_CPU_LOONG64 /
-//    ARCH_CPU_MIPS / ARCH_CPU_MIPS64 / ARCH_CPU_MIPS64EL / ARCH_CPU_MIPSEL /
-//    ARCH_CPU_PPC64 / ARCH_CPU_S390 / ARCH_CPU_S390X / ARCH_CPU_X86 /
-//    ARCH_CPU_X86_64 / ARCH_CPU_RISCV64
-//  Processor family:
-//    ARCH_CPU_ARM_FAMILY: ARMEL or ARM64
-//    ARCH_CPU_LOONG_FAMILY: LOONG32 or LOONG64
-//    ARCH_CPU_MIPS_FAMILY: MIPS64EL or MIPSEL or MIPS64 or MIPS
-//    ARCH_CPU_PPC64_FAMILY: PPC64
-//    ARCH_CPU_S390_FAMILY: S390 or S390X
-//    ARCH_CPU_X86_FAMILY: X86 or X86_64
-//    ARCH_CPU_RISCV_FAMILY: Riscv64
-//  Processor features:
-//    ARCH_CPU_31_BITS / ARCH_CPU_32_BITS / ARCH_CPU_64_BITS
-//    ARCH_CPU_BIG_ENDIAN / ARCH_CPU_LITTLE_ENDIAN
-
-#ifndef BUILD_BUILD_CONFIG_H_
-#define BUILD_BUILD_CONFIG_H_
-
-// A brief primer on #defines:
-//
-// - __ANDROID__ is automatically defined by the Android toolchain (see
-//   https://goo.gl/v61lXa). It's not defined when building host code.
-// - __ANDROID_HOST__ is defined via -D by Android.mk when building host code
-//   within an Android checkout.
-// - ANDROID is defined via -D when building code for either Android targets or
-//   hosts. Use __ANDROID__ and __ANDROID_HOST__ instead.
-// - OS_ANDROID is a define used to build Chrome for Android within the NDK and
-//   to build Android targets.
-
-// Android targets and hosts don't use tcmalloc.
-#if defined(__ANDROID__) || defined(__ANDROID_HOST__)
-#define NO_TCMALLOC
-#endif  // defined(__ANDROID__) || defined(__ANDROID_HOST__)
-
-#if defined(__ANDROID__)  // Android targets
-
-#define OS_ANDROID 1
-
-#elif !defined(__ANDROID_HOST__)  // Chrome OS
-
-#define OS_CHROMEOS 1
-// TODO: Remove these once the GLib MessageLoopForUI isn't being used:
-// https://crbug.com/361635
-#define USE_GLIB 1
-#define USE_OZONE 1
-
-#endif  // defined(__ANDROID__)
-
-// A set of macros to use for platform detection.
-#if defined(__native_client__)
-// __native_client__ must be first, so that other OS_ defines are not set.
-#define OS_NACL 1
-// OS_NACL comes in two sandboxing technology flavors, SFI or Non-SFI.
-// PNaCl toolchain defines __native_client_nonsfi__ macro in Non-SFI build
-// mode, while it does not in SFI build mode.
-#if defined(__native_client_nonsfi__)
-#define OS_NACL_NONSFI
-#else
-#define OS_NACL_SFI
-#endif
-#elif defined(__APPLE__)
-// only include TargetConditions after testing ANDROID as some android builds
-// on mac don't have this header available and it's not needed unless the target
-// is really mac/ios.
-#include <TargetConditionals.h>
-#define OS_MACOSX 1
-#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
-#define OS_IOS 1
-#endif  // defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
-#elif defined(__linux__)
-#define OS_LINUX 1
-// include a system header to pull in features.h for glibc/uclibc macros.
-#include <unistd.h>
-#if defined(__GLIBC__) && !defined(__UCLIBC__)
-// we really are using glibc, not uClibc pretending to be glibc
-#define LIBC_GLIBC 1
-#endif
-#elif defined(_WIN32)
-#define OS_WIN 1
-#elif defined(__Fuchsia__)
-#define OS_FUCHSIA 1
-#elif defined(__FreeBSD__)
-#define OS_FREEBSD 1
-#elif defined(__NetBSD__)
-#define OS_NETBSD 1
-#elif defined(__OpenBSD__)
-#define OS_OPENBSD 1
-#elif defined(__sun)
-#define OS_SOLARIS 1
-#elif defined(__QNXNTO__)
-#define OS_QNX 1
-#elif defined(_AIX)
-#define OS_AIX 1
-#elif defined(__asmjs__)
-#define OS_ASMJS
-#else
-#error Please add support for your platform in build/build_config.h
-#endif
-// NOTE: Adding a new port? Please follow
-// https://chromium.googlesource.com/chromium/src/+/master/docs/new_port_policy.md
-
-// For access to standard BSD features, use OS_BSD instead of a
-// more specific macro.
-#if defined(OS_FREEBSD) || defined(OS_NETBSD) || defined(OS_OPENBSD)
-#define OS_BSD 1
-#endif
-
-// For access to standard POSIXish features, use OS_POSIX instead of a
-// more specific macro.
-#if defined(OS_AIX) || defined(OS_ANDROID) || defined(OS_ASMJS) ||    \
-    defined(OS_FREEBSD) || defined(OS_LINUX) || defined(OS_MACOSX) || \
-    defined(OS_NACL) || defined(OS_NETBSD) || defined(OS_OPENBSD) ||  \
-    defined(OS_QNX) || defined(OS_SOLARIS)
-#define OS_POSIX 1
-#endif
-
-// Use tcmalloc
-#if (defined(OS_WIN) || defined(OS_LINUX) || defined(OS_ANDROID)) && \
-    !defined(NO_TCMALLOC)
-#define USE_TCMALLOC 1
-#endif
-
-// Compiler detection.
-#if defined(__GNUC__)
-#define COMPILER_GCC 1
-#elif defined(_MSC_VER)
-#define COMPILER_MSVC 1
-#else
-#error Please add support for your compiler in build/build_config.h
-#endif
-
-// Processor architecture detection.  For more info on what's defined, see:
-//   http://msdn.microsoft.com/en-us/library/b0084kay.aspx
-//   http://www.agner.org/optimize/calling_conventions.pdf
-//   or with gcc, run: "echo | gcc -E -dM -"
-#if defined(_M_X64) || defined(__x86_64__)
-#define ARCH_CPU_X86_FAMILY 1
-#define ARCH_CPU_X86_64 1
-#define ARCH_CPU_64_BITS 1
-#define ARCH_CPU_LITTLE_ENDIAN 1
-#elif defined(_M_IX86) || defined(__i386__)
-#define ARCH_CPU_X86_FAMILY 1
-#define ARCH_CPU_X86 1
-#define ARCH_CPU_32_BITS 1
-#define ARCH_CPU_LITTLE_ENDIAN 1
-#elif defined(__s390x__)
-#define ARCH_CPU_S390_FAMILY 1
-#define ARCH_CPU_S390X 1
-#define ARCH_CPU_64_BITS 1
-#define ARCH_CPU_BIG_ENDIAN 1
-#elif defined(__s390__)
-#define ARCH_CPU_S390_FAMILY 1
-#define ARCH_CPU_S390 1
-#define ARCH_CPU_31_BITS 1
-#define ARCH_CPU_BIG_ENDIAN 1
-#elif (defined(__PPC64__) || defined(__PPC__)) && defined(__BIG_ENDIAN__)
-#define ARCH_CPU_PPC64_FAMILY 1
-#define ARCH_CPU_PPC64 1
-#define ARCH_CPU_64_BITS 1
-#define ARCH_CPU_BIG_ENDIAN 1
-#elif defined(__PPC64__)
-#define ARCH_CPU_PPC64_FAMILY 1
-#define ARCH_CPU_PPC64 1
-#define ARCH_CPU_64_BITS 1
-#define ARCH_CPU_LITTLE_ENDIAN 1
-#elif defined(__ARMEL__)
-#define ARCH_CPU_ARM_FAMILY 1
-#define ARCH_CPU_ARMEL 1
-#define ARCH_CPU_32_BITS 1
-#define ARCH_CPU_LITTLE_ENDIAN 1
-#elif defined(__aarch64__)
-#define ARCH_CPU_ARM_FAMILY 1
-#define ARCH_CPU_ARM64 1
-#define ARCH_CPU_64_BITS 1
-#define ARCH_CPU_LITTLE_ENDIAN 1
-#elif defined(__pnacl__) || defined(__asmjs__)
-#define ARCH_CPU_32_BITS 1
-#define ARCH_CPU_LITTLE_ENDIAN 1
-#elif defined(__MIPSEL__)
-#if defined(__LP64__)
-#define ARCH_CPU_MIPS_FAMILY 1
-#define ARCH_CPU_MIPS64EL 1
-#define ARCH_CPU_64_BITS 1
-#define ARCH_CPU_LITTLE_ENDIAN 1
-#else
-#define ARCH_CPU_MIPS_FAMILY 1
-#define ARCH_CPU_MIPSEL 1
-#define ARCH_CPU_32_BITS 1
-#define ARCH_CPU_LITTLE_ENDIAN 1
-#endif
-#elif defined(__MIPSEB__)
-#if defined(__LP64__)
-#define ARCH_CPU_MIPS_FAMILY 1
-#define ARCH_CPU_MIPS64 1
-#define ARCH_CPU_64_BITS 1
-#define ARCH_CPU_BIG_ENDIAN 1
-#else
-#define ARCH_CPU_MIPS_FAMILY 1
-#define ARCH_CPU_MIPS 1
-#define ARCH_CPU_32_BITS 1
-#define ARCH_CPU_BIG_ENDIAN 1
-#endif
-#elif defined(__loongarch32)
-#define ARCH_CPU_LOONG_FAMILY 1
-#define ARCH_CPU_LOONG32 1
-#define ARCH_CPU_32_BITS 1
-#define ARCH_CPU_LITTLE_ENDIAN 1
-#elif defined(__loongarch64)
-#define ARCH_CPU_LOONG_FAMILY 1
-#define ARCH_CPU_LOONG64 1
-#define ARCH_CPU_64_BITS 1
-#define ARCH_CPU_LITTLE_ENDIAN 1
-#elif defined(__riscv) && (__riscv_xlen == 64)
-#define ARCH_CPU_RISCV_FAMILY 1
-#define ARCH_CPU_RISCV64 1
-#define ARCH_CPU_64_BITS 1
-#define ARCH_CPU_LITTLE_ENDIAN 1
-#else
-#error Please add support for your architecture in build/build_config.h
-#endif
-
-// Type detection for wchar_t.
-#if defined(OS_WIN)
-#define WCHAR_T_IS_UTF16
-#elif defined(OS_FUCHSIA)
-#define WCHAR_T_IS_UTF32
-#elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
-    (__WCHAR_MAX__ == 0x7fffffff || __WCHAR_MAX__ == 0xffffffff)
-#define WCHAR_T_IS_UTF32
-#elif defined(OS_POSIX) && defined(COMPILER_GCC) && defined(__WCHAR_MAX__) && \
-    (__WCHAR_MAX__ == 0x7fff || __WCHAR_MAX__ == 0xffff)
-// On Posix, we'll detect short wchar_t, but projects aren't guaranteed to
-// compile in this mode (in particular, Chrome doesn't). This is intended for
-// other projects using base who manage their own dependencies and make sure
-// short wchar works for them.
-#define WCHAR_T_IS_UTF16
-#else
-#error Please add support for your compiler in build/build_config.h
-#endif
-
-#if defined(OS_ANDROID)
-// The compiler thinks std::string::const_iterator and "const char*" are
-// equivalent types.
-#define STD_STRING_ITERATOR_IS_CHAR_POINTER
-// The compiler thinks base::string16::const_iterator and "char16*" are
-// equivalent types.
-#define BASE_STRING16_ITERATOR_IS_CHAR16_POINTER
-#endif
-
-#endif  // BUILD_BUILD_CONFIG_H_
diff --git a/native/zucchini/vendor/libchrome/testing/gtest/include/gtest/gtest_prod.h b/native/zucchini/vendor/libchrome/testing/gtest/include/gtest/gtest_prod.h
deleted file mode 100644
index 00174fc..0000000
--- a/native/zucchini/vendor/libchrome/testing/gtest/include/gtest/gtest_prod.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <gtest/gtest_prod.h>
diff --git a/native/zucchini/vendor/zucchini/LICENSE b/native/zucchini/vendor/zucchini/LICENSE
deleted file mode 100644
index a32e00c..0000000
--- a/native/zucchini/vendor/zucchini/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/native/zucchini/vendor/zucchini/MODULE_LICENSE_CHROME b/native/zucchini/vendor/zucchini/MODULE_LICENSE_CHROME
deleted file mode 100644
index e69de29..0000000
diff --git a/native/zucchini/vendor/zucchini/abs32_utils.cc b/native/zucchini/vendor/zucchini/abs32_utils.cc
deleted file mode 100644
index 27e7e11..0000000
--- a/native/zucchini/vendor/zucchini/abs32_utils.cc
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/abs32_utils.h"
-
-#include <algorithm>
-#include <type_traits>
-#include <utility>
-
-#include "base/check_op.h"
-#include "components/zucchini/io_utils.h"
-
-namespace zucchini {
-
-namespace {
-
-// Templated helper for AbsoluteAddress::Read().
-template <typename T>
-bool ReadAbs(ConstBufferView image, offset_t offset, uint64_t* value) {
-  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned.");
-  if (!image.can_access<T>(offset))
-    return false;
-  *value = static_cast<uint64_t>(image.read<T>(offset));
-  return true;
-}
-
-// Templated helper for AbsoluteAddress::Write().
-template <typename T>
-bool WriteAbs(offset_t offset, T value, MutableBufferView* image) {
-  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned.");
-  if (!image->can_access<T>(offset))
-    return false;
-  image->write<T>(offset, value);
-  return true;
-}
-
-}  // namespace
-
-/******** AbsoluteAddress ********/
-
-AbsoluteAddress::AbsoluteAddress(Bitness bitness, uint64_t image_base)
-    : bitness_(bitness), image_base_(image_base), value_(image_base) {
-  CHECK(bitness_ == kBit64 || image_base_ < 0x100000000ULL);
-}
-
-AbsoluteAddress::AbsoluteAddress(AbsoluteAddress&&) = default;
-
-AbsoluteAddress::~AbsoluteAddress() = default;
-
-bool AbsoluteAddress::FromRva(rva_t rva) {
-  if (rva >= kRvaBound)
-    return false;
-  uint64_t value = image_base_ + rva;
-  // Check overflow, which manifests as |value| "wrapping around", resulting in
-  // |value| less than |image_base_| (preprocessing needed for 32-bit).
-  if (((bitness_ == kBit32) ? (value & 0xFFFFFFFFU) : value) < image_base_)
-    return false;
-  value_ = value;
-  return true;
-}
-
-rva_t AbsoluteAddress::ToRva() const {
-  if (value_ < image_base_)
-    return kInvalidRva;
-  uint64_t raw_rva = value_ - image_base_;
-  if (raw_rva >= kRvaBound)
-    return kInvalidRva;
-  return static_cast<rva_t>(raw_rva);
-}
-
-bool AbsoluteAddress::Read(offset_t offset, const ConstBufferView& image) {
-  // Read raw data; |value_| is not guaranteed to represent a valid RVA.
-  if (bitness_ == kBit32)
-    return ReadAbs<uint32_t>(image, offset, &value_);
-  DCHECK_EQ(kBit64, bitness_);
-  return ReadAbs<uint64_t>(image, offset, &value_);
-}
-
-bool AbsoluteAddress::Write(offset_t offset, MutableBufferView* image) {
-  if (bitness_ == kBit32)
-    return WriteAbs<uint32_t>(offset, static_cast<uint32_t>(value_), image);
-  DCHECK_EQ(kBit64, bitness_);
-  return WriteAbs<uint64_t>(offset, value_, image);
-}
-
-/******** Abs32RvaExtractorWin32 ********/
-
-Abs32RvaExtractorWin32::Abs32RvaExtractorWin32(
-    ConstBufferView image,
-    AbsoluteAddress&& addr,
-    const std::vector<offset_t>& abs32_locations,
-    offset_t lo,
-    offset_t hi)
-    : image_(image), addr_(std::move(addr)) {
-  CHECK_LE(lo, hi);
-  auto find_and_check = [this](const std::vector<offset_t>& locations,
-                               offset_t offset) {
-    auto it = std::lower_bound(locations.begin(), locations.end(), offset);
-    // Ensure that |offset| does not straddle a reference body.
-    CHECK(it == locations.begin() || offset - *(it - 1) >= addr_.width());
-    return it;
-  };
-  cur_abs32_ = find_and_check(abs32_locations, lo);
-  end_abs32_ = find_and_check(abs32_locations, hi);
-}
-
-Abs32RvaExtractorWin32::Abs32RvaExtractorWin32(Abs32RvaExtractorWin32&&) =
-    default;
-
-Abs32RvaExtractorWin32::~Abs32RvaExtractorWin32() = default;
-
-std::optional<Abs32RvaExtractorWin32::Unit> Abs32RvaExtractorWin32::GetNext() {
-  while (cur_abs32_ < end_abs32_) {
-    offset_t location = *(cur_abs32_++);
-    if (!addr_.Read(location, image_))
-      continue;
-    rva_t target_rva = addr_.ToRva();
-    if (target_rva == kInvalidRva)
-      continue;
-    return Unit{location, target_rva};
-  }
-  return std::nullopt;
-}
-
-/******** Abs32ReaderWin32 ********/
-
-Abs32ReaderWin32::Abs32ReaderWin32(Abs32RvaExtractorWin32&& abs32_rva_extractor,
-                                   const AddressTranslator& translator)
-    : abs32_rva_extractor_(std::move(abs32_rva_extractor)),
-      target_rva_to_offset_(translator) {}
-
-Abs32ReaderWin32::~Abs32ReaderWin32() = default;
-
-std::optional<Reference> Abs32ReaderWin32::GetNext() {
-  for (auto unit = abs32_rva_extractor_.GetNext(); unit.has_value();
-       unit = abs32_rva_extractor_.GetNext()) {
-    offset_t location = unit->location;
-    offset_t unsafe_target = target_rva_to_offset_.Convert(unit->target_rva);
-    if (unsafe_target != kInvalidOffset)
-      return Reference{location, unsafe_target};
-  }
-  return std::nullopt;
-}
-
-/******** Abs32WriterWin32 ********/
-
-Abs32WriterWin32::Abs32WriterWin32(MutableBufferView image,
-                                   AbsoluteAddress&& addr,
-                                   const AddressTranslator& translator)
-    : image_(image),
-      addr_(std::move(addr)),
-      target_offset_to_rva_(translator) {}
-
-Abs32WriterWin32::~Abs32WriterWin32() = default;
-
-void Abs32WriterWin32::PutNext(Reference ref) {
-  rva_t target_rva = target_offset_to_rva_.Convert(ref.target);
-  if (target_rva != kInvalidRva) {
-    addr_.FromRva(target_rva);
-    addr_.Write(ref.location, &image_);
-  }
-}
-
-/******** Exported Functions ********/
-
-size_t RemoveUntranslatableAbs32(ConstBufferView image,
-                                 AbsoluteAddress&& addr,
-                                 const AddressTranslator& translator,
-                                 std::vector<offset_t>* locations) {
-  AddressTranslator::RvaToOffsetCache target_rva_checker(translator);
-  Abs32RvaExtractorWin32 extractor(image, std::move(addr), *locations, 0,
-                                   image.size());
-  Abs32ReaderWin32 reader(std::move(extractor), translator);
-  std::vector<offset_t>::iterator write_it = locations->begin();
-  // |reader| reads |locations| while |write_it| modifies it. However, there's
-  // no conflict since read occurs before write, and can skip ahead.
-  for (auto ref = reader.GetNext(); ref.has_value(); ref = reader.GetNext())
-    *(write_it++) = ref->location;
-  DCHECK(write_it <= locations->end());
-  size_t num_removed = locations->end() - write_it;
-  locations->erase(write_it, locations->end());
-  return num_removed;
-}
-
-size_t RemoveOverlappingAbs32Locations(uint32_t width,
-                                       std::vector<offset_t>* locations) {
-  if (locations->size() <= 1)
-    return 0;
-
-  auto slow = locations->begin();
-  auto fast = locations->begin() + 1;
-  for (;;) {
-    // Find next good location.
-    while (fast != locations->end() && *fast - *slow < width)
-      ++fast;
-    // Advance |slow|. For the last iteration this becomes the new sentinel.
-    ++slow;
-    if (fast == locations->end())
-      break;
-    // Compactify good locations (potentially overwrite bad locations).
-    if (slow != fast)
-      *slow = *fast;
-    ++fast;
-  }
-  size_t num_removed = locations->end() - slow;
-  locations->erase(slow, locations->end());
-  return num_removed;
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/address_translator.cc b/native/zucchini/vendor/zucchini/address_translator.cc
deleted file mode 100644
index d7d7201..0000000
--- a/native/zucchini/vendor/zucchini/address_translator.cc
+++ /dev/null
@@ -1,258 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/address_translator.h"
-
-#include <algorithm>
-#include <utility>
-
-#include "base/containers/cxx20_erase.h"
-
-namespace zucchini {
-
-/******** AddressTranslator::OffsetToRvaCache ********/
-
-AddressTranslator::OffsetToRvaCache::OffsetToRvaCache(
-    const AddressTranslator& translator)
-    : translator_(translator) {}
-
-rva_t AddressTranslator::OffsetToRvaCache::Convert(offset_t offset) const {
-  if (offset >= translator_.fake_offset_begin_) {
-    // Rely on |translator_| to handle this special case.
-    return translator_.OffsetToRva(offset);
-  }
-  if (cached_unit_ && cached_unit_->CoversOffset(offset))
-    return cached_unit_->OffsetToRvaUnsafe(offset);
-  const AddressTranslator::Unit* unit = translator_.OffsetToUnit(offset);
-  if (!unit)
-    return kInvalidRva;
-  cached_unit_ = unit;
-  return unit->OffsetToRvaUnsafe(offset);
-}
-
-/******** AddressTranslator::RvaToOffsetCache ********/
-
-AddressTranslator::RvaToOffsetCache::RvaToOffsetCache(
-    const AddressTranslator& translator)
-    : translator_(translator) {}
-
-bool AddressTranslator::RvaToOffsetCache::IsValid(rva_t rva) const {
-  if (rva == kInvalidRva)
-    return false;
-  if (!cached_unit_ || !cached_unit_->CoversRva(rva)) {
-    const AddressTranslator::Unit* unit = translator_.RvaToUnit(rva);
-    if (!unit)
-      return false;
-    cached_unit_ = unit;
-  }
-  return true;
-}
-
-offset_t AddressTranslator::RvaToOffsetCache::Convert(rva_t rva) const {
-  if (!cached_unit_ || !cached_unit_->CoversRva(rva)) {
-    const AddressTranslator::Unit* unit = translator_.RvaToUnit(rva);
-    if (!unit)
-      return kInvalidOffset;
-    cached_unit_ = unit;
-  }
-  return cached_unit_->RvaToOffsetUnsafe(rva, translator_.fake_offset_begin_);
-}
-
-/******** AddressTranslator ********/
-
-AddressTranslator::AddressTranslator() = default;
-
-AddressTranslator::AddressTranslator(AddressTranslator&&) = default;
-
-AddressTranslator::~AddressTranslator() = default;
-
-AddressTranslator::Status AddressTranslator::Initialize(
-    std::vector<Unit>&& units) {
-  for (Unit& unit : units) {
-    // Check for overflows and fail if found.
-    if (!RangeIsBounded<offset_t>(unit.offset_begin, unit.offset_size,
-                                  kOffsetBound) ||
-        !RangeIsBounded<rva_t>(unit.rva_begin, unit.rva_size, kRvaBound)) {
-      return kErrorOverflow;
-    }
-    // If |rva_size < offset_size|: Just shrink |offset_size| to accommodate.
-    unit.offset_size = std::min(unit.offset_size, unit.rva_size);
-    // Now |rva_size >= offset_size|. Note that |rva_size > offset_size| is
-    // allowed; these lead to dangling RVA.
-  }
-
-  // Remove all empty units.
-  base::EraseIf(units, [](const Unit& unit) { return unit.IsEmpty(); });
-
-  // Sort |units| by RVA, then uniquefy.
-  std::sort(units.begin(), units.end(), [](const Unit& a, const Unit& b) {
-    return std::tie(a.rva_begin, a.rva_size) <
-           std::tie(b.rva_begin, b.rva_size);
-  });
-  units.erase(std::unique(units.begin(), units.end()), units.end());
-
-  // Scan for RVA range overlaps, validate, and merge wherever possible.
-  if (units.size() > 1) {
-    // Traverse with two iterators: |slow| stays behind and modifies Units that
-    // absorb all overlapping (or tangent if suitable) Units; |fast| explores
-    // new Units as candidates for consistency checks and potential merge into
-    // |slow|.
-    auto slow = units.begin();
-
-    // All |it| with |slow| < |it| < |fast| contain garbage.
-    for (auto fast = slow + 1; fast != units.end(); ++fast) {
-      // Comment notation: S = slow offset, F = fast offset, O = overlap offset,
-      // s = slow RVA, f = fast RVA, o = overlap RVA.
-      DCHECK_GE(fast->rva_begin, slow->rva_begin);
-      if (slow->rva_end() < fast->rva_begin) {
-        // ..ssssss..ffffff..: Disjoint: Can advance |slow|.
-        *(++slow) = *fast;
-        continue;
-      }
-
-      // ..ssssffff..: Tangent: Merge is optional.
-      // ..sssooofff.. / ..sssooosss..: Overlap: Merge is required.
-      bool merge_is_optional = slow->rva_end() == fast->rva_begin;
-
-      // Check whether |fast| and |slow| have identical RVA -> offset shift.
-      // If not, then merge cannot be resolved. Examples:
-      // ..ssssffff.. -> ..SSSSFFFF..: Good, can merge.
-      // ..ssssffff.. -> ..SSSS..FFFF..: Non-fatal: don't merge.
-      // ..ssssffff.. -> ..FFFF..SSSS..: Non-fatal: don't merge.
-      // ..ssssffff.. -> ..SSOOFF..: Fatal: Ignore for now (handled later).
-      // ..sssooofff.. -> ..SSSOOOFFF..: Good, can merge.
-      // ..sssooofff.. -> ..SSSSSOFFFFF..: Fatal.
-      // ..sssooofff.. -> ..FFOOOOSS..: Fatal.
-      // ..sssooofff.. -> ..SSSOOOF..: Good, notice |fast| has dangling RVAs.
-      // ..oooooo.. -> ..OOOOOO..: Good, can merge.
-      if (fast->offset_begin < slow->offset_begin ||
-          fast->offset_begin - slow->offset_begin !=
-              fast->rva_begin - slow->rva_begin) {
-        if (merge_is_optional) {
-          *(++slow) = *fast;
-          continue;
-        }
-        return kErrorBadOverlap;
-      }
-
-      // Check whether dangling RVAs (if they exist) are consistent. Examples:
-      // ..sssooofff.. -> ..SSSOOOF..: Good, can merge.
-      // ..sssooosss.. -> ..SSSOOOS..: Good, can merge.
-      // ..sssooofff.. -> ..SSSOO..: Good, can merge.
-      // ..sssooofff.. -> ..SSSOFFF..: Fatal.
-      // ..sssooosss.. -> ..SSSOOFFFF..: Fatal.
-      // ..oooooo.. -> ..OOO..: Good, can merge.
-      // Idea of check: Suppose |fast| has dangling RVA, then
-      // |[fast->rva_start, fast->rva_start + fast->offset_start)| ->
-      // |[fast->offset_start, **fast->offset_end()**)|, with remaining RVA
-      // mapping to fake offsets. This means |fast->offset_end()| must be >=
-      // |slow->offset_end()|, and failure to do so resluts in error. The
-      // argument for |slow| havng dangling RVA is symmetric.
-      if ((fast->HasDanglingRva() && fast->offset_end() < slow->offset_end()) ||
-          (slow->HasDanglingRva() && slow->offset_end() < fast->offset_end())) {
-        if (merge_is_optional) {
-          *(++slow) = *fast;
-          continue;
-        }
-        return kErrorBadOverlapDanglingRva;
-      }
-
-      // Merge |fast| into |slow|.
-      slow->rva_size =
-          std::max(slow->rva_size, fast->rva_end() - slow->rva_begin);
-      slow->offset_size =
-          std::max(slow->offset_size, fast->offset_end() - slow->offset_begin);
-    }
-    ++slow;
-    units.erase(slow, units.end());
-  }
-
-  // After resolving RVA overlaps, any offset overlap would imply error.
-  std::sort(units.begin(), units.end(), [](const Unit& a, const Unit& b) {
-    return a.offset_begin < b.offset_begin;
-  });
-
-  if (units.size() > 1) {
-    auto previous = units.begin();
-    for (auto current = previous + 1; current != units.end(); ++current) {
-      if (previous->offset_end() > current->offset_begin)
-        return kErrorBadOverlap;
-      previous = current;
-    }
-  }
-
-  // For to fake offset heuristics: Compute exclusive upper bounds for offsets
-  // and RVAs.
-  offset_t offset_bound = 0;
-  rva_t rva_bound = 0;
-  for (const Unit& unit : units) {
-    offset_bound = std::max(offset_bound, unit.offset_end());
-    rva_bound = std::max(rva_bound, unit.rva_end());
-  }
-
-  // Compute pessimistic range and see if it still fits within space of valid
-  // offsets. This limits image size to one half of |kOffsetBound|, and is a
-  // main drawback for the current heuristic to convert dangling RVA to fake
-  // offsets.
-  if (!RangeIsBounded(offset_bound, rva_bound, kOffsetBound))
-    return kErrorFakeOffsetBeginTooLarge;
-
-  // Success. Store results. |units| is currently sorted by offset, so assign.
-  units_sorted_by_offset_.assign(units.begin(), units.end());
-
-  // Sort |units| by RVA, and just store it directly
-  std::sort(units.begin(), units.end(), [](const Unit& a, const Unit& b) {
-    return a.rva_begin < b.rva_begin;
-  });
-  units_sorted_by_rva_ = std::move(units);
-
-  fake_offset_begin_ = offset_bound;
-  return kSuccess;
-}
-
-rva_t AddressTranslator::OffsetToRva(offset_t offset) const {
-  if (offset >= fake_offset_begin_) {
-    // Handle dangling RVA: First shift it to regular RVA space.
-    rva_t rva = offset - fake_offset_begin_;
-    // If result is indeed a dangling RVA, return it; else return |kInvalidRva|.
-    const Unit* unit = RvaToUnit(rva);
-    return (unit && unit->HasDanglingRva() && unit->CoversDanglingRva(rva))
-               ? rva
-               : kInvalidRva;
-  }
-  const Unit* unit = OffsetToUnit(offset);
-  return unit ? unit->OffsetToRvaUnsafe(offset) : kInvalidRva;
-}
-
-offset_t AddressTranslator::RvaToOffset(rva_t rva) const {
-  const Unit* unit = RvaToUnit(rva);
-  // This also handles dangling RVA.
-  return unit ? unit->RvaToOffsetUnsafe(rva, fake_offset_begin_)
-              : kInvalidOffset;
-}
-
-const AddressTranslator::Unit* AddressTranslator::OffsetToUnit(
-    offset_t offset) const {
-  // Finds first Unit with |offset_begin| > |offset|, rewind by 1 to find the
-  // last Unit with |offset_begin| >= |offset| (if it exists).
-  auto it = std::upper_bound(
-      units_sorted_by_offset_.begin(), units_sorted_by_offset_.end(), offset,
-      [](offset_t a, const Unit& b) { return a < b.offset_begin; });
-  if (it == units_sorted_by_offset_.begin())
-    return nullptr;
-  --it;
-  return it->CoversOffset(offset) ? &(*it) : nullptr;
-}
-
-const AddressTranslator::Unit* AddressTranslator::RvaToUnit(rva_t rva) const {
-  auto it = std::upper_bound(
-      units_sorted_by_rva_.begin(), units_sorted_by_rva_.end(), rva,
-      [](rva_t a, const Unit& b) { return a < b.rva_begin; });
-  if (it == units_sorted_by_rva_.begin())
-    return nullptr;
-  --it;
-  return it->CoversRva(rva) ? &(*it) : nullptr;
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/aosp/include/base/check.h b/native/zucchini/vendor/zucchini/aosp/include/base/check.h
deleted file mode 100644
index 3ed2e04..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/base/check.h
+++ /dev/null
@@ -1,22 +0,0 @@
-//
-// Copyright (C) 2021 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef __ZUCCHINI_AOSP_BASE_CHECK_H
-#define __ZUCCHINI_AOSP_BASE_CHECK_H
-
-#include <base/logging.h>
-
-#endif /* __ZUCCHINI_AOSP_BASE_CHECK_H */
diff --git a/native/zucchini/vendor/zucchini/aosp/include/base/check_op.h b/native/zucchini/vendor/zucchini/aosp/include/base/check_op.h
deleted file mode 100644
index 47162e6..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/base/check_op.h
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// Copyright (C) 2021 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef __ZUCCHINI_AOSP_BASE_CHECK_OP_H
-#define __ZUCCHINI_AOSP_BASE_CHECK_OP_H
-
-#include <base/logging.h>
-
-#define FLAG_WIN_SHARE_DELETE FLAG_SHARE_DELETE
-
-#endif /* __ZUCCHINI_AOSP_BASE_CHECK_OP_H */
diff --git a/native/zucchini/vendor/zucchini/aosp/include/base/containers/cxx20_erase.h b/native/zucchini/vendor/zucchini/aosp/include/base/containers/cxx20_erase.h
deleted file mode 100644
index 2fac314..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/base/containers/cxx20_erase.h
+++ /dev/null
@@ -1,22 +0,0 @@
-//
-// Copyright (C) 2021 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#ifndef __ZUCCHINI_AOSP_BASE_CONTAINERS_CXX20_ERASE_H
-#define __ZUCCHINI_AOSP_BASE_CONTAINERS_CXX20_ERASE_H
-
-#include <base/stl_util.h>
-
-#endif
diff --git a/native/zucchini/vendor/zucchini/aosp/include/build/buildflag.h b/native/zucchini/vendor/zucchini/aosp/include/build/buildflag.h
deleted file mode 100644
index 8d7c0e0..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/build/buildflag.h
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef BUILD_BUILDFLAG_H_
-#define BUILD_BUILDFLAG_H_
-
-// These macros un-mangle the names of the build flags in a way that looks
-// natural, and gives errors if the flag is not defined. Normally in the
-// preprocessor it's easy to make mistakes that interpret "you haven't done
-// the setup to know what the flag is" as "flag is off". Normally you would
-// include the generated header rather than include this file directly.
-//
-// This is for use with generated headers. See build/buildflag_header.gni.
-
-// This dance of two macros does a concatenation of two preprocessor args using
-// ## doubly indirectly because using ## directly prevents macros in that
-// parameter from being expanded.
-#define BUILDFLAG_CAT_INDIRECT(a, b) a##b
-#define BUILDFLAG_CAT(a, b) BUILDFLAG_CAT_INDIRECT(a, b)
-
-// Accessor for build flags.
-//
-// To test for a value, if the build file specifies:
-//
-//   ENABLE_FOO=true
-//
-// Then you would check at build-time in source code with:
-//
-//   #include "foo_flags.h"  // The header the build file specified.
-//
-//   #if BUILDFLAG(ENABLE_FOO)
-//     ...
-//   #endif
-//
-// There will no #define called ENABLE_FOO so if you accidentally test for
-// whether that is defined, it will always be negative. You can also use
-// the value in expressions:
-//
-//   const char kSpamServerName[] = BUILDFLAG(SPAM_SERVER_NAME);
-//
-// Because the flag is accessed as a preprocessor macro with (), an error
-// will be thrown if the proper header defining the internal flag value has
-// not been included.
-#define BUILDFLAG(flag) (BUILDFLAG_CAT(BUILDFLAG_INTERNAL_, flag)())
-
-#endif // BUILD_BUILDFLAG_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/abs32_utils.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/abs32_utils.h
deleted file mode 100644
index ecdb61a..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/abs32_utils.h
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_ABS32_UTILS_H_
-#define COMPONENTS_ZUCCHINI_ABS32_UTILS_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <optional>
-#include <vector>
-
-#include "components/zucchini/address_translator.h"
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/image_utils.h"
-
-namespace zucchini {
-
-// A class to represent an abs32 address (32-bit or 64-bit). Accessors are
-// provided to translate from / to RVA, and to read / write the represented
-// abs32 address from / to an image.
-class AbsoluteAddress {
- public:
-  AbsoluteAddress(Bitness bitness, uint64_t image_base);
-  AbsoluteAddress(AbsoluteAddress&&);
-  ~AbsoluteAddress();
-
-  // Attempts to translate |rva| to an abs32 address. On success, assigns
-  // |value_| to the result and returns true. On failure (invalid |rva| or
-  // overflow), returns false.
-  bool FromRva(rva_t rva);
-
-  // Returns the RVA for |value_|, or |kInvalidRva| if the represented value
-  // address does not correspond to a valid RVA.
-  rva_t ToRva() const;
-
-  // Attempts to read the abs32 address at |image[offset]| into |value_|. On
-  // success, updates |value_| and returns true. On failure (invalid |offset|),
-  // returns false.
-  bool Read(offset_t offset, const ConstBufferView& image);
-
-  // Attempts to write |value_| to to |(*image)[offset]|. On success, performs
-  // the write and returns true. On failure (invalid |offset|), returns false.
-  bool Write(offset_t offset, MutableBufferView* image);
-
-  uint32_t width() const { return WidthOf(bitness_); }
-
-  // Exposing |value_| for testing.
-  uint64_t* mutable_value() { return &value_; }
-
- private:
-  const Bitness bitness_;
-  const uint64_t image_base_;  // Accommodates 32-bit and 64-bit.
-  uint64_t value_;             // Accommodates 32-bit and 64-bit.
-};
-
-// A class to extract Win32 abs32 references from |abs32_locations| within
-// |image_| bounded by |[lo, hi)|. GetNext() is used to successively return
-// data as Units, which are locations and (potentially out-of-bound) RVAs.
-// |addr| determines the bitness of abs32 values stored, and mediates all reads.
-class Abs32RvaExtractorWin32 {
- public:
-  struct Unit {
-    offset_t location;
-    rva_t target_rva;
-  };
-
-  // Requires |lo| <= |hi|, and they must not straddle a reference body (with
-  // length |addr.width()|) in |abs32_locations|.
-  Abs32RvaExtractorWin32(ConstBufferView image,
-                         AbsoluteAddress&& addr,
-                         const std::vector<offset_t>& abs32_locations,
-                         offset_t lo,
-                         offset_t hi);
-  Abs32RvaExtractorWin32(Abs32RvaExtractorWin32&&);
-  ~Abs32RvaExtractorWin32();
-
-  // Visits given abs32 locations, rejects invalid locations and non-existent
-  // RVAs, and returns reference as Unit, or std::nullopt on completion.
-  std::optional<Unit> GetNext();
-
- private:
-  ConstBufferView image_;
-  AbsoluteAddress addr_;
-  std::vector<offset_t>::const_iterator cur_abs32_;
-  std::vector<offset_t>::const_iterator end_abs32_;
-};
-
-// A reader for Win32 abs32 references that filters and translates results from
-// |abs32_rva_extractor_|.
-class Abs32ReaderWin32 : public ReferenceReader {
- public:
-  Abs32ReaderWin32(Abs32RvaExtractorWin32&& abs32_rva_extractor,
-                   const AddressTranslator& translator);
-  Abs32ReaderWin32(const Abs32ReaderWin32&) = delete;
-  const Abs32ReaderWin32& operator=(const Abs32ReaderWin32&) = delete;
-  ~Abs32ReaderWin32() override;
-
-  // ReferenceReader:
-  std::optional<Reference> GetNext() override;
-
- private:
-  Abs32RvaExtractorWin32 abs32_rva_extractor_;
-  AddressTranslator::RvaToOffsetCache target_rva_to_offset_;
-};
-
-// A writer for Win32 abs32 references. |addr| determines the bitness of the
-// abs32 values stored, and mediates all writes.
-class Abs32WriterWin32 : public ReferenceWriter {
- public:
-  Abs32WriterWin32(MutableBufferView image,
-                   AbsoluteAddress&& addr,
-                   const AddressTranslator& translator);
-  Abs32WriterWin32(const Abs32WriterWin32&) = delete;
-  const Abs32WriterWin32& operator=(const Abs32WriterWin32&) = delete;
-  ~Abs32WriterWin32() override;
-
-  // ReferenceWriter:
-  void PutNext(Reference ref) override;
-
- private:
-  MutableBufferView image_;
-  AbsoluteAddress addr_;
-  AddressTranslator::OffsetToRvaCache target_offset_to_rva_;
-};
-
-// Given a list of abs32 |locations|, removes all elements whose targets cannot
-// be translated. Returns the number of elements removed.
-size_t RemoveUntranslatableAbs32(ConstBufferView image,
-                                 AbsoluteAddress&& addr,
-                                 const AddressTranslator& translator,
-                                 std::vector<offset_t>* locations);
-
-// Given a sorted list of abs32 |locations|, removes all elements whose body
-// (with |width| given) overlaps with the body of a previous element.
-size_t RemoveOverlappingAbs32Locations(uint32_t width,
-                                       std::vector<offset_t>* locations);
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_ABS32_UTILS_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/address_translator.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/address_translator.h
deleted file mode 100644
index a517a2c..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/address_translator.h
+++ /dev/null
@@ -1,199 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_ADDRESS_TRANSLATOR_H_
-#define COMPONENTS_ZUCCHINI_ADDRESS_TRANSLATOR_H_
-
-#include <stdint.h>
-
-#include <tuple>
-#include <vector>
-
-#include "components/zucchini/algorithm.h"
-#include "components/zucchini/image_utils.h"
-
-namespace zucchini {
-
-// There are several ways to reason about addresses in an image:
-// - Offset: Position relative to start of image.
-// - VA (Virtual Address): Virtual memory address of a loaded image. This is
-//   subject to relocation by the OS.
-// - RVA (Relative Virtual Address): VA relative to some base address. This is
-//   the preferred way to specify pointers in an image.
-//
-// Zucchini is primarily concerned with offsets and RVAs. Executable images like
-// PE and ELF are organized into sections. Each section specifies offset and RVA
-// ranges as:
-//   {Offset start, offset size, RVA start, RVA size}.
-// This constitutes a basic unit to translate between offsets and RVAs. Note:
-// |offset size| < |RVA size| is possible. For example, the .bss section can can
-// have zero-filled statically-allocated data that have no corresponding bytes
-// on image (to save space). This poses a problem for Zucchini, which stores
-// addresses as offsets: now we'd have "dangling RVAs" that don't map to
-// offsets! Some ways to handling this are:
-// 1. Ignore all dangling RVAs. This simplifies the algorithm, but also means
-//    some reference targets would escape detection and processing.
-// 2. Create distinct "fake offsets" to accommodate dangling RVAs. Image data
-//    must not be read on these fake offsets, which are only valid as target
-//    addresses for reference matching.
-// As for |RVA size| < |offset size|, the extra portion just gets ignored.
-//
-// Status: Zucchini implements (2) in a simple way: dangling RVAs are mapped to
-// fake offsets by adding a large value. This value can be chosen as an
-// exclusive upper bound of all offsets (i.e., image size). This allows them to
-// be easily detected and processed as a special-case.
-// TODO(huangs): Investigate option (1), now that the refactored code makes
-// experimentation easier.
-// TODO(huangs): Make AddressTranslator smarter: Allocate unused |offset_t|
-// ranges and create "fake" units to accommodate dangling RVAs. Then
-// AddressTranslator can be simplified.
-
-// Virtual Address relative to some base address (RVA). There's distinction
-// between "valid RVA" and "existent RVA":
-// - Valid RVA: An RVA that's reasonably small, i.e., below |kRvaBound|.
-// - Existent RVA: An RVA that has semantic meaning in an image, and may
-//   translate to an offset in an image or (if a dangling RVA) a fake offset.
-//   All existent RVAs are valid RVAs.
-using rva_t = uint32_t;
-// Divide by 2 to match |kOffsetBound|.
-constexpr rva_t kRvaBound = static_cast<rva_t>(-1) / 2;
-constexpr rva_t kInvalidRva = static_cast<rva_t>(-2);
-
-// A utility to translate between offsets and RVAs in an image.
-class AddressTranslator {
- public:
-  // A basic unit for address translation, roughly maps to a section, but may
-  // be processed (e.g., merged) as an optimization.
-  struct Unit {
-    offset_t offset_end() const { return offset_begin + offset_size; }
-    rva_t rva_end() const { return rva_begin + rva_size; }
-    bool IsEmpty() const {
-      // |rva_size == 0| and |offset_size > 0| means Unit hasn't been trimmed
-      // yet, and once it is then it's empty.
-      // |rva_size > 0| and |offset_size == 0| means Unit has dangling RVA, but
-      // is not empty.
-      return rva_size == 0;
-    }
-    bool CoversOffset(offset_t offset) const {
-      return RangeCovers(offset_begin, offset_size, offset);
-    }
-    bool CoversRva(rva_t rva) const {
-      return RangeCovers(rva_begin, rva_size, rva);
-    }
-    bool CoversDanglingRva(rva_t rva) const {
-      return CoversRva(rva) && rva - rva_begin >= offset_size;
-    }
-    // Assumes valid |offset| (*cannot* be fake offset).
-    rva_t OffsetToRvaUnsafe(offset_t offset) const {
-      return offset - offset_begin + rva_begin;
-    }
-    // Assumes valid |rva| (*can* be danging RVA).
-    offset_t RvaToOffsetUnsafe(rva_t rva, offset_t fake_offset_begin) const {
-      rva_t delta = rva - rva_begin;
-      return delta < offset_size ? delta + offset_begin
-                                 : fake_offset_begin + rva;
-    }
-    bool HasDanglingRva() const { return rva_size > offset_size; }
-    friend bool operator==(const Unit& a, const Unit& b) {
-      return std::tie(a.offset_begin, a.offset_size, a.rva_begin, a.rva_size) ==
-             std::tie(b.offset_begin, b.offset_size, b.rva_begin, b.rva_size);
-    }
-
-    offset_t offset_begin;
-    offset_t offset_size;
-    rva_t rva_begin;
-    rva_t rva_size;
-  };
-
-  // An adaptor for AddressTranslator::OffsetToRva() that caches the last Unit
-  // found, to reduce the number of OffsetToUnit() calls for clustered queries.
-  class OffsetToRvaCache {
-   public:
-    // Embeds |translator| for use. Now object lifetime is tied to |translator|
-    // lifetime.
-    explicit OffsetToRvaCache(const AddressTranslator& translator);
-    OffsetToRvaCache(const OffsetToRvaCache&) = delete;
-    const OffsetToRvaCache& operator=(const OffsetToRvaCache&) = delete;
-
-    rva_t Convert(offset_t offset) const;
-
-   private:
-    const AddressTranslator& translator_;
-    mutable const AddressTranslator::Unit* cached_unit_ = nullptr;
-  };
-
-  // An adaptor for AddressTranslator::RvaToOffset() that caches the last Unit
-  // found, to reduce the number of RvaToUnit() calls for clustered queries.
-  class RvaToOffsetCache {
-   public:
-    // Embeds |translator| for use. Now object lifetime is tied to |translator|
-    // lifetime.
-    explicit RvaToOffsetCache(const AddressTranslator& translator);
-    RvaToOffsetCache(const RvaToOffsetCache&) = delete;
-    const RvaToOffsetCache& operator=(const RvaToOffsetCache&) = delete;
-
-    bool IsValid(rva_t rva) const;
-
-    offset_t Convert(rva_t rva) const;
-
-   private:
-    const AddressTranslator& translator_;
-    mutable const AddressTranslator::Unit* cached_unit_ = nullptr;
-  };
-
-  enum Status {
-    kSuccess = 0,
-    kErrorOverflow,
-    kErrorBadOverlap,
-    kErrorBadOverlapDanglingRva,
-    kErrorFakeOffsetBeginTooLarge,
-  };
-
-  AddressTranslator();
-  AddressTranslator(AddressTranslator&&);
-  AddressTranslator(const AddressTranslator&) = delete;
-  const AddressTranslator& operator=(const AddressTranslator&) = delete;
-  ~AddressTranslator();
-
-  // Consumes |units| to populate data in this class. Performs consistency
-  // checks and overlapping Units. Returns Status to indicate success.
-  Status Initialize(std::vector<Unit>&& units);
-
-  // Returns the (possibly dangling) RVA corresponding to |offset|, or
-  // kInvalidRva if not found.
-  rva_t OffsetToRva(offset_t offset) const;
-
-  // Returns the (possibly fake) offset corresponding to |rva|, or
-  // kInvalidOffset if not found (i.e., |rva| is non-existent).
-  offset_t RvaToOffset(rva_t rva) const;
-
-  // For testing.
-  offset_t fake_offset_begin() const { return fake_offset_begin_; }
-
-  const std::vector<Unit>& units_sorted_by_offset() const {
-    return units_sorted_by_offset_;
-  }
-
-  const std::vector<Unit>& units_sorted_by_rva() const {
-    return units_sorted_by_rva_;
-  }
-
- private:
-  // Helper to find the Unit that contains given |offset| or |rva|. Returns null
-  // if not found.
-  const Unit* OffsetToUnit(offset_t offset) const;
-  const Unit* RvaToUnit(rva_t rva) const;
-
-  // Storage of Units. All offset ranges are non-empty and disjoint. Likewise
-  // for all RVA ranges.
-  std::vector<Unit> units_sorted_by_offset_;
-  std::vector<Unit> units_sorted_by_rva_;
-
-  // Conversion factor to translate between dangling RVAs and fake offsets.
-  offset_t fake_offset_begin_;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_ADDRESS_TRANSLATOR_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/algorithm.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/algorithm.h
deleted file mode 100644
index 4cafe93..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/algorithm.h
+++ /dev/null
@@ -1,147 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_ALGORITHM_H_
-#define COMPONENTS_ZUCCHINI_ALGORITHM_H_
-
-#include <stddef.h>
-
-#include <algorithm>
-#include <deque>
-#include <type_traits>
-#include <vector>
-
-#include "base/check_op.h"
-
-// Collection of simple utilities used in for low-level computation.
-
-namespace zucchini {
-
-// Safely determines whether |[begin, begin + size)| is in |[0, bound)|. Note:
-// The special case |[bound, bound)| is not considered to be in |[0, bound)|.
-template <typename T>
-bool RangeIsBounded(T begin, T size, size_t bound) {
-  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned.");
-  return begin < bound && size <= bound - begin;
-}
-
-// Safely determines whether |value| lies in |[begin, begin + size)|. Works
-// properly even if |begin + size| overflows -- although such ranges are
-// considered pathological, and should fail validation elsewhere.
-template <typename T>
-bool RangeCovers(T begin, T size, T value) {
-  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned.");
-  return begin <= value && value - begin < size;
-}
-
-// Returns the integer in inclusive range |[lo, hi]| that's closest to |value|.
-// This departs from the usual usage of semi-inclusive ranges, but is useful
-// because (1) sentinels can use this, (2) a valid output always exists. It is
-// assumed that |lo <= hi|.
-template <class T>
-T InclusiveClamp(T value, T lo, T hi) {
-  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned.");
-  DCHECK_LE(lo, hi);
-  return value <= lo ? lo : (value >= hi ? hi : value);
-}
-
-// Returns the minimum multiple of |m| that's no less than |x|. Assumes |m > 0|
-// and |x| is sufficiently small so that no overflow occurs.
-template <class T>
-constexpr T AlignCeil(T x, T m) {
-  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned.");
-  return T((x + m - 1) / m) * m;
-}
-
-// Specialized alignment helpers that returns the increment to |pos| to get the
-// next n-aligned value, where n is in {2, 4}. This is useful for aligning
-// iterators relative to a base iterator using:
-//   it += IncrementForAlignCeil2(it - base);
-template <class T>
-inline int IncrementForAlignCeil2(T pos) {
-  return static_cast<int>(pos & 1);  // Optimized from (-pos) & 1.
-}
-
-template <class T>
-inline int IncrementForAlignCeil4(T pos) {
-  return static_cast<int>((-pos) & 3);
-}
-
-// Sorts values in |container| and removes duplicates.
-template <class T>
-void SortAndUniquify(std::deque<T>* container) {
-  std::sort(container->begin(), container->end());
-  container->erase(std::unique(container->begin(), container->end()),
-                   container->end());
-  container->shrink_to_fit();
-}
-
-// Extracts a single bit at |pos| from integer |v|.
-template <int pos, typename T>
-constexpr T GetBit(T v) {
-  return (v >> pos) & 1;
-}
-
-// Extracts bits in inclusive range [|lo|, |hi|] from integer |v|, and returns
-// the sign-extend result. For example, let the (MSB-first) bits in a 32-bit int
-// |v| be:
-//   xxxxxxxx xxxxxSii iiiiiiii iyyyyyyy,
-//               hi^          lo^       => lo = 7, hi = 18
-// To extract "Sii iiiiiiii i", calling
-//   GetSignedBits<7, 18>(v);
-// produces the sign-extended result:
-//   SSSSSSSS SSSSSSSS SSSSSiii iiiiiiii.
-template <int lo, int hi, typename T>
-constexpr typename std::make_signed<T>::type GetSignedBits(T v) {
-  constexpr int kNumBits = sizeof(T) * 8;
-  using SignedType = typename std::make_signed<T>::type;
-  // Assumes 0 <= |lo| <= |hi| < |kNumBits|.
-  // How this works:
-  // (1) Shift-left by |kNumBits - 1 - hi| to clear "left" bits.
-  // (2) Shift-right by |kNumBits - 1 - hi + lo| to clear "right" bits. The
-  //     input is casted to a signed type to perform sign-extension.
-  return static_cast<SignedType>(v << (kNumBits - 1 - hi)) >>
-         (kNumBits - 1 - hi + lo);
-}
-
-// Similar to GetSignedBits(), but returns the zero-extended result. For the
-// above example, calling
-//   GetUnsignedBits<7, 18>(v);
-// results in:
-//   00000000 00000000 0000Siii iiiiiiii.
-template <int lo, int hi, typename T>
-constexpr typename std::make_unsigned<T>::type GetUnsignedBits(T v) {
-  constexpr int kNumBits = sizeof(T) * 8;
-  using UnsignedType = typename std::make_unsigned<T>::type;
-  return static_cast<UnsignedType>(v << (kNumBits - 1 - hi)) >>
-         (kNumBits - 1 - hi + lo);
-}
-
-// Copies bits at |pos| in |v| to all higher bits, and returns the result as the
-// same int type as |v|.
-template <typename T>
-constexpr T SignExtend(int pos, T v) {
-  int kNumBits = sizeof(T) * 8;
-  int kShift = kNumBits - 1 - pos;
-  return static_cast<typename std::make_signed<T>::type>(v << kShift) >> kShift;
-}
-
-// Optimized version where |pos| becomes a template parameter.
-template <int pos, typename T>
-constexpr T SignExtend(T v) {
-  constexpr int kNumBits = sizeof(T) * 8;
-  constexpr int kShift = kNumBits - 1 - pos;
-  return static_cast<typename std::make_signed<T>::type>(v << kShift) >> kShift;
-}
-
-// Determines whether |v|, if interpreted as a signed integer, is representable
-// using |digs| bits. |1 <= digs <= sizeof(T)| is assumed.
-template <int digs, typename T>
-constexpr bool SignedFit(T v) {
-  return v == SignExtend<digs - 1, T>(v);
-}
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_ALGORITHM_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/arm_utils.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/arm_utils.h
deleted file mode 100644
index 8664f3e..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/arm_utils.h
+++ /dev/null
@@ -1,423 +0,0 @@
-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_ARM_UTILS_H_
-#define COMPONENTS_ZUCCHINI_ARM_UTILS_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include "base/check_op.h"
-#include "components/zucchini/address_translator.h"
-#include "components/zucchini/buffer_view.h"
-
-namespace zucchini {
-
-// References:
-// * AArch32 (32-bit ARM, AKA ARM32):
-//     https://static.docs.arm.com/ddi0406/c/DDI0406C_C_arm_architecture_reference_manual.pdf
-// * AArch64 (64-bit ARM):
-//     https://static.docs.arm.com/ddi0487/da/DDI0487D_a_armv8_arm.pdf
-
-// Definitions (used in Zucchini):
-// * |instr_rva|: Instruction RVA: The RVA where an instruction is located. In
-//   ARM mode and for AArch64 this is 4-byte aligned; in THUMB2 mode this is
-//   2-byte aligned.
-// * |code|: Instruction code: ARM instruction code as seen in manual. In ARM
-//   mode and for AArch64, this is a 32-bit int. In THUMB2 mode, this may be a
-//   16-bit or 32-bit int.
-// * |disp|: Displacement: For branch instructions (e.g.: B, BL, BLX, and
-//   conditional varieties) this is the value encoded in instruction bytes.
-// * PC: Program Counter: In ARM mode this is |instr_rva + 8|; in THUMB2 mode
-//   this is |instr_rva + 4|; for AArch64 this is |instr_rva|.
-// * |target_rva|: Target RVA: The RVA targeted by a branch instruction.
-//
-// These are related by:
-//   |code| = Fetch(image data at offset(|instr_rva|)).
-//   |disp| = Decode(|code|).
-//   PC = |instr_rva| + {8 in ARM mode, 4 in THUMB2 mode, 0 for AArch64}.
-//   |target_rva| = PC + |disp| - (see "BLX complication" below)
-//
-// Example 1 (ARM mode):
-//   00103050: 00 01 02 EA    B     00183458
-//   |instr_rva| = 0x00103050  (4-byte aligned).
-//   |code| = 0xEA020100  (little endian fetched from data).
-//   |disp| = 0x00080400  (decoded from |code| with A24 -> B encoding T1).
-//   PC = |instr_rva| + 8 = 0x00103058  (ARM mode).
-//   |target_rva| = PC + |disp| = 0x00183458.
-//
-// Example 2 (THUMB2 mode):
-//   001030A2: 00 F0 01 FA    BL    001034A8
-//   |instr_rva| = 0x001030A2  (2-byte aligned).
-//   |code| = 0xF000FA01  (special THUMB2 mode data fetch).
-//   |disp| = 0x00000402  (decoded from |code| with T24 -> BL encoding T1).
-//   PC = |instr_rva| + 4 = 0x001030A6  (THUMB2 mode).
-//   |target_rva| = PC + |disp| = 0x001034A8.
-//
-// Example 3 (AArch64):
-//   0000000000305070: 03 02 01 14    B     000000000034587C
-//   |instr_rva| = 0x00305070  (4-byte aligned, assumed to fit in 32-bit).
-//   |code| = 0x14010203  (little endian fetchd from data).
-//   |disp| = 0x0004080C  (decoded from |code| with Immd -> B).
-//   PC = |instr_rva| = 0x00305070  (AArch64).
-//   |target_rva| = PC + |disp| = 0x0034587C.
-
-// BLX complication: BLX transits between ARM mode and THUMB2 mode, and branches
-// to an address. Therefore |instr_rva| must align by the "old" mode, and
-// |target_rva| must align by the "new" mode. In particular:
-// * BLX encoding A2 (ARM -> THUMB2): |instr_rva| is 4-byte aligned with
-//   PC = |instr_rva| + 8; |target_rva| is 2-byte aligned, and so |disp| is
-//   2-byte aligned.
-// * BLX encoding T2 (THUMB2 -> ARM): |instr_rva| is 2-byte aligned with
-//   PC = |instr_rva| + 4; |target_rva| is 4-byte aligned. Complication: BLX
-//   encoding T2 stores a bit |H| that corresponds to "2" in binary, but |H|
-//   must be set to 0. Thus the encoded value is effectively 4-byte aligned. So
-//   when computing |target_rva| by adding PC (2-byte aligned) to the stored
-//   value (4-byte aligned), the result must be rounded down to the nearest
-//   4-byte aligned address.
-// The last situation creates ambiguity in how |disp| is defined! Alternatives:
-// (1) |disp| := |target_rva| - PC: So |code| <-> |disp| for BLX encoding T2,
-//     requires |instr_rva| % 4 to be determined, and adjustments made.
-// (2) |disp| := Value stored in |code|: So |disp| <-> |target_rva| for BLX
-//     encoding T2 requires adjustment: |disp| -> |target_rva| needs to round
-//     down, whereas |target_rva| -> |disp| needs to round up.
-// We adopt (2) to simplify |code| <-> |disp|, since that gets used.
-
-using arm_disp_t = int32_t;
-
-// Alignment requirement for |target_rva|, useful for |disp| <-> |target_rva|
-// (also requires |instr_rva|). Alignment is determined by parsing |code| in
-// *Decode() functions. kArmAlignFail is also defined to indicate parse failure.
-// Alignments can be 2 or 4. These values are also used in the enum, so
-// |x % align| with |x & (align - 1)| to compute alignment.
-enum ArmAlign : uint32_t {
-  kArmAlignFail = 0U,
-  kArmAlign2 = 2U,
-  kArmAlign4 = 4U,
-};
-
-// Traits for rel32 address types (technically rel64 for AArch64 -- but we
-// assume values are small enough), which form collections of strategies to
-// process each rel32 address type.
-template <typename ENUM_ADDR_TYPE,
-          ENUM_ADDR_TYPE ADDR_TYPE,
-          typename CODE_T,
-          CODE_T (*FETCH)(ConstBufferView, offset_t),
-          void (*STORE)(MutableBufferView, offset_t, CODE_T),
-          ArmAlign (*DECODE)(CODE_T, arm_disp_t*),
-          bool (*ENCODE)(arm_disp_t, CODE_T*),
-          bool (*READ)(rva_t, CODE_T, rva_t*),
-          bool (*WRITE)(rva_t, rva_t, CODE_T*)>
-class ArmAddrTraits {
- public:
-  static constexpr ENUM_ADDR_TYPE addr_type = ADDR_TYPE;
-  using code_t = CODE_T;
-  static constexpr CODE_T (*Fetch)(ConstBufferView, offset_t) = FETCH;
-  static constexpr void (*Store)(MutableBufferView, offset_t, CODE_T) = STORE;
-  static constexpr ArmAlign (*Decode)(CODE_T, arm_disp_t*) = DECODE;
-  static constexpr bool (*Encode)(arm_disp_t, CODE_T*) = ENCODE;
-  static constexpr bool (*Read)(rva_t, CODE_T, rva_t*) = READ;
-  static constexpr bool (*Write)(rva_t, rva_t, CODE_T*) = WRITE;
-};
-
-// Given THUMB2 instruction |code16|, returns 2 if it's from a 16-bit THUMB2
-// instruction, or 4 if it's from a 32-bit THUMB2 instruction.
-inline int GetThumb2InstructionSize(uint16_t code16) {
-  return ((code16 & 0xF000) == 0xF000 || (code16 & 0xF800) == 0xE800) ? 4 : 2;
-}
-
-// A translator for ARM mode and THUMB2 mode with static functions that
-// translate among |code|, |disp|, and |target_rva|.
-class AArch32Rel32Translator {
- public:
-  // Rel32 address types enumeration.
-  enum AddrType : uint8_t {
-    ADDR_NONE = 0xFF,
-    // Naming: Here "A24" represents ARM mode instructions where |code|
-    // dedicates 24 bits (including sign bit) to specify |disp|. Similarly, "T8"
-    // represents THUMB2 mode instructions with 8 bits for |disp|. Currently
-    // only {A24, T8, T11, T20, T24} are defined. These are not to be confused
-    // with "B encoding A1", "B encoding T3", etc., which are specific encoding
-    // schemes given by the manual for the "B" (or other) instructions (only
-    // {A1, A2, T1, T2, T3, T4} are seen).
-    ADDR_A24 = 0,
-    ADDR_T8,
-    ADDR_T11,
-    ADDR_T20,
-    ADDR_T24,
-    NUM_ADDR_TYPE
-  };
-
-  AArch32Rel32Translator();
-  AArch32Rel32Translator(const AArch32Rel32Translator&) = delete;
-  const AArch32Rel32Translator& operator=(const AArch32Rel32Translator&) =
-      delete;
-
-  // Fetches the 32-bit ARM instruction |code| at |view[idx]|.
-  static inline uint32_t FetchArmCode32(ConstBufferView view, offset_t idx) {
-    return view.read<uint32_t>(idx);
-  }
-
-  // Fetches the 16-bit THUMB2 instruction |code| at |view[idx]|.
-  static inline uint16_t FetchThumb2Code16(ConstBufferView view, offset_t idx) {
-    return view.read<uint16_t>(idx);
-  }
-
-  // Fetches the 32-bit THUMB2 instruction |code| at |view[idx]|.
-  static inline uint32_t FetchThumb2Code32(ConstBufferView view, offset_t idx) {
-    // By convention, 32-bit THUMB2 instructions are written (as seen later) as:
-    //   [byte3, byte2, byte1, byte0].
-    // However (assuming little-endian ARM) the in-memory representation is
-    //   [byte2, byte3, byte0, byte1].
-    return (static_cast<uint32_t>(view.read<uint16_t>(idx)) << 16) |
-           view.read<uint16_t>(idx + 2);
-  }
-
-  // Stores the 32-bit ARM instruction |code| to |mutable_view[idx]|.
-  static inline void StoreArmCode32(MutableBufferView mutable_view,
-                                    offset_t idx,
-                                    uint32_t code) {
-    mutable_view.write<uint32_t>(idx, code);
-  }
-
-  // Stores the 16-bit THUMB2 instruction |code| to |mutable_view[idx]|.
-  static inline void StoreThumb2Code16(MutableBufferView mutable_view,
-                                       offset_t idx,
-                                       uint16_t code) {
-    mutable_view.write<uint16_t>(idx, code);
-  }
-
-  // Stores the next 32-bit THUMB2 instruction |code| to |mutable_view[idx]|.
-  static inline void StoreThumb2Code32(MutableBufferView mutable_view,
-                                       offset_t idx,
-                                       uint32_t code) {
-    mutable_view.write<uint16_t>(idx, static_cast<uint16_t>(code >> 16));
-    mutable_view.write<uint16_t>(idx + 2, static_cast<uint16_t>(code & 0xFFFF));
-  }
-
-  // The following functions convert |code| (16-bit or 32-bit) from/to |disp|
-  // or |target_rva|, for specific branch instruction types.
-  // Read*() and write*() functions convert between |code| and |target_rva|.
-  // * Decode*() determines whether |code16/code32| is a branch instruction
-  //   of a specific type. If so, then extracts |*disp| and returns the required
-  //   ArmAlign. Otherwise returns kArmAlignFail.
-  // * Encode*() determines whether |*code16/*code32| is a branch instruction of
-  //   a specific type, and whether it can accommodate |disp|. If so, then
-  //   re-encodes |*code32| using |disp|, and returns true. Otherwise returns
-  //   false.
-  // * Read*() is similar to Decode*(), but on success, extracts |*target_rva|
-  //   using |instr_rva| as aid, performs the proper alignment, and returns
-  //   true. Otherwise returns false.
-  // * Write*() is similar to Encode*(), takes |target_rva| instead, and uses
-  //   |instr_rva| as aid.
-  static ArmAlign DecodeA24(uint32_t code32, arm_disp_t* disp);
-  static bool EncodeA24(arm_disp_t disp, uint32_t* code32);
-  // TODO(huangs): Refactor the Read*() functions: These are identical
-  // except for Decode*() and Get*TargetRvaFromDisp().
-  static bool ReadA24(rva_t instr_rva, uint32_t code32, rva_t* target_rva);
-  static bool WriteA24(rva_t instr_rva, rva_t target_rva, uint32_t* code32);
-
-  static ArmAlign DecodeT8(uint16_t code16, arm_disp_t* disp);
-  static bool EncodeT8(arm_disp_t disp, uint16_t* code16);
-  static bool ReadT8(rva_t instr_rva, uint16_t code16, rva_t* target_rva);
-  static bool WriteT8(rva_t instr_rva, rva_t target_rva, uint16_t* code16);
-
-  static ArmAlign DecodeT11(uint16_t code16, arm_disp_t* disp);
-  static bool EncodeT11(arm_disp_t disp, uint16_t* code16);
-  static bool ReadT11(rva_t instr_rva, uint16_t code16, rva_t* target_rva);
-  static bool WriteT11(rva_t instr_rva, rva_t target_rva, uint16_t* code16);
-
-  static ArmAlign DecodeT20(uint32_t code32, arm_disp_t* disp);
-  static bool EncodeT20(arm_disp_t disp, uint32_t* code32);
-  static bool ReadT20(rva_t instr_rva, uint32_t code32, rva_t* target_rva);
-  static bool WriteT20(rva_t instr_rva, rva_t target_rva, uint32_t* code32);
-
-  static ArmAlign DecodeT24(uint32_t code32, arm_disp_t* disp);
-  static bool EncodeT24(arm_disp_t disp, uint32_t* code32);
-  static bool ReadT24(rva_t instr_rva, uint32_t code32, rva_t* target_rva);
-  static bool WriteT24(rva_t instr_rva, rva_t target_rva, uint32_t* code32);
-
-  // Computes |target_rva| from |instr_rva| and |disp| in ARM mode.
-  static inline rva_t GetArmTargetRvaFromDisp(rva_t instr_rva,
-                                              arm_disp_t disp,
-                                              ArmAlign align) {
-    rva_t ret = static_cast<rva_t>(instr_rva + 8 + disp);
-    // Align down.
-    DCHECK_NE(align, kArmAlignFail);
-    return ret - (ret & static_cast<rva_t>(align - 1));
-  }
-
-  // Computes |target_rva| from |instr_rva| and |disp| in THUMB2 mode.
-  static inline rva_t GetThumb2TargetRvaFromDisp(rva_t instr_rva,
-                                                 arm_disp_t disp,
-                                                 ArmAlign align) {
-    rva_t ret = static_cast<rva_t>(instr_rva + 4 + disp);
-    // Align down.
-    DCHECK_NE(align, kArmAlignFail);
-    return ret - (ret & static_cast<rva_t>(align - 1));
-  }
-
-  // Computes |disp| from |instr_rva| and |target_rva| in ARM mode.
-  static inline arm_disp_t GetArmDispFromTargetRva(rva_t instr_rva,
-                                                   rva_t target_rva,
-                                                   ArmAlign align) {
-    // Assumes that |instr_rva + 8| does not overflow.
-    arm_disp_t ret = static_cast<arm_disp_t>(target_rva) -
-                     static_cast<arm_disp_t>(instr_rva + 8);
-    // Align up.
-    DCHECK_NE(align, kArmAlignFail);
-    return ret + ((-ret) & static_cast<arm_disp_t>(align - 1));
-  }
-
-  // Computes |disp| from |instr_rva| and |target_rva| in THUMB2 mode.
-  static inline arm_disp_t GetThumb2DispFromTargetRva(rva_t instr_rva,
-                                                      rva_t target_rva,
-                                                      ArmAlign align) {
-    // Assumes that |instr_rva + 4| does not overflow.
-    arm_disp_t ret = static_cast<arm_disp_t>(target_rva) -
-                     static_cast<arm_disp_t>(instr_rva + 4);
-    // Align up.
-    DCHECK_NE(align, kArmAlignFail);
-    return ret + ((-ret) & static_cast<arm_disp_t>(align - 1));
-  }
-
-  // Strategies to process each rel32 address type.
-  using AddrTraits_A24 = ArmAddrTraits<AddrType,
-                                       ADDR_A24,
-                                       uint32_t,
-                                       FetchArmCode32,
-                                       StoreArmCode32,
-                                       DecodeA24,
-                                       EncodeA24,
-                                       ReadA24,
-                                       WriteA24>;
-  using AddrTraits_T8 = ArmAddrTraits<AddrType,
-                                      ADDR_T8,
-                                      uint16_t,
-                                      FetchThumb2Code16,
-                                      StoreThumb2Code16,
-                                      DecodeT8,
-                                      EncodeT8,
-                                      ReadT8,
-                                      WriteT8>;
-  using AddrTraits_T11 = ArmAddrTraits<AddrType,
-                                       ADDR_T11,
-                                       uint16_t,
-                                       FetchThumb2Code16,
-                                       StoreThumb2Code16,
-                                       DecodeT11,
-                                       EncodeT11,
-                                       ReadT11,
-                                       WriteT11>;
-  using AddrTraits_T20 = ArmAddrTraits<AddrType,
-                                       ADDR_T20,
-                                       uint32_t,
-                                       FetchThumb2Code32,
-                                       StoreThumb2Code32,
-                                       DecodeT20,
-                                       EncodeT20,
-                                       ReadT20,
-                                       WriteT20>;
-  using AddrTraits_T24 = ArmAddrTraits<AddrType,
-                                       ADDR_T24,
-                                       uint32_t,
-                                       FetchThumb2Code32,
-                                       StoreThumb2Code32,
-                                       DecodeT24,
-                                       EncodeT24,
-                                       ReadT24,
-                                       WriteT24>;
-};
-
-// Translator for AArch64, which is simpler than 32-bit ARM. Although pointers
-// are 64-bit, displacements are within 32-bit.
-class AArch64Rel32Translator {
- public:
-  // Rel64 address types enumeration.
-  enum AddrType : uint8_t {
-    ADDR_NONE = 0xFF,
-    ADDR_IMMD14 = 0,
-    ADDR_IMMD19,
-    ADDR_IMMD26,
-    NUM_ADDR_TYPE
-  };
-
-  // Although RVA for 64-bit architecture can be 64-bit in length, we make the
-  // bold assumption that for ELF images that RVA will stay nicely in 32-bit!
-  AArch64Rel32Translator();
-  AArch64Rel32Translator(const AArch64Rel32Translator&) = delete;
-  const AArch64Rel32Translator& operator=(const AArch64Rel32Translator&) =
-      delete;
-
-  static inline uint32_t FetchCode32(ConstBufferView view, offset_t idx) {
-    return view.read<uint32_t>(idx);
-  }
-
-  static inline void StoreCode32(MutableBufferView mutable_view,
-                                 offset_t idx,
-                                 uint32_t code) {
-    mutable_view.write<uint32_t>(idx, code);
-  }
-
-  // Conversion functions for |code32| from/to |disp| or |target_rva|, similar
-  // to the counterparts in AArch32Rel32Translator.
-  static ArmAlign DecodeImmd14(uint32_t code32, arm_disp_t* disp);
-  static bool EncodeImmd14(arm_disp_t disp, uint32_t* code32);
-  // TODO(huangs): Refactor the Read*() functions: These are identical
-  // except for Decode*().
-  static bool ReadImmd14(rva_t instr_rva, uint32_t code32, rva_t* target_rva);
-  static bool WriteImmd14(rva_t instr_rva, rva_t target_rva, uint32_t* code32);
-
-  static ArmAlign DecodeImmd19(uint32_t code32, arm_disp_t* disp);
-  static bool EncodeImmd19(arm_disp_t disp, uint32_t* code32);
-  static bool ReadImmd19(rva_t instr_rva, uint32_t code32, rva_t* target_rva);
-  static bool WriteImmd19(rva_t instr_rva, rva_t target_rva, uint32_t* code32);
-
-  static ArmAlign DecodeImmd26(uint32_t code32, arm_disp_t* disp);
-  static bool EncodeImmd26(arm_disp_t disp, uint32_t* code32);
-  static bool ReadImmd26(rva_t instr_rva, uint32_t code32, rva_t* target_rva);
-  static bool WriteImmd26(rva_t instr_rva, rva_t target_rva, uint32_t* code32);
-
-  static inline rva_t GetTargetRvaFromDisp(rva_t instr_rva, arm_disp_t disp) {
-    return static_cast<rva_t>(instr_rva + disp);
-  }
-
-  static inline arm_disp_t GetDispFromTargetRva(rva_t instr_rva,
-                                                rva_t target_rva) {
-    return static_cast<arm_disp_t>(target_rva - instr_rva);
-  }
-
-  // Strategies to process each rel32 address type.
-  using AddrTraits_Immd14 = ArmAddrTraits<AddrType,
-                                          ADDR_IMMD14,
-                                          uint32_t,
-                                          FetchCode32,
-                                          StoreCode32,
-                                          DecodeImmd14,
-                                          EncodeImmd14,
-                                          ReadImmd14,
-                                          WriteImmd14>;
-  using AddrTraits_Immd19 = ArmAddrTraits<AddrType,
-                                          ADDR_IMMD19,
-                                          uint32_t,
-                                          FetchCode32,
-                                          StoreCode32,
-                                          DecodeImmd19,
-                                          EncodeImmd19,
-                                          ReadImmd19,
-                                          WriteImmd19>;
-  using AddrTraits_Immd26 = ArmAddrTraits<AddrType,
-                                          ADDR_IMMD26,
-                                          uint32_t,
-                                          FetchCode32,
-                                          StoreCode32,
-                                          DecodeImmd26,
-                                          EncodeImmd26,
-                                          ReadImmd26,
-                                          WriteImmd26>;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_ARM_UTILS_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_sink.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_sink.h
deleted file mode 100644
index 24798af..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_sink.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_BUFFER_SINK_H_
-#define COMPONENTS_ZUCCHINI_BUFFER_SINK_H_
-
-#include <stdint.h>
-
-#include <algorithm>
-#include <iterator>
-
-#include "base/check_op.h"
-#include "components/zucchini/buffer_view.h"
-
-namespace zucchini {
-
-// BufferSink acts like an output stream with convenience methods to serialize
-// data into a contiguous sequence of raw data. The underlying MutableBufferView
-// emulates a cursor to track current write position, and guards against buffer
-// overrun. Where applicable, BufferSink should be passed by pointer to maintain
-// cursor progress across writes.
-class BufferSink : public MutableBufferView {
- public:
-  using iterator = MutableBufferView::iterator;
-
-  using MutableBufferView::MutableBufferView;
-  BufferSink() = default;
-  explicit BufferSink(MutableBufferView buffer);
-  BufferSink(const BufferSink&) = default;
-  BufferSink& operator=(BufferSink&&) = default;
-
-  // If sufficient space is available, writes the binary representation of
-  // |value| starting at the cursor, while advancing the cursor beyond the
-  // written region, and returns true. Otherwise returns false.
-  template <class T>
-  bool PutValue(const T& value) {
-    DCHECK_NE(begin(), nullptr);
-    if (Remaining() < sizeof(T))
-      return false;
-    *reinterpret_cast<T*>(begin()) = value;
-    remove_prefix(sizeof(T));
-    return true;
-  }
-
-  // If sufficient space is available, writes the raw bytes [|first|, |last|)
-  // starting at the cursor, while advancing the cursor beyond the written
-  // region, and returns true. Otherwise returns false.
-  template <class It>
-  bool PutRange(It first, It last) {
-    static_assert(sizeof(typename std::iterator_traits<It>::value_type) ==
-                      sizeof(uint8_t),
-                  "value_type should fit in uint8_t");
-    DCHECK_NE(begin(), nullptr);
-    DCHECK(last >= first);
-    if (Remaining() < size_type(last - first))
-      return false;
-    std::copy(first, last, begin());
-    remove_prefix(last - first);
-    return true;
-  }
-
-  size_type Remaining() const { return size(); }
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_BUFFER_SINK_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_source.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_source.h
deleted file mode 100644
index 7426d4e..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_source.h
+++ /dev/null
@@ -1,141 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_BUFFER_SOURCE_H_
-#define COMPONENTS_ZUCCHINI_BUFFER_SOURCE_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <initializer_list>
-#include <type_traits>
-
-#include "base/check_op.h"
-#include "components/zucchini/buffer_view.h"
-
-namespace zucchini {
-
-// BufferSource acts like an input stream with convenience methods to parse data
-// from a contiguous sequence of raw data. The underlying ConstBufferView
-// emulates a cursor to track current read position, and guards against buffer
-// overrun. Where applicable, BufferSource should be passed by pointer to
-// maintain cursor progress across reads.
-class BufferSource : public ConstBufferView {
- public:
-  // LEB128 info: http://dwarfstd.org/doc/dwarf-2.0.0.pdf , Section 7.6.
-  enum : size_t { kMaxLeb128Size = 5 };
-
-  static BufferSource FromRange(const_iterator first, const_iterator last) {
-    return BufferSource(ConstBufferView::FromRange(first, last));
-  }
-
-  using ConstBufferView::ConstBufferView;
-  BufferSource() = default;
-  explicit BufferSource(ConstBufferView buffer);
-  BufferSource(const BufferSource&) = default;
-  BufferSource& operator=(BufferSource&&) = default;
-
-  // Moves the cursor forward by |n| bytes, or to the end if data is exhausted.
-  // Returns a reference to *this, to allow chaining, e.g.:
-  //   if (!buffer_source.Skip(1024).GetValue<uint32_t>(&value)) {
-  //      ... // Handle error.
-  //   }
-  // Notice that Skip() defers error handling to GetValue().
-  BufferSource& Skip(size_type n);
-
-  // Returns true if |value| matches data starting at the cursor when
-  // reinterpreted as the integral type |T|.
-  template <class T>
-  bool CheckNextValue(const T& value) const {
-    static_assert(std::is_integral<T>::value,
-                  "Value type must be an integral type");
-    DCHECK_NE(begin(), nullptr);
-    if (Remaining() < sizeof(T))
-      return false;
-    return value == *reinterpret_cast<const T*>(begin());
-  }
-
-  // Returns true if the next bytes.size() bytes at the cursor match those in
-  // |bytes|.
-  bool CheckNextBytes(std::initializer_list<uint8_t> bytes) const;
-
-  // Same as CheckNextBytes(), but moves the cursor by bytes.size() if read is
-  // successfull.
-  bool ConsumeBytes(std::initializer_list<uint8_t> bytes);
-
-  // Tries to reinterpret data as type |T|, starting at the cursor and to write
-  // the result into |value|, while moving the cursor forward by sizeof(T).
-  // Returns true if sufficient data is available, and false otherwise.
-  template <class T>
-  bool GetValue(T* value) {
-    static_assert(std::is_standard_layout<T>::value,
-                  "Value type must be a standard layout type");
-
-    DCHECK_NE(begin(), nullptr);
-    if (Remaining() < sizeof(T))
-      return false;
-    *value = *reinterpret_cast<const T*>(begin());
-    remove_prefix(sizeof(T));
-    return true;
-  }
-
-  // Tries to reinterpret data as type |T| at the cursor and to return a
-  // reinterpreted pointer of type |T| pointing into the underlying data, while
-  // moving the cursor forward by sizeof(T). Returns nullptr if insufficient
-  // data is available.
-  template <class T>
-  const T* GetPointer() {
-    static_assert(std::is_standard_layout<T>::value,
-                  "Value type must be a standard layout type");
-
-    DCHECK_NE(begin(), nullptr);
-    if (Remaining() < sizeof(T))
-      return nullptr;
-    const T* ptr = reinterpret_cast<const T*>(begin());
-    remove_prefix(sizeof(T));
-    return ptr;
-  }
-
-  // Tries to reinterpret data as an array of type |T| with |count| elements,
-  // starting at the cursor, and to return a reinterpreted pointer of type |T|
-  // pointing into the underlying data, while advancing the cursor beyond the
-  // array. Returns nullptr if insufficient data is available.
-  template <class T>
-  const T* GetArray(size_t count) {
-    static_assert(std::is_standard_layout<T>::value,
-                  "Value type must be a standard layout type");
-
-    if (Remaining() / sizeof(T) < count)
-      return nullptr;
-    const T* array = reinterpret_cast<const T*>(begin());
-    remove_prefix(count * sizeof(T));
-    return array;
-  }
-
-  // If sufficient data is available, assigns |buffer| to point to a region of
-  // |size| bytes starting at the cursor, while advancing the cursor beyond the
-  // region, and returns true. Otherwise returns false.
-  bool GetRegion(size_type size, ConstBufferView* buffer);
-
-  // Reads an Unsigned Little Endian Base 128 (uleb128) int at |first_|. If
-  // successful, writes the result to |value|, advances |first_|, and returns
-  // true. Otherwise returns false.
-  bool GetUleb128(uint32_t* value);
-
-  // Reads a Signed Little Endian Base 128 (sleb128) int at |first_|. If
-  // successful, writes the result to |value|, advances |first_|, and returns
-  // true. Otherwise returns false.
-  bool GetSleb128(int32_t* value);
-
-  // Reads uleb128 / sleb128 at |first_| but discards the result. If successful,
-  // advances |first_| and returns true. Otherwise returns false.
-  bool SkipLeb128();
-
-  // Returns the number of bytes remaining from cursor until end.
-  size_type Remaining() const { return size(); }
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_BUFFER_SOURCE_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_view.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_view.h
deleted file mode 100644
index 661e3c3..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/buffer_view.h
+++ /dev/null
@@ -1,217 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_BUFFER_VIEW_H_
-#define COMPONENTS_ZUCCHINI_BUFFER_VIEW_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <algorithm>
-#include <type_traits>
-
-#include "base/check_op.h"
-#include "components/zucchini/algorithm.h"
-
-namespace zucchini {
-
-// Describes a region within a buffer, with starting offset and size.
-struct BufferRegion {
-  // The region data are stored as |offset| and |size|, but often it is useful
-  // to represent it as an interval [lo(), hi()) = [offset, offset + size).
-  size_t lo() const { return offset; }
-  size_t hi() const { return offset + size; }
-
-  // Returns whether the Region fits in |[0, container_size)|. Special case:
-  // a size-0 region starting at |container_size| fits.
-  bool FitsIn(size_t container_size) const {
-    return offset <= container_size && container_size - offset >= size;
-  }
-
-  // Returns |v| clipped to the inclusive range |[lo(), hi()]|.
-  size_t InclusiveClamp(size_t v) const {
-    return zucchini::InclusiveClamp(v, lo(), hi());
-  }
-
-  // Region data use size_t to match BufferViewBase::size_type, to make it
-  // convenient to index into buffer view.
-  size_t offset;
-  size_t size;
-};
-
-namespace internal {
-
-// TODO(huangs): Rename to BasicBufferView.
-// BufferViewBase should not be used directly; it is an implementation used for
-// both BufferView and MutableBufferView.
-template <class T>
-class BufferViewBase {
- public:
-  using value_type = T;
-  using reference = T&;
-  using pointer = T*;
-  using iterator = T*;
-  using const_iterator = typename std::add_const<T>::type*;
-  using size_type = std::size_t;
-  using difference_type = std::ptrdiff_t;
-
-  static BufferViewBase FromRange(iterator first, iterator last) {
-    DCHECK_GE(last, first);
-    BufferViewBase ret;
-    ret.first_ = first;
-    ret.last_ = last;
-    return ret;
-  }
-
-  BufferViewBase() = default;
-
-  BufferViewBase(iterator first, size_type size)
-      : first_(first), last_(first_ + size) {
-    DCHECK_GE(last_, first_);
-  }
-
-  template <class U>
-  BufferViewBase(const BufferViewBase<U>& that)
-      : first_(that.begin()), last_(that.end()) {}
-
-  template <class U>
-  BufferViewBase(BufferViewBase<U>&& that)
-      : first_(that.begin()), last_(that.end()) {}
-
-  BufferViewBase(const BufferViewBase&) = default;
-  BufferViewBase& operator=(const BufferViewBase&) = default;
-
-  // Iterators
-
-  iterator begin() const { return first_; }
-  iterator end() const { return last_; }
-  const_iterator cbegin() const { return begin(); }
-  const_iterator cend() const { return end(); }
-
-  // Capacity
-
-  bool empty() const { return first_ == last_; }
-  size_type size() const { return last_ - first_; }
-
-  // Returns whether the buffer is large enough to cover |region|.
-  bool covers(const BufferRegion& region) const {
-    return region.FitsIn(size());
-  }
-
-  // Returns whether the buffer is large enough to cover an array starting at
-  // |offset| with |num| elements, each taking |elt_size| bytes.
-  bool covers_array(size_t offset, size_t num, size_t elt_size) {
-    DCHECK_GT(elt_size, 0U);
-    // Use subtraction and division to avoid overflow.
-    return offset <= size() && (size() - offset) / elt_size >= num;
-  }
-
-  // Element access
-
-  // Returns the raw value at specified location |pos|.
-  // If |pos| is not within the range of the buffer, the process is terminated.
-  reference operator[](size_type pos) const {
-    CHECK_LT(pos, size());
-    return first_[pos];
-  }
-
-  // Returns a sub-buffer described by |region|.
-  BufferViewBase operator[](BufferRegion region) const {
-    DCHECK_LE(region.offset, size());
-    DCHECK_LE(region.size, size() - region.offset);
-    return {begin() + region.offset, region.size};
-  }
-
-  template <class U>
-  const U& read(size_type pos) const {
-    // TODO(huangs): Use can_access<U>(pos) after fixing can_access().
-    CHECK_LE(sizeof(U), size());
-    CHECK_LE(pos, size() - sizeof(U));
-    return *reinterpret_cast<const U*>(begin() + pos);
-  }
-
-  template <class U>
-  void write(size_type pos, const U& value) {
-    // TODO(huangs): Use can_access<U>(pos) after fixing can_access().
-    CHECK_LE(sizeof(U), size());
-    CHECK_LE(pos, size() - sizeof(U));
-    *reinterpret_cast<U*>(begin() + pos) = value;
-  }
-
-  // Returns a mutable reference to an object type U whose raw storage starts
-  // at location |pos|.
-  template <class U>
-  U& modify(size_type pos) {
-    // TODO(huangs): Use can_access<U>(pos) after fixing can_access().
-    CHECK_LE(sizeof(U), size());
-    CHECK_LE(pos, size() - sizeof(U));
-    return *reinterpret_cast<U*>(begin() + pos);
-  }
-
-  template <class U>
-  bool can_access(size_type pos) const {
-    return pos < size() && size() - pos >= sizeof(U);
-  }
-
-  // Returns a BufferRegion describing the full view, with offset = 0. If the
-  // BufferViewBase is derived from another, this does *not* return the
-  // original region used for its definition (hence "local").
-  BufferRegion local_region() const { return BufferRegion{0, size()}; }
-
-  bool equals(BufferViewBase other) const {
-    return size() == other.size() && std::equal(begin(), end(), other.begin());
-  }
-
-  // Modifiers
-
-  void shrink(size_type new_size) {
-    DCHECK_LE(first_ + new_size, last_);
-    last_ = first_ + new_size;
-  }
-
-  // Moves the start of the view forward by n bytes.
-  void remove_prefix(size_type n) {
-    DCHECK_LE(n, size());
-    first_ += n;
-  }
-
-  // Moves the start of the view to |it|, which is in range [begin(), end()).
-  void seek(iterator it) {
-    DCHECK_GE(it, begin());
-    DCHECK_LE(it, end());
-    first_ = it;
-  }
-
-  // Given |origin| that contains |*this|, minimally increase |first_| (possibly
-  // by 0) so that |first_ <= last_|, and |first_ - origin.first_| is a multiple
-  // of |alignment|. On success, updates |first_| and returns true. Otherwise
-  // returns false.
-  bool AlignOn(BufferViewBase origin, size_type alignment) {
-    DCHECK_GT(alignment, 0U);
-    DCHECK_LE(origin.first_, first_);
-    DCHECK_GE(origin.last_, last_);
-    size_type aligned_size =
-        AlignCeil(static_cast<size_type>(first_ - origin.first_), alignment);
-    if (aligned_size > static_cast<size_type>(last_ - origin.first_))
-      return false;
-    first_ = origin.first_ + aligned_size;
-    return true;
-  }
-
- private:
-  iterator first_ = nullptr;
-  iterator last_ = nullptr;
-};
-
-}  // namespace internal
-
-// Classes to encapsulate a contiguous sequence of raw data, without owning the
-// encapsulated memory regions. These are intended to be used as value types.
-
-using ConstBufferView = internal::BufferViewBase<const uint8_t>;
-using MutableBufferView = internal::BufferViewBase<uint8_t>;
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_BUFFER_VIEW_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/crc32.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/crc32.h
deleted file mode 100644
index c729f5b..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/crc32.h
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_CRC32_H_
-#define COMPONENTS_ZUCCHINI_CRC32_H_
-
-#include <stdint.h>
-
-namespace zucchini {
-
-// Calculates CRC-32 of the given range [|first|, |last|).
-uint32_t CalculateCrc32(const uint8_t* first, const uint8_t* last);
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_CRC32_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler.h
deleted file mode 100644
index 7ec739b..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler.h
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_DISASSEMBLER_H_
-#define COMPONENTS_ZUCCHINI_DISASSEMBLER_H_
-
-#include <stddef.h>
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/image_utils.h"
-
-namespace zucchini {
-
-// A vacuous ReferenceReader that produces no references.
-class EmptyReferenceReader : public ReferenceReader {
- public:
-  std::optional<Reference> GetNext() override;
-};
-
-// A vacuous EmptyReferenceWriter that does not write.
-class EmptyReferenceWriter : public ReferenceWriter {
- public:
-  void PutNext(Reference reference) override;
-};
-
-// Disassembler needs to be declared before ReferenceGroup because the latter
-// contains member pointers based on the former, and we use a compiler flag,
-// -fcomplete-member-pointers, which enforces that member pointer base types are
-// complete. This flag helps prevent us from running into problems in the
-// Microsoft C++ ABI (see https://crbug.com/847724).
-
-class ReferenceGroup;
-
-// A Disassembler is used to encapsulate architecture specific operations, to:
-// - Describe types of references found in the architecture using traits.
-// - Extract references contained in an image file.
-// - Correct target for some references.
-class Disassembler {
- public:
-  // Attempts to parse |image| and create an architecture-specifc Disassembler,
-  // as determined by DIS, which is inherited from Disassembler. Returns an
-  // instance of DIS if successful, and null otherwise.
-  template <class DIS>
-  static std::unique_ptr<DIS> Make(ConstBufferView image) {
-    auto disasm = std::make_unique<DIS>();
-    if (!disasm->Parse(image))
-      return nullptr;
-    return disasm;
-  }
-
-  Disassembler(const Disassembler&) = delete;
-  const Disassembler& operator=(const Disassembler&) = delete;
-  virtual ~Disassembler();
-
-  // Returns the type of executable handled by the Disassembler.
-  virtual ExecutableType GetExeType() const = 0;
-
-  // Returns a more detailed description of the executable type.
-  virtual std::string GetExeTypeString() const = 0;
-
-  // Creates and returns a vector that contains all groups of references.
-  // Groups must be aggregated by pool.
-  virtual std::vector<ReferenceGroup> MakeReferenceGroups() const = 0;
-
-  ConstBufferView image() const { return image_; }
-  size_t size() const { return image_.size(); }
-
-  int num_equivalence_iterations() const { return num_equivalence_iterations_; }
-
- protected:
-  explicit Disassembler(int num_equivalence_iterations);
-
-  // Parses |image| and initializes internal states. Returns true on success.
-  // This must be called once and before any other operation.
-  virtual bool Parse(ConstBufferView image) = 0;
-
-  // Raw image data. After Parse(), a Disassembler should shrink this to contain
-  // only the portion containing the executable file it recognizes.
-  ConstBufferView image_;
-
-  // The number of iterations to run for equivalence map generation. This should
-  // roughly be the max length of reference indirection chains.
-  int num_equivalence_iterations_;
-};
-
-// A ReferenceGroup is associated with a specific |type| and has convenience
-// methods to obtain readers and writers for that type. A ReferenceGroup does
-// not store references; it is a lightweight class that communicates with the
-// disassembler to operate on them.
-class ReferenceGroup {
- public:
-  // Member function pointer used to obtain a ReferenceReader.
-  using ReaderFactory = std::unique_ptr<ReferenceReader> (
-      Disassembler::*)(offset_t lower, offset_t upper);
-
-  // Member function pointer used to obtain a ReferenceWriter.
-  using WriterFactory = std::unique_ptr<ReferenceWriter> (Disassembler::*)(
-      MutableBufferView image);
-
-  // RefinedGeneratorFactory and RefinedReceptorFactory don't have to be
-  // identical to GeneratorFactory and ReceptorFactory, but they must be
-  // convertible. As a result, they can be pointer to member function of a
-  // derived Disassembler.
-  template <class RefinedReaderFactory, class RefinedWriterFactory>
-  ReferenceGroup(ReferenceTypeTraits traits,
-                 RefinedReaderFactory reader_factory,
-                 RefinedWriterFactory writer_factory)
-      : traits_(traits),
-        reader_factory_(static_cast<ReaderFactory>(reader_factory)),
-        writer_factory_(static_cast<WriterFactory>(writer_factory)) {}
-
-  // Returns a reader for all references in the binary.
-  // Invalidates any other writer or reader previously obtained for |disasm|.
-  std::unique_ptr<ReferenceReader> GetReader(Disassembler* disasm) const;
-
-  // Returns a reader for references whose bytes are entirely contained in
-  // |[lower, upper)|.
-  // Invalidates any other writer or reader previously obtained for |disasm|.
-  std::unique_ptr<ReferenceReader> GetReader(offset_t lower,
-                                             offset_t upper,
-                                             Disassembler* disasm) const;
-
-  // Returns a writer for references in |image|, assuming that |image| was the
-  // same one initially parsed by |disasm|.
-  // Invalidates any other writer or reader previously obtained for |disasm|.
-  std::unique_ptr<ReferenceWriter> GetWriter(MutableBufferView image,
-                                             Disassembler* disasm) const;
-
-  // Returns traits describing the reference type.
-  const ReferenceTypeTraits& traits() const { return traits_; }
-
-  // Shorthand for traits().width.
-  offset_t width() const { return traits().width; }
-
-  // Shorthand for traits().type_tag.
-  TypeTag type_tag() const { return traits().type_tag; }
-
-  // Shorthand for traits().pool_tag.
-  PoolTag pool_tag() const { return traits().pool_tag; }
-
- private:
-  ReferenceTypeTraits traits_;
-  ReaderFactory reader_factory_ = nullptr;
-  WriterFactory writer_factory_ = nullptr;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_DISASSEMBLER_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_dex.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_dex.h
deleted file mode 100644
index d9d93b2..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_dex.h
+++ /dev/null
@@ -1,295 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_DISASSEMBLER_DEX_H_
-#define COMPONENTS_ZUCCHINI_DISASSEMBLER_DEX_H_
-
-#include <stdint.h>
-
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "components/zucchini/disassembler.h"
-#include "components/zucchini/image_utils.h"
-#include "components/zucchini/type_dex.h"
-
-namespace zucchini {
-
-// For consistency, let "canonical order" of DEX data types be the order defined
-// in https://source.android.com/devices/tech/dalvik/dex-format "Type Codes"
-// section.
-
-class DisassemblerDex : public Disassembler {
- public:
-  static constexpr uint16_t kVersion = 1;
-  // Pools follow canonical order.
-  enum ReferencePool : uint8_t {
-    kStringId,
-    kTypeId,
-    kProtoId,
-    kFieldId,
-    kMethodId,
-    // kClassDef,  // Unused
-    kCallSiteId,
-    kMethodHandle,
-    kTypeList,
-    kAnnotationSetRefList,
-    kAnnotionSet,
-    kClassData,
-    kCode,
-    kStringData,
-    kAnnotation,
-    kEncodedArray,
-    kAnnotationsDirectory,
-    kCallSite,
-    kNumPools
-  };
-
-  // Types are grouped and ordered by target ReferencePool. This is required by
-  // Zucchini-apply, which visits references by type order and sequentially
-  // handles pools in the same order. Type-pool association is established in
-  // MakeReferenceGroups(), and verified by a unit test.
-  enum ReferenceType : uint8_t {
-    kTypeIdToDescriptorStringId,  // kStringId
-    kProtoIdToShortyStringId,
-    kFieldIdToNameStringId,
-    kMethodIdToNameStringId,
-    kClassDefToSourceFileStringId,
-    kCodeToStringId16,
-    kCodeToStringId32,
-
-    kProtoIdToReturnTypeId,  // kTypeId
-    kFieldIdToClassTypeId,
-    kFieldIdToTypeId,
-    kMethodIdToClassTypeId,
-    kClassDefToClassTypeId,
-    kClassDefToSuperClassTypeId,
-    kTypeListToTypeId,
-    kCodeToTypeId,
-
-    kCodeToProtoId,  // kProtoId
-    kMethodIdToProtoId,
-
-    kCodeToFieldId,  // kFieldId
-    kMethodHandleToFieldId,
-    kAnnotationsDirectoryToFieldId,
-
-    kCodeToMethodId,  // kMethodId
-    kMethodHandleToMethodId,
-    kAnnotationsDirectoryToMethodId,
-    kAnnotationsDirectoryToParameterMethodId,
-
-    kCodeToCallSiteId,  // kCallSiteId
-
-    kCodeToMethodHandle,  // kMethodHandle
-
-    kProtoIdToParametersTypeList,  // kTypeList
-    kClassDefToInterfacesTypeList,
-
-    kAnnotationsDirectoryToParameterAnnotationSetRef,  // kAnnotationSetRef,
-
-    kAnnotationSetRefListToAnnotationSet,  // kAnnotationSet,
-    kAnnotationsDirectoryToClassAnnotationSet,
-    kAnnotationsDirectoryToFieldAnnotationSet,
-    kAnnotationsDirectoryToMethodAnnotationSet,
-
-    kClassDefToClassData,  // kClassData
-
-    kCodeToRelCode8,  // kCode
-    kCodeToRelCode16,
-    kCodeToRelCode32,
-
-    kStringIdToStringData,  // kStringData
-
-    kAnnotationSetToAnnotation,  // kAnnotation
-
-    kClassDefToStaticValuesEncodedArray,  // kEncodedArrayItem
-
-    kClassDefToAnnotationDirectory,  // kAnnotationsDirectory
-
-    kCallSiteIdToCallSite,  // kCallSite
-
-    kNumTypes
-  };
-
-  DisassemblerDex();
-  DisassemblerDex(const DisassemblerDex&) = delete;
-  const DisassemblerDex& operator=(const DisassemblerDex&) = delete;
-  ~DisassemblerDex() override;
-
-  // Applies quick checks to determine if |image| *may* point to the start of an
-  // executable. Returns true on success.
-  static bool QuickDetect(ConstBufferView image);
-
-  // Disassembler:
-  ExecutableType GetExeType() const override;
-  std::string GetExeTypeString() const override;
-  std::vector<ReferenceGroup> MakeReferenceGroups() const override;
-
-  // Functions that return reference readers. These follow canonical order of
-  // *locations* (unlike targets for ReferenceType). This allows functions with
-  // similar parsing logic to appear togeter.
-  std::unique_ptr<ReferenceReader> MakeReadStringIdToStringData(offset_t lo,
-                                                                offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadTypeIdToDescriptorStringId32(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadProtoIdToShortyStringId32(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadProtoIdToReturnTypeId32(offset_t lo,
-                                                                   offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadProtoIdToParametersTypeList(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadFieldToClassTypeId16(offset_t lo,
-                                                                offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadFieldToTypeId16(offset_t lo,
-                                                           offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadFieldToNameStringId32(offset_t lo,
-                                                                 offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadMethodIdToClassTypeId16(offset_t lo,
-                                                                   offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadMethodIdToProtoId16(offset_t lo,
-                                                               offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadMethodIdToNameStringId32(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadClassDefToClassTypeId32(offset_t lo,
-                                                                   offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadClassDefToSuperClassTypeId32(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadClassDefToInterfacesTypeList(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadClassDefToSourceFileStringId32(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadClassDefToAnnotationDirectory(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadClassDefToClassData(offset_t lo,
-                                                               offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadClassDefToStaticValuesEncodedArray(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadCallSiteIdToCallSite32(offset_t lo,
-                                                                  offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadMethodHandleToFieldId16(offset_t lo,
-                                                                   offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadMethodHandleToMethodId16(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadTypeListToTypeId16(offset_t lo,
-                                                              offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadAnnotationSetToAnnotation(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadAnnotationSetRefListToAnnotationSet(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader>
-  MakeReadAnnotationsDirectoryToClassAnnotationSet(offset_t lo, offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadAnnotationsDirectoryToFieldId32(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader>
-  MakeReadAnnotationsDirectoryToFieldAnnotationSet(offset_t lo, offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadAnnotationsDirectoryToMethodId32(
-      offset_t lo,
-      offset_t hi);
-  std::unique_ptr<ReferenceReader>
-  MakeReadAnnotationsDirectoryToMethodAnnotationSet(offset_t lo, offset_t hi);
-  std::unique_ptr<ReferenceReader>
-  MakeReadAnnotationsDirectoryToParameterMethodId32(offset_t lo, offset_t hi);
-  std::unique_ptr<ReferenceReader>
-  MakeReadAnnotationsDirectoryToParameterAnnotationSetRef(offset_t lo,
-                                                          offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadCodeToStringId16(offset_t lo,
-                                                            offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadCodeToStringId32(offset_t lo,
-                                                            offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadCodeToTypeId16(offset_t lo,
-                                                          offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadCodeToProtoId16(offset_t lo,
-                                                           offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadCodeToFieldId16(offset_t lo,
-                                                           offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadCodeToMethodId16(offset_t lo,
-                                                            offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadCodeToCallSiteId16(offset_t lo,
-                                                              offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadCodeToMethodHandle16(offset_t lo,
-                                                                offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadCodeToRelCode8(offset_t lo,
-                                                          offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadCodeToRelCode16(offset_t lo,
-                                                           offset_t hi);
-  std::unique_ptr<ReferenceReader> MakeReadCodeToRelCode32(offset_t lo,
-                                                           offset_t hi);
-
-  // Functions that return reference writers. Different readers may share a
-  // common writer. Therefore these loosely follow canonical order of locations,
-  std::unique_ptr<ReferenceWriter> MakeWriteStringId16(MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteStringId32(MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteTypeId16(MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteTypeId32(MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteProtoId16(MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteFieldId16(MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteFieldId32(MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteMethodId16(MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteMethodId32(MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteCallSiteId16(
-      MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteMethodHandle16(
-      MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteRelCode8(MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteRelCode16(MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteRelCode32(MutableBufferView image);
-  std::unique_ptr<ReferenceWriter> MakeWriteAbs32(MutableBufferView image);
-
- private:
-  friend Disassembler;
-  using MapItemMap = std::map<uint16_t, const dex::MapItem*>;
-
-  // Disassembler:
-  bool Parse(ConstBufferView image) override;
-
-  bool ParseHeader();
-
-  const dex::HeaderItem* header_ = nullptr;
-  int dex_version_ = 0;
-  MapItemMap map_item_map_ = {};
-  dex::MapItem string_map_item_ = {};
-  dex::MapItem type_map_item_ = {};
-  dex::MapItem proto_map_item_ = {};
-  dex::MapItem field_map_item_ = {};
-  dex::MapItem method_map_item_ = {};
-  dex::MapItem class_def_map_item_ = {};
-  dex::MapItem call_site_map_item_ = {};
-  dex::MapItem method_handle_map_item_ = {};
-  dex::MapItem type_list_map_item_ = {};
-  dex::MapItem annotation_set_ref_list_map_item_ = {};
-  dex::MapItem annotation_set_map_item_ = {};
-  dex::MapItem code_map_item_ = {};
-  dex::MapItem annotations_directory_map_item_ = {};
-
-  // Sorted list of offsets of parsed items in |image_|.
-  std::vector<offset_t> code_item_offsets_;
-  std::vector<offset_t> type_list_offsets_;
-  std::vector<offset_t> annotation_set_ref_list_offsets_;
-  std::vector<offset_t> annotation_set_offsets_;
-  std::vector<offset_t> annotations_directory_item_offsets_;
-  std::vector<offset_t> annotations_directory_item_field_annotation_offsets_;
-  std::vector<offset_t> annotations_directory_item_method_annotation_offsets_;
-  std::vector<offset_t>
-      annotations_directory_item_parameter_annotation_offsets_;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_DISASSEMBLER_DEX_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_elf.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_elf.h
deleted file mode 100644
index 353c444..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_elf.h
+++ /dev/null
@@ -1,356 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_DISASSEMBLER_ELF_H_
-#define COMPONENTS_ZUCCHINI_DISASSEMBLER_ELF_H_
-
-#include <stdint.h>
-
-#include <algorithm>
-#include <deque>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "components/zucchini/address_translator.h"
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/disassembler.h"
-#include "components/zucchini/image_utils.h"
-#include "components/zucchini/rel32_finder.h"
-#include "components/zucchini/rel32_utils.h"
-#include "components/zucchini/reloc_elf.h"
-#include "components/zucchini/type_elf.h"
-
-namespace zucchini {
-
-struct ArmReferencePool {
-  enum : uint8_t {
-    kPoolReloc,
-    kPoolAbs32,
-    kPoolRel32,
-  };
-};
-
-struct AArch32ReferenceType {
-  enum : uint8_t {
-    kReloc,  // kPoolReloc
-
-    kAbs32,  // kPoolAbs32
-
-    kRel32_A24,  // kPoolRel32
-    kRel32_T8,
-    kRel32_T11,
-    kRel32_T20,
-    kRel32_T24,
-
-    kTypeCount
-  };
-};
-
-struct AArch64ReferenceType {
-  enum : uint8_t {
-    kReloc,  // kPoolReloc
-
-    kAbs32,  // kPoolAbs32
-
-    kRel32_Immd14,  // kPoolRel32
-    kRel32_Immd19,
-    kRel32_Immd26,
-
-    kTypeCount
-  };
-};
-
-struct Elf32Traits {
-  static constexpr uint16_t kVersion = 1;
-  static constexpr Bitness kBitness = kBit32;
-  static constexpr elf::FileClass kIdentificationClass = elf::ELFCLASS32;
-  using Elf_Shdr = elf::Elf32_Shdr;
-  using Elf_Phdr = elf::Elf32_Phdr;
-  using Elf_Ehdr = elf::Elf32_Ehdr;
-  using Elf_Rel = elf::Elf32_Rel;
-  using Elf_Rela = elf::Elf32_Rela;
-};
-
-// Architecture-specific definitions.
-
-struct Elf32IntelTraits : public Elf32Traits {
-  static constexpr ExecutableType kExeType = kExeTypeElfX86;
-  static const char kExeTypeString[];
-  static constexpr elf::MachineArchitecture kMachineValue = elf::EM_386;
-  static constexpr uint32_t kRelType = elf::R_386_RELATIVE;
-  enum : uint32_t { kVAWidth = 4 };
-  using Rel32FinderUse = Rel32FinderX86;
-};
-
-struct ElfAArch32Traits : public Elf32Traits {
-  static constexpr ExecutableType kExeType = kExeTypeElfAArch32;
-  static const char kExeTypeString[];
-  static constexpr elf::MachineArchitecture kMachineValue = elf::EM_ARM;
-  static constexpr uint32_t kRelType = elf::R_ARM_RELATIVE;
-  enum : uint32_t { kVAWidth = 4 };
-  using ArmReferenceType = AArch32ReferenceType;
-  using Rel32FinderUse = Rel32FinderAArch32;
-};
-
-struct Elf64Traits {
-  static constexpr uint16_t kVersion = 1;
-  static constexpr Bitness kBitness = kBit64;
-  static constexpr elf::FileClass kIdentificationClass = elf::ELFCLASS64;
-  using Elf_Shdr = elf::Elf64_Shdr;
-  using Elf_Phdr = elf::Elf64_Phdr;
-  using Elf_Ehdr = elf::Elf64_Ehdr;
-  using Elf_Rel = elf::Elf64_Rel;
-  using Elf_Rela = elf::Elf64_Rela;
-};
-
-// Architecture-specific definitions.
-struct Elf64IntelTraits : public Elf64Traits {
-  static constexpr ExecutableType kExeType = kExeTypeElfX64;
-  static const char kExeTypeString[];
-  static constexpr elf::MachineArchitecture kMachineValue = elf::EM_X86_64;
-  static constexpr uint32_t kRelType = elf::R_X86_64_RELATIVE;
-  enum : uint32_t { kVAWidth = 8 };
-  using Rel32FinderUse = Rel32FinderX64;
-};
-
-struct ElfAArch64Traits : public Elf64Traits {
-  static constexpr ExecutableType kExeType = kExeTypeElfAArch64;
-  static const char kExeTypeString[];
-  static constexpr elf::MachineArchitecture kMachineValue = elf::EM_AARCH64;
-  // TODO(huangs): See if R_AARCH64_GLOB_DAT and R_AARCH64_JUMP_SLOT should be
-  // used.
-  static constexpr uint32_t kRelType = elf::R_AARCH64_RELATIVE;
-  enum : uint32_t { kVAWidth = 8 };
-  using ArmReferenceType = AArch64ReferenceType;
-  using Rel32FinderUse = Rel32FinderAArch64;
-};
-
-// Decides whether target |offset| is covered by a section in |sorted_headers|.
-template <class ELF_SHDR>
-bool IsTargetOffsetInElfSectionList(
-    const std::vector<const ELF_SHDR*>& sorted_headers,
-    offset_t offset) {
-  // Use binary search to search in a list of intervals, in a fashion similar to
-  // AddressTranslator::OffsetToUnit().
-  auto comp = [](offset_t offset, const ELF_SHDR* header) -> bool {
-    return offset < header->sh_offset;
-  };
-  auto it = std::upper_bound(sorted_headers.begin(), sorted_headers.end(),
-                             offset, comp);
-  if (it == sorted_headers.begin())
-    return false;
-  --it;
-  // Just check offset without worrying about width, since this is a target.
-  // Not using RangeCovers() because |sh_offset| and |sh_size| can be 64-bit.
-  return offset >= (*it)->sh_offset &&
-         offset - (*it)->sh_offset < (*it)->sh_size;
-}
-
-// Disassembler for ELF.
-template <class TRAITS>
-class DisassemblerElf : public Disassembler {
- public:
-  using Traits = TRAITS;
-  static constexpr uint16_t kVersion = Traits::kVersion;
-  // Applies quick checks to determine whether |image| *may* point to the start
-  // of an executable. Returns true iff the check passes.
-  static bool QuickDetect(ConstBufferView image);
-
-  DisassemblerElf(const DisassemblerElf&) = delete;
-  const DisassemblerElf& operator=(const DisassemblerElf&) = delete;
-  ~DisassemblerElf() override;
-
-  // Disassembler:
-  ExecutableType GetExeType() const override;
-  std::string GetExeTypeString() const override;
-  std::vector<ReferenceGroup> MakeReferenceGroups() const override = 0;
-
-  // Read/Write functions that are common among different architectures.
-  std::unique_ptr<ReferenceReader> MakeReadRelocs(offset_t lo, offset_t hi);
-  std::unique_ptr<ReferenceWriter> MakeWriteRelocs(MutableBufferView image);
-
-  const AddressTranslator& translator() const { return translator_; }
-
- protected:
-  friend Disassembler;
-
-  DisassemblerElf();
-
-  bool Parse(ConstBufferView image) override;
-
-  // Returns the supported Elf_Ehdr::e_machine enum.
-  static constexpr elf::MachineArchitecture supported_architecture() {
-    return Traits::kMachineValue;
-  }
-
-  // Returns the type to look for in the reloc section.
-  static constexpr uint32_t supported_relocation_type() {
-    return Traits::kRelType;
-  }
-
-  // Performs architecture-specific parsing of an executable section, to extract
-  // rel32 references.
-  virtual void ParseExecSection(const typename Traits::Elf_Shdr& section) = 0;
-
-  // Processes rel32 data after they are extracted from executable sections.
-  virtual void PostProcessRel32() = 0;
-
-  // Parses ELF header and section headers, and performs basic validation.
-  // Returns whether parsing was successful.
-  bool ParseHeader();
-
-  // Extracts and stores section headers that we need.
-  void ExtractInterestingSectionHeaders();
-
-  // Parsing functions that extract references from various sections.
-  void GetAbs32FromRelocSections();
-  void GetRel32FromCodeSections();
-  void ParseSections();
-
-  // Main ELF header.
-  const typename Traits::Elf_Ehdr* header_ = nullptr;
-
-  // Section header table, ordered by section id.
-  elf::Elf32_Half sections_count_ = 0;
-  const typename Traits::Elf_Shdr* sections_ = nullptr;
-
-  // Program header table.
-  elf::Elf32_Half segments_count_ = 0;
-  const typename Traits::Elf_Phdr* segments_ = nullptr;
-
-  // Bit fields to store the role each section may play.
-  std::vector<int> section_judgements_;
-
-  // Translator between offsets and RVAs.
-  AddressTranslator translator_;
-
-  // Identity translator for abs32 translation.
-  AddressTranslator identity_translator_;
-
-  // Extracted relocation section dimensions data, sorted by file offsets.
-  std::vector<SectionDimensionsElf> reloc_section_dims_;
-
-  // Headers of executable sections, sorted by file offsets of the data each
-  // header points to.
-  std::vector<const typename Traits::Elf_Shdr*> exec_headers_;
-
-  // Sorted file offsets of abs32 locations.
-  std::vector<offset_t> abs32_locations_;
-};
-
-// Disassembler for ELF with Intel architectures.
-template <class TRAITS>
-class DisassemblerElfIntel : public DisassemblerElf<TRAITS> {
- public:
-  using Traits = TRAITS;
-  enum ReferenceType : uint8_t { kReloc, kAbs32, kRel32, kTypeCount };
-
-  DisassemblerElfIntel();
-  DisassemblerElfIntel(const DisassemblerElfIntel&) = delete;
-  const DisassemblerElfIntel& operator=(const DisassemblerElfIntel&) = delete;
-  ~DisassemblerElfIntel() override;
-
-  // Disassembler:
-  std::vector<ReferenceGroup> MakeReferenceGroups() const override;
-
-  // DisassemblerElf:
-  void ParseExecSection(const typename Traits::Elf_Shdr& section) override;
-  void PostProcessRel32() override;
-
-  // Specialized Read/Write functions.
-  std::unique_ptr<ReferenceReader> MakeReadAbs32(offset_t lo, offset_t hi);
-  std::unique_ptr<ReferenceWriter> MakeWriteAbs32(MutableBufferView image);
-  std::unique_ptr<ReferenceReader> MakeReadRel32(offset_t lo, offset_t hi);
-  std::unique_ptr<ReferenceWriter> MakeWriteRel32(MutableBufferView image);
-
- private:
-  // Sorted file offsets of rel32 locations.
-  // Using std::deque to reduce peak memory footprint.
-  std::deque<offset_t> rel32_locations_;
-};
-
-using DisassemblerElfX86 = DisassemblerElfIntel<Elf32IntelTraits>;
-using DisassemblerElfX64 = DisassemblerElfIntel<Elf64IntelTraits>;
-
-// Disassembler for ELF with ARM architectures.
-template <class TRAITS>
-class DisassemblerElfArm : public DisassemblerElf<TRAITS> {
- public:
-  using Traits = TRAITS;
-  DisassemblerElfArm();
-  DisassemblerElfArm(const DisassemblerElfArm&) = delete;
-  const DisassemblerElfArm& operator=(const DisassemblerElfArm&) = delete;
-  ~DisassemblerElfArm() override;
-
-  // Determines whether target |offset| is in an executable section.
-  bool IsTargetOffsetInExecSection(offset_t offset) const;
-
-  // Creates an architecture-specific Rel32Finder for ParseExecSection.
-  virtual std::unique_ptr<typename Traits::Rel32FinderUse> MakeRel32Finder(
-      const typename Traits::Elf_Shdr& section) = 0;
-
-  // DisassemblerElf:
-  void ParseExecSection(const typename Traits::Elf_Shdr& section) override;
-  void PostProcessRel32() override;
-
-  // Specialized Read/Write functions.
-  std::unique_ptr<ReferenceReader> MakeReadAbs32(offset_t lo, offset_t hi);
-  std::unique_ptr<ReferenceWriter> MakeWriteAbs32(MutableBufferView image);
-
-  // Specialized Read/Write functions for different rel32 address types.
-  template <class ADDR_TRAITS>
-  std::unique_ptr<ReferenceReader> MakeReadRel32(offset_t lower,
-                                                 offset_t upper);
-  template <class ADDR_TRAITS>
-  std::unique_ptr<ReferenceWriter> MakeWriteRel32(MutableBufferView image);
-
- protected:
-  // Sorted file offsets of rel32 locations for each rel32 address type.
-  std::deque<offset_t>
-      rel32_locations_table_[Traits::ArmReferenceType::kTypeCount];
-};
-
-// Disassembler for ELF with AArch32 (AKA ARM32).
-class DisassemblerElfAArch32 : public DisassemblerElfArm<ElfAArch32Traits> {
- public:
-  DisassemblerElfAArch32();
-  DisassemblerElfAArch32(const DisassemblerElfAArch32&) = delete;
-  const DisassemblerElfAArch32& operator=(const DisassemblerElfAArch32&) =
-      delete;
-  ~DisassemblerElfAArch32() override;
-
-  // Disassembler:
-  std::vector<ReferenceGroup> MakeReferenceGroups() const override;
-
-  // DisassemblerElfArm:
-  std::unique_ptr<typename Traits::Rel32FinderUse> MakeRel32Finder(
-      const typename Traits::Elf_Shdr& section) override;
-
-  // Under the naive assumption that an executable section is entirely ARM mode
-  // or THUMB2 mode, this function implements heuristics to distinguish between
-  // the two. Returns true if section is THUMB2 mode; otherwise return false.
-  bool IsExecSectionThumb2(const typename Traits::Elf_Shdr& section) const;
-};
-
-// Disassembler for ELF with AArch64 (AKA ARM64).
-class DisassemblerElfAArch64 : public DisassemblerElfArm<ElfAArch64Traits> {
- public:
-  DisassemblerElfAArch64();
-  DisassemblerElfAArch64(const DisassemblerElfAArch64&) = delete;
-  const DisassemblerElfAArch64& operator=(const DisassemblerElfAArch64&) =
-      delete;
-  ~DisassemblerElfAArch64() override;
-
-  // Disassembler:
-  std::vector<ReferenceGroup> MakeReferenceGroups() const override;
-
-  // DisassemblerElfArm:
-  std::unique_ptr<typename Traits::Rel32FinderUse> MakeRel32Finder(
-      const typename Traits::Elf_Shdr& section) override;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_DISASSEMBLER_ELF_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_no_op.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_no_op.h
deleted file mode 100644
index 1d436dd..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/disassembler_no_op.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_DISASSEMBLER_NO_OP_H_
-#define COMPONENTS_ZUCCHINI_DISASSEMBLER_NO_OP_H_
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/disassembler.h"
-#include "components/zucchini/image_utils.h"
-
-namespace zucchini {
-
-// This disassembler works on any file and does not look for reference.
-class DisassemblerNoOp : public Disassembler {
- public:
-  static constexpr uint16_t kVersion = 1;
-
-  DisassemblerNoOp();
-  DisassemblerNoOp(const DisassemblerNoOp&) = delete;
-  const DisassemblerNoOp& operator=(const DisassemblerNoOp&) = delete;
-  ~DisassemblerNoOp() override;
-
-  // Disassembler:
-  ExecutableType GetExeType() const override;
-  std::string GetExeTypeString() const override;
-  std::vector<ReferenceGroup> MakeReferenceGroups() const override;
-
- private:
-  friend Disassembler;
-
-  bool Parse(ConstBufferView image) override;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_DISASSEMBLER_NO_OP_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/element_detection.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/element_detection.h
deleted file mode 100644
index 7d4b0bc..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/element_detection.h
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_ELEMENT_DETECTION_H_
-#define COMPONENTS_ZUCCHINI_ELEMENT_DETECTION_H_
-
-#include <stddef.h>
-
-#include <memory>
-#include <optional>
-
-#include "base/callback.h"
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/image_utils.h"
-
-namespace zucchini {
-
-class Disassembler;
-
-// Attempts to detect an executable located at start of |image|. If found,
-// returns the corresponding disassembler. Otherwise returns null.
-std::unique_ptr<Disassembler> MakeDisassemblerWithoutFallback(
-    ConstBufferView image);
-
-// Attempts to create a disassembler corresponding to |exe_type| and initialize
-// it with |image|, On failure, returns null.
-std::unique_ptr<Disassembler> MakeDisassemblerOfType(ConstBufferView image,
-                                                     ExecutableType exe_type);
-
-// Returns the version associated with disassembler of type |exe_type|.
-uint16_t DisassemblerVersionOfType(ExecutableType exe_type);
-
-// Attempts to detect an element associated with |image| and returns it, or
-// returns nullopt if no element is detected.
-using ElementDetector =
-    base::RepeatingCallback<std::optional<Element>(ConstBufferView image)>;
-
-// Implementation of ElementDetector using disassemblers.
-std::optional<Element> DetectElementFromDisassembler(ConstBufferView image);
-
-// A class to scan through an image and iteratively detect elements.
-class ElementFinder {
- public:
-  ElementFinder(ConstBufferView image, ElementDetector&& detector);
-  ElementFinder(const ElementFinder&) = delete;
-  const ElementFinder& operator=(const ElementFinder&) = delete;
-  ~ElementFinder();
-
-  // Scans for the next executable using |detector|. Returns the next element
-  // found, or nullopt if no more element can be found.
-  std::optional<Element> GetNext();
-
- private:
-  ConstBufferView image_;
-  ElementDetector detector_;
-  offset_t pos_ = 0;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_ELEMENT_DETECTION_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/encoded_view.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/encoded_view.h
deleted file mode 100644
index 864d265..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/encoded_view.h
+++ /dev/null
@@ -1,185 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_ENCODED_VIEW_H_
-#define COMPONENTS_ZUCCHINI_ENCODED_VIEW_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <iterator>
-#include <vector>
-
-#include "components/zucchini/image_index.h"
-#include "components/zucchini/image_utils.h"
-
-namespace zucchini {
-
-// Zucchini-gen performs semantics-aware matching:
-// - Same-typed reference target in "old" and "new" can be associated.
-//   Associated targets are assigned an identifier called "label" (and for
-//   unassociated targets, label = 0).
-// - EncodedView maps each offset in "old" and "new" images to a "projected
-//   value", which can be:
-//   - Raw byte value (0-255) for non-references.
-//   - Reference "projected value" (> 256) that depends on target {type, label}
-//     at each reference's location (byte 0).
-//   - Reference padding value (256) at the body of each reference (bytes 1+).
-// - The projected values for "old" and "new" are used to build the equivalence
-//   map.
-
-constexpr size_t kReferencePaddingProjection = 256;
-constexpr size_t kBaseReferenceProjection = 257;
-
-// A Range (providing begin and end iterators) that adapts ImageIndex to make
-// image data appear as an Encoded Image, that is encoded data under a higher
-// level of abstraction than raw bytes. In particular:
-// - First byte of each reference become a projection of its type and label.
-// - Subsequent bytes of each reference becomes |kReferencePaddingProjection|.
-// - Non-reference raw bytes remain as raw bytes.
-class EncodedView {
- public:
-  // RandomAccessIterator whose values are the results of Projection().
-  class Iterator {
-   public:
-    using iterator_category = std::random_access_iterator_tag;
-    using value_type = size_t;
-    using difference_type = ptrdiff_t;
-    using reference = size_t;
-    using pointer = size_t*;
-
-    Iterator(const EncodedView* encoded_view, difference_type pos)
-        : encoded_view_(encoded_view), pos_(pos) {}
-
-    Iterator(const Iterator&) = default;
-
-    Iterator& operator=(const Iterator&) = default;
-
-    value_type operator*() const {
-      return encoded_view_->Projection(static_cast<offset_t>(pos_));
-    }
-
-    value_type operator[](difference_type n) const {
-      return encoded_view_->Projection(static_cast<offset_t>(pos_ + n));
-    }
-
-    Iterator& operator++() {
-      ++pos_;
-      return *this;
-    }
-
-    Iterator operator++(int) {
-      Iterator tmp = *this;
-      ++pos_;
-      return tmp;
-    }
-
-    Iterator& operator--() {
-      --pos_;
-      return *this;
-    }
-
-    Iterator operator--(int) {
-      Iterator tmp = *this;
-      --pos_;
-      return tmp;
-    }
-
-    Iterator& operator+=(difference_type n) {
-      pos_ += n;
-      return *this;
-    }
-
-    Iterator& operator-=(difference_type n) {
-      pos_ -= n;
-      return *this;
-    }
-
-    friend bool operator==(Iterator a, Iterator b) { return a.pos_ == b.pos_; }
-
-    friend bool operator!=(Iterator a, Iterator b) { return !(a == b); }
-
-    friend bool operator<(Iterator a, Iterator b) { return a.pos_ < b.pos_; }
-
-    friend bool operator>(Iterator a, Iterator b) { return b < a; }
-
-    friend bool operator<=(Iterator a, Iterator b) { return !(b < a); }
-
-    friend bool operator>=(Iterator a, Iterator b) { return !(a < b); }
-
-    friend difference_type operator-(Iterator a, Iterator b) {
-      return a.pos_ - b.pos_;
-    }
-
-    friend Iterator operator+(Iterator it, difference_type n) {
-      it += n;
-      return it;
-    }
-
-    friend Iterator operator-(Iterator it, difference_type n) {
-      it -= n;
-      return it;
-    }
-
-   private:
-    const EncodedView* encoded_view_;
-    difference_type pos_;
-  };
-
-  using value_type = size_t;
-  using size_type = offset_t;
-  using difference_type = ptrdiff_t;
-  using const_iterator = Iterator;
-
-  // |image_index| is the annotated image being adapted, and is required to
-  // remain valid for the lifetime of the object.
-  explicit EncodedView(const ImageIndex& image_index);
-  EncodedView(const EncodedView&) = delete;
-  const EncodedView& operator=(const EncodedView&) = delete;
-  ~EncodedView();
-
-  // Projects |location| to a scalar value that describes the content at a
-  // higher level of abstraction.
-  value_type Projection(offset_t location) const;
-
-  bool IsToken(offset_t location) const {
-    return image_index_.IsToken(location);
-  }
-
-  // Returns the cardinality of the projection, i.e., the upper bound on
-  // values returned by Projection().
-  value_type Cardinality() const;
-
-  // Associates |labels| to targets for a given |pool|, replacing previous
-  // association. Values in |labels| must be smaller than |bound|.
-  void SetLabels(PoolTag pool, std::vector<uint32_t>&& labels, size_t bound);
-  const ImageIndex& image_index() const { return image_index_; }
-
-  // Range functions.
-  size_type size() const { return size_type(image_index_.size()); }
-  const_iterator begin() const {
-    return const_iterator{this, difference_type(0)};
-  }
-  const_iterator end() const {
-    return const_iterator{this, difference_type(size())};
-  }
-
- private:
-  struct PoolInfo {
-    PoolInfo();
-    PoolInfo(PoolInfo&&);
-    ~PoolInfo();
-
-    // |labels| translates IndirectReference target_key to label.
-    std::vector<uint32_t> labels;
-    size_t bound = 0;
-  };
-
-  const ImageIndex& image_index_;
-  std::vector<PoolInfo> pool_infos_;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_ENCODED_VIEW_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/equivalence_map.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/equivalence_map.h
deleted file mode 100644
index af99ac4..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/equivalence_map.h
+++ /dev/null
@@ -1,208 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_EQUIVALENCE_MAP_H_
-#define COMPONENTS_ZUCCHINI_EQUIVALENCE_MAP_H_
-
-#include <stddef.h>
-
-#include <deque>
-#include <limits>
-#include <vector>
-
-#include "components/zucchini/image_index.h"
-#include "components/zucchini/image_utils.h"
-#include "components/zucchini/targets_affinity.h"
-
-namespace zucchini {
-
-constexpr double kMismatchFatal = -std::numeric_limits<double>::infinity();
-
-class EncodedView;
-class EquivalenceSource;
-
-// Returns similarity score between a token (raw byte or first byte of a
-// reference) in |old_image_index| at |src| and a token in |new_image_index|
-// at |dst|. |targets_affinities| describes affinities for each target pool and
-// is used to evaluate similarity between references, hence it's size must be
-// equal to the number of pools in both |old_image_index| and |new_image_index|.
-// Both |src| and |dst| must refer to tokens in |old_image_index| and
-// |new_image_index|.
-double GetTokenSimilarity(
-    const ImageIndex& old_image_index,
-    const ImageIndex& new_image_index,
-    const std::vector<TargetsAffinity>& targets_affinities,
-    offset_t src,
-    offset_t dst);
-
-// Returns a similarity score between content in |old_image_index| and
-// |new_image_index| at regions described by |equivalence|, using
-// |targets_affinities| to evaluate similarity between references.
-double GetEquivalenceSimilarity(
-    const ImageIndex& old_image_index,
-    const ImageIndex& new_image_index,
-    const std::vector<TargetsAffinity>& targets_affinities,
-    const Equivalence& equivalence);
-
-// Extends |equivalence| forward and returns the result. This is related to
-// VisitEquivalenceSeed().
-EquivalenceCandidate ExtendEquivalenceForward(
-    const ImageIndex& old_image_index,
-    const ImageIndex& new_image_index,
-    const std::vector<TargetsAffinity>& targets_affinities,
-    const EquivalenceCandidate& equivalence,
-    double min_similarity);
-
-// Extends |equivalence| backward and returns the result. This is related to
-// VisitEquivalenceSeed().
-EquivalenceCandidate ExtendEquivalenceBackward(
-    const ImageIndex& old_image_index,
-    const ImageIndex& new_image_index,
-    const std::vector<TargetsAffinity>& targets_affinities,
-    const EquivalenceCandidate& equivalence,
-    double min_similarity);
-
-// Creates an equivalence, starting with |src| and |dst| as offset hint, and
-// extends it both forward and backward, trying to maximise similarity between
-// |old_image_index| and |new_image_index|, and returns the result.
-// |targets_affinities| is used to evaluate similarity between references.
-// |min_similarity| describes the minimum acceptable similarity score and is
-// used as threshold to discard bad equivalences.
-EquivalenceCandidate VisitEquivalenceSeed(
-    const ImageIndex& old_image_index,
-    const ImageIndex& new_image_index,
-    const std::vector<TargetsAffinity>& targets_affinities,
-    offset_t src,
-    offset_t dst,
-    double min_similarity);
-
-// Container of pruned equivalences used to map offsets from |old_image| to
-// offsets in |new_image|. Equivalences are pruned by cropping smaller
-// equivalences to avoid overlaps, to make the equivalence map (for covered
-// bytes in |old_image| and |new_image|) one-to-one.
-class OffsetMapper {
- public:
-  using const_iterator = std::deque<Equivalence>::const_iterator;
-
-  // Constructors for various data sources. "Old" and "new" image sizes are
-  // needed for bounds checks and to handle dangling targets.
-  // - From a list of |equivalences|, already sorted (by |src_offset|) and
-  //   pruned, useful for tests.
-  OffsetMapper(std::deque<Equivalence>&& equivalences,
-               offset_t old_image_size,
-               offset_t new_image_size);
-  // - From a generator, useful for Zucchini-apply.
-  OffsetMapper(EquivalenceSource&& equivalence_source,
-               offset_t old_image_size,
-               offset_t new_image_size);
-  // - From an EquivalenceMap that needs to be processed, useful for
-  //   Zucchini-gen.
-  OffsetMapper(const EquivalenceMap& equivalence_map,
-               offset_t old_image_size,
-               offset_t new_image_size);
-  ~OffsetMapper();
-
-  size_t size() const { return equivalences_.size(); }
-  const_iterator begin() const { return equivalences_.begin(); }
-  const_iterator end() const { return equivalences_.end(); }
-
-  // Returns naive extended forward-projection of "old" |offset| that follows
-  // |eq|'s delta. |eq| needs not cover |offset|.
-  // - Averts underflow / overflow by clamping to |[0, new_image_size_)|.
-  // - However, |offset| is *not* restricted to |[0, old_image_size_)|; the
-  //   caller must to make the check (hence "naive").
-  offset_t NaiveExtendedForwardProject(const Equivalence& unit,
-                                       offset_t offset) const;
-
-  // Returns an offset in |new_image| corresponding to |offset| in |old_image|.
-  // Assumes |equivalences_| to be non-empty. Cases:
-  // - If |offset| is covered (i.e., in an "old" block), then use the delta of
-  //   the (unique) equivalence unit that covers |offset|.
-  // - If |offset| is non-covered, but in |[0, old_image_size_)|, then find the
-  //   nearest "old" block, use its delta, and avert underflow / overflow by
-  //   clamping the result to |[0, new_image_size_)|.
-  // - If |offset| is >= |new_image_size_| (a "fake offset"), then use
-  //   |new_image_size_ - old_image_size_| as the delta.
-  offset_t ExtendedForwardProject(offset_t offset) const;
-
-  // Given sorted |offsets|, applies a projection in-place of all offsets that
-  // are part of a pruned equivalence from |old_image| to |new_image|. Other
-  // offsets are removed from |offsets|.
-  void ForwardProjectAll(std::deque<offset_t>* offsets) const;
-
-  // Accessor for testing.
-  const std::deque<Equivalence> equivalences() const { return equivalences_; }
-
-  // Sorts |equivalences| by |src_offset| and removes all source overlaps; so a
-  // source location that was covered by some Equivalence would become covered
-  // by exactly one Equivalence. Moreover, for the offset, the equivalence
-  // corresponds to the largest (pre-pruning) covering Equivalence, and in case
-  // of a tie, the Equivalence with minimal |src_offset|. |equivalences| may
-  // change in size since empty Equivalences are removed.
-  static void PruneEquivalencesAndSortBySource(
-      std::deque<Equivalence>* equivalences);
-
- private:
-  // |equivalences_| is pruned, i.e., no "old" blocks overlap (and no "new"
-  // block overlaps). Also, it is sorted by "old" offsets.
-  std::deque<Equivalence> equivalences_;
-  const offset_t old_image_size_;
-  const offset_t new_image_size_;
-};
-
-// Container of equivalences between |old_image_index| and |new_image_index|,
-// sorted by |Equivalence::dst_offset|, only used during patch generation.
-class EquivalenceMap {
- public:
-  using const_iterator = std::vector<EquivalenceCandidate>::const_iterator;
-
-  EquivalenceMap();
-  // Initializes the object with |equivalences|.
-  explicit EquivalenceMap(std::vector<EquivalenceCandidate>&& candidates);
-  EquivalenceMap(EquivalenceMap&&);
-  EquivalenceMap(const EquivalenceMap&) = delete;
-  ~EquivalenceMap();
-
-  // Finds relevant equivalences between |old_view| and |new_view|, using
-  // suffix array |old_sa| computed from |old_view| and using
-  // |targets_affinities| to evaluate similarity between references. This
-  // function is not symmetric. Equivalences might overlap in |old_view|, but
-  // not in |new_view|. It tries to maximize accumulated similarity within each
-  // equivalence, while maximizing |new_view| coverage. The minimum similarity
-  // of an equivalence is given by |min_similarity|.
-  void Build(const std::vector<offset_t>& old_sa,
-             const EncodedView& old_view,
-             const EncodedView& new_view,
-             const std::vector<TargetsAffinity>& targets_affinities,
-             double min_similarity);
-
-  size_t size() const { return candidates_.size(); }
-  const_iterator begin() const { return candidates_.begin(); }
-  const_iterator end() const { return candidates_.end(); }
-
- private:
-  // Discovers equivalence candidates between |old_view| and |new_view| and
-  // stores them in the object. Note that resulting candidates are not sorted
-  // and might be overlapping in new image.
-  void CreateCandidates(const std::vector<offset_t>& old_sa,
-                        const EncodedView& old_view,
-                        const EncodedView& new_view,
-                        const std::vector<TargetsAffinity>& targets_affinities,
-                        double min_similarity);
-  // Sorts candidates by their offset in new image.
-  void SortByDestination();
-  // Visits |candidates_| (sorted by |dst_offset|) and remove all destination
-  // overlaps. Candidates with low similarity scores are more likely to be
-  // shrunken. Unfit candidates may be removed.
-  void Prune(const EncodedView& old_view,
-             const EncodedView& new_view,
-             const std::vector<TargetsAffinity>& targets_affinities,
-             double min_similarity);
-
-  std::vector<EquivalenceCandidate> candidates_;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_EQUIVALENCE_MAP_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_index.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_index.h
deleted file mode 100644
index b5acee1..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_index.h
+++ /dev/null
@@ -1,116 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_IMAGE_INDEX_H_
-#define COMPONENTS_ZUCCHINI_IMAGE_INDEX_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <vector>
-
-#include "base/check_op.h"
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/image_utils.h"
-#include "components/zucchini/reference_set.h"
-#include "components/zucchini/target_pool.h"
-
-namespace zucchini {
-
-class Disassembler;
-
-// A class that holds annotations of an image, allowing quick access to its raw
-// and reference content. The memory overhead of storing all references is
-// relatively high, so this is only used during patch generation.
-class ImageIndex {
- public:
-  explicit ImageIndex(ConstBufferView image);
-  ImageIndex(const ImageIndex&) = delete;
-  ImageIndex(ImageIndex&&);
-  ~ImageIndex();
-
-  // Inserts all references read from |disasm|. This should be called exactly
-  // once. If overlap between any two references of any type is encountered,
-  // returns false and leaves the object in an invalid state. Otherwise,
-  // returns true.
-  // TODO(huangs): Refactor ReaderFactory and WriterFactory so
-  // |const Disassembler&| can be used here.
-  bool Initialize(Disassembler* disasm);
-
-  // Returns the array size needed to accommodate all reference type values.
-  size_t TypeCount() const {
-    if (reference_sets_.empty())
-      return 0U;
-    return reference_sets_.rbegin()->first.value() + 1;  // Max key + 1.
-  }
-
-  // Returns the array size needed to accommodate all pool values.
-  size_t PoolCount() const {
-    if (target_pools_.empty())
-      return 0U;
-    return target_pools_.rbegin()->first.value() + 1;  // Max key + 1.
-  }
-
-  // Returns true if |image_[location]| is either:
-  // - A raw value.
-  // - The first byte of a reference.
-  bool IsToken(offset_t location) const;
-
-  // Returns true if |image_[location]| is part of a reference.
-  bool IsReference(offset_t location) const {
-    return LookupType(location) != kNoTypeTag;
-  }
-
-  // Returns the type tag of the reference covering |location|, or kNoTypeTag if
-  // |location| is not part of a reference.
-  TypeTag LookupType(offset_t location) const {
-    DCHECK_LT(location, size());
-    return type_tags_[location];
-  }
-
-  // Returns the raw value at |location|.
-  uint8_t GetRawValue(offset_t location) const {
-    DCHECK_LT(location, size());
-    return image_[location];
-  }
-
-  const std::map<PoolTag, TargetPool>& target_pools() const {
-    return target_pools_;
-  }
-  const std::map<TypeTag, ReferenceSet>& reference_sets() const {
-    return reference_sets_;
-  }
-
-  const TargetPool& pool(PoolTag pool_tag) const {
-    return target_pools_.at(pool_tag);
-  }
-  const ReferenceSet& refs(TypeTag type_tag) const {
-    return reference_sets_.at(type_tag);
-  }
-
-  // Returns the size of the image.
-  size_t size() const { return image_.size(); }
-
- private:
-  // Inserts to |*this| index, all references described by |traits| read from
-  // |ref_reader|, which gets consumed. This should be called exactly once for
-  // each reference type. If overlap between any two references of any type is
-  // encountered, returns false and leaves the object in an invalid state.
-  // Otherwise, returns true.
-  bool InsertReferences(const ReferenceTypeTraits& traits,
-                        ReferenceReader&& ref_reader);
-
-  const ConstBufferView image_;
-
-  // Used for random access lookup of reference type, for each byte in |image_|.
-  std::vector<TypeTag> type_tags_;
-
-  std::map<PoolTag, TargetPool> target_pools_;
-  std::map<TypeTag, ReferenceSet> reference_sets_;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_IMAGE_INDEX_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_utils.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_utils.h
deleted file mode 100644
index 7bfa8cf..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/image_utils.h
+++ /dev/null
@@ -1,225 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_IMAGE_UTILS_H_
-#define COMPONENTS_ZUCCHINI_IMAGE_UTILS_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <optional>
-#include <string>
-
-#include "base/format_macros.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/strings/stringprintf.h"
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/typed_value.h"
-
-namespace zucchini {
-
-// offset_t is used to describe an offset in an image.
-// Files bigger than 4GB are not supported.
-using offset_t = uint32_t;
-// Divide by 2 since label marking uses the most significant bit.
-constexpr offset_t kOffsetBound = static_cast<offset_t>(-1) / 2;
-// Use 0xFFFFFFF*E*, since 0xFFFFFFF*F* is a sentinel value for Dex references.
-constexpr offset_t kInvalidOffset = static_cast<offset_t>(-2);
-
-// key_t is used to identify an offset in a table.
-using key_t = uint32_t;
-
-enum Bitness : uint8_t {
-  // The numerical values are intended to simplify WidthOf() below.
-  kBit32 = 4,
-  kBit64 = 8
-};
-
-inline uint32_t WidthOf(Bitness bitness) {
-  return static_cast<uint32_t>(bitness);
-}
-
-// Used to uniquely identify a reference type.
-// Strongly typed objects are used to avoid ambiguitees with PoolTag.
-struct TypeTag : public TypedValue<TypeTag, uint8_t> {
-  // inheriting constructor:
-  using TypedValue<TypeTag, uint8_t>::TypedValue;
-};
-
-// Used to uniquely identify a pool.
-struct PoolTag : public TypedValue<PoolTag, uint8_t> {
-  // inheriting constructor:
-  using TypedValue<PoolTag, uint8_t>::TypedValue;
-};
-
-constexpr TypeTag kNoTypeTag(0xFF);  // Typically used to identify raw data.
-constexpr PoolTag kNoPoolTag(0xFF);
-
-// Specification of references in an image file.
-struct ReferenceTypeTraits {
-  constexpr ReferenceTypeTraits(offset_t width_in,
-                                TypeTag type_tag_in,
-                                PoolTag pool_tag_in)
-      : width(width_in), type_tag(type_tag_in), pool_tag(pool_tag_in) {}
-
-  // |width| specifies number of bytes covered by the reference's binary
-  // encoding.
-  const offset_t width;
-  // |type_tag| identifies the reference type being described.
-  const TypeTag type_tag;
-  // |pool_tag| identifies the pool this type belongs to.
-  const PoolTag pool_tag;
-};
-
-// There is no need to store |type| because references of the same type are
-// always aggregated into the same container, and so during iteration we'd have
-// |type| already.
-struct Reference {
-  offset_t location;
-  offset_t target;
-};
-
-inline bool operator==(const Reference& a, const Reference& b) {
-  return a.location == b.location && a.target == b.target;
-}
-
-// Interface for extracting References through member function GetNext().
-// This is used by Disassemblers to extract references from an image file.
-// Typically, a Reader lazily extracts values and does not hold any storage.
-class ReferenceReader {
- public:
-  virtual ~ReferenceReader() = default;
-
-  // Returns the next available Reference, or nullopt_t if exhausted.
-  // Extracted References must be ordered by their location in the image.
-  virtual std::optional<Reference> GetNext() = 0;
-};
-
-// Interface for writing References through member function
-// PutNext(reference). This is used by Disassemblers to write new References
-// in the image file.
-class ReferenceWriter {
- public:
-  virtual ~ReferenceWriter() = default;
-
-  // Writes |reference| in the underlying image file. This operation always
-  // succeeds.
-  virtual void PutNext(Reference reference) = 0;
-};
-
-// An Equivalence is a block of length |length| that approximately match in
-// |old_image| at an offset of |src_offset| and in |new_image| at an offset of
-// |dst_offset|.
-struct Equivalence {
-  offset_t src_offset;
-  offset_t dst_offset;
-  offset_t length;
-
-  offset_t src_end() const { return src_offset + length; }
-  offset_t dst_end() const { return dst_offset + length; }
-};
-
-inline bool operator==(const Equivalence& a, const Equivalence& b) {
-  return a.src_offset == b.src_offset && a.dst_offset == b.dst_offset &&
-         a.length == b.length;
-}
-
-// Same as Equivalence, but with a similarity score. This is only used when
-// generating the patch.
-struct EquivalenceCandidate {
-  Equivalence eq;
-  double similarity;
-};
-
-template <size_t N>
-inline constexpr uint32_t ExeTypeToUint32(const char (&exe_type)[N]) {
-  static_assert(N == 5, "Expected ExeType of length 4 + 1 null byte.");
-  return (exe_type[3] << 24) | (exe_type[2] << 16) | (exe_type[1] << 8) |
-         exe_type[0];
-}
-
-// Enumerations for supported executables. Values in this enum must be distinct.
-// Once present, values should never be altered or removed to ensure backwards
-// compatibility and patch type collision avoidance.
-enum ExecutableType : uint32_t {
-  kExeTypeUnknown = UINT32_MAX,
-  kExeTypeNoOp = ExeTypeToUint32("NoOp"),
-  kExeTypeWin32X86 = ExeTypeToUint32("Px86"),
-  kExeTypeWin32X64 = ExeTypeToUint32("Px64"),
-  kExeTypeElfX86 = ExeTypeToUint32("Ex86"),
-  kExeTypeElfX64 = ExeTypeToUint32("Ex64"),
-  kExeTypeElfAArch32 = ExeTypeToUint32("EA32"),
-  kExeTypeElfAArch64 = ExeTypeToUint32("EA64"),
-  kExeTypeDex = ExeTypeToUint32("DEX "),
-  kExeTypeZtf = ExeTypeToUint32("ZTF "),
-};
-
-constexpr ExecutableType CastToExecutableType(uint32_t possible_exe_type) {
-  switch (static_cast<ExecutableType>(possible_exe_type)) {
-    case kExeTypeNoOp:        // Falls through.
-    case kExeTypeWin32X86:    // Falls through.
-    case kExeTypeWin32X64:    // Falls through.
-    case kExeTypeElfX86:      // Falls through.
-    case kExeTypeElfX64:      // Falls through.
-    case kExeTypeElfAArch32:  // Falls through.
-    case kExeTypeElfAArch64:  // Falls through.
-    case kExeTypeDex:         // Falls through.
-    case kExeTypeZtf:         // Falls through.
-    case kExeTypeUnknown:
-      return static_cast<ExecutableType>(possible_exe_type);
-    default:
-      return kExeTypeUnknown;
-  }
-}
-
-inline std::string CastExecutableTypeToString(ExecutableType exe_type) {
-  uint32_t v = static_cast<uint32_t>(exe_type);
-  char result[] = {static_cast<char>(v), static_cast<char>(v >> 8),
-                   static_cast<char>(v >> 16), static_cast<char>(v >> 24), 0};
-  return result;
-}
-
-// A region in an image with associated executable type |exe_type|. If
-// |exe_type == kExeTypeNoOp|, then the Element represents a region of raw data.
-struct Element : public BufferRegion {
-  Element() = default;
-  constexpr Element(const BufferRegion& region_in, ExecutableType exe_type_in)
-      : BufferRegion(region_in), exe_type(exe_type_in) {}
-  constexpr explicit Element(const BufferRegion& region_in)
-      : BufferRegion(region_in), exe_type(kExeTypeNoOp) {}
-
-  // Similar to lo() and hi(), but returns values in offset_t.
-  offset_t BeginOffset() const { return base::checked_cast<offset_t>(lo()); }
-  offset_t EndOffset() const { return base::checked_cast<offset_t>(hi()); }
-
-  BufferRegion region() const { return {offset, size}; }
-
-  friend bool operator==(const Element& a, const Element& b) {
-    return a.exe_type == b.exe_type && a.offset == b.offset && a.size == b.size;
-  }
-
-  ExecutableType exe_type;
-};
-
-// A matched pair of Elements.
-struct ElementMatch {
-  bool IsValid() const { return old_element.exe_type == new_element.exe_type; }
-  ExecutableType exe_type() const { return old_element.exe_type; }
-
-  // Represents match as "#+#=#+#", where "#" denotes the integers:
-  //   [offset in "old", size in "old", offset in "new", size in "new"].
-  // Note that element type is omitted.
-  std::string ToString() const {
-    return base::StringPrintf("%" PRIuS "+%" PRIuS "=%" PRIuS "+%" PRIuS "",
-                              old_element.offset, old_element.size,
-                              new_element.offset, new_element.size);
-  }
-
-  Element old_element;
-  Element new_element;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_IMAGE_UTILS_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/io_utils.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/io_utils.h
deleted file mode 100644
index 63eeec8..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/io_utils.h
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_IO_UTILS_H_
-#define COMPONENTS_ZUCCHINI_IO_UTILS_H_
-
-#include <stdint.h>
-
-#include <cctype>
-#include <istream>
-#include <ostream>
-#include <sstream>
-#include <string>
-
-namespace zucchini {
-
-// An std::ostream wrapper that that limits number of std::endl lines to output,
-// useful for preventing excessive debug message output. Usage requires some
-// work by the caller. Sample:
-//   static LimitedOutputStream los(std::cerr, 10);
-//   if (!los.full()) {
-//     ...  // Prepare message. Block may be skipped so don't do other work!
-//     los << message;
-//     los << std::endl;  // Important!
-//   }
-class LimitedOutputStream : public std::ostream {
- private:
-  class StreamBuf : public std::stringbuf {
-   public:
-    StreamBuf(std::ostream& os, int limit);
-    ~StreamBuf() override;
-
-    int sync() override;
-    bool full() const { return counter_ >= limit_; }
-
-   private:
-    std::ostream& os_;
-    const int limit_;
-    int counter_ = 0;
-  };
-
- public:
-  LimitedOutputStream(std::ostream& os, int limit);
-  LimitedOutputStream(const LimitedOutputStream&) = delete;
-  const LimitedOutputStream& operator=(const LimitedOutputStream&) = delete;
-  bool full() const { return buf_.full(); }
-
- private:
-  StreamBuf buf_;
-};
-
-// A class to render hexadecimal numbers for std::ostream with 0-padding. This
-// is more concise and flexible than stateful STL manipulator alternatives; so:
-//   std::ios old_fmt(nullptr);
-//   old_fmt.copyfmt(std::cout);
-//   std::cout << std::uppercase << std::hex;
-//   std::cout << std::setfill('0') << std::setw(8) << int_data << std::endl;
-//   std::cout.copyfmt(old_fmt);
-// can be expressed as:
-//   std::cout << AxHex<8>(int_data) << std::endl;
-template <int N, typename T = uint32_t>
-struct AsHex {
-  explicit AsHex(T value_in) : value(value_in) {}
-  T value;
-};
-
-template <int N, typename T>
-std::ostream& operator<<(std::ostream& os, const AsHex<N, T>& as_hex) {
-  char buf[N + 1];
-  buf[N] = '\0';
-  T value = as_hex.value;
-  for (int i = N - 1; i >= 0; --i, value >>= 4)
-    buf[i] = "0123456789ABCDEF"[static_cast<int>(value & 0x0F)];
-  if (value)
-    os << "...";  // To indicate data truncation, or negative values.
-  os << buf;
-  return os;
-}
-
-// An output manipulator to simplify printing list separators. Sample usage:
-//   PrefixSep sep(",");
-//   for (int i : {3, 1, 4, 1, 5, 9})
-//      std::cout << sep << i;
-//   std::cout << std::endl;  // Outputs "3,1,4,1,5,9\n".
-class PrefixSep {
- public:
-  explicit PrefixSep(const std::string& sep_str) : sep_str_(sep_str) {}
-  PrefixSep(const PrefixSep&) = delete;
-  const PrefixSep& operator=(const PrefixSep&) = delete;
-
-  friend std::ostream& operator<<(std::ostream& ostr, PrefixSep& obj);
-
- private:
-  std::string sep_str_;
-  bool first_ = true;
-};
-
-// An input manipulator that dictates the expected next character in
-// |std::istream|, and invalidates the stream if expectation is not met.
-class EatChar {
- public:
-  explicit EatChar(char ch) : ch_(ch) {}
-  EatChar(const EatChar&) = delete;
-  const EatChar& operator=(const EatChar&) = delete;
-
-  friend inline std::istream& operator>>(std::istream& istr,
-                                         const EatChar& obj) {
-    if (!istr.fail() && istr.get() != obj.ch_)
-      istr.setstate(std::ios_base::failbit);
-    return istr;
-  }
-
- private:
-  char ch_;
-};
-
-// An input manipulator that reads an unsigned integer from |std::istream|,
-// and invalidates the stream on failure. Intolerant of leading white spaces,
-template <typename T>
-class StrictUInt {
- public:
-  explicit StrictUInt(T& var) : var_(var) {}
-  StrictUInt(const StrictUInt&) = default;
-
-  friend std::istream& operator>>(std::istream& istr, StrictUInt<T> obj) {
-    if (!istr.fail() && !::isdigit(istr.peek())) {
-      istr.setstate(std::ios_base::failbit);
-      return istr;
-    }
-    return istr >> obj.var_;
-  }
-
- private:
-  T& var_;
-};
-
-// Stub out uint8_t: istream treats it as char, and value won't be read as int!
-template <>
-struct StrictUInt<uint8_t> {};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_IO_UTILS_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_reader.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_reader.h
deleted file mode 100644
index ed0ab9c..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_reader.h
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_PATCH_READER_H_
-#define COMPONENTS_ZUCCHINI_PATCH_READER_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <optional>
-#include <vector>
-
-#include "base/debug/stack_trace.h"
-#include "base/logging.h"
-#include "base/numerics/checked_math.h"
-#include "components/zucchini/buffer_source.h"
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/image_utils.h"
-#include "components/zucchini/patch_utils.h"
-
-namespace zucchini {
-
-namespace patch {
-
-// The Parse*() functions below attempt to extract data of a specific type from
-// the beginning of |source|. A parse function: On success, consumes the used
-// portion of |source|, writes data into the output parameter, and returns
-// true. Otherwise returns false and does not consume |source|.
-
-// Parses |source| for the next ElementMatch.
-bool ParseElementMatch(BufferSource* source, ElementMatch* element_match);
-
-// Parses |source| for the next embedded BufferSource.
-bool ParseBuffer(BufferSource* source, BufferSource* buffer);
-
-// Parses |source| for the next VarUInt.
-template <class T>
-bool ParseVarUInt(BufferSource* source, T* value) {
-  auto bytes_read = DecodeVarUInt(source->begin(), source->end(), value);
-  if (!bytes_read) {
-    LOG(ERROR) << "Impossible to read VarUInt from source.";
-    LOG(ERROR) << base::debug::StackTrace().ToString();
-    return false;
-  }
-  // Advance |source| beyond the VarUInt value.
-  source->Skip(bytes_read);
-  return true;
-}
-
-// Parses |source| for the next VarInt.
-template <class T>
-bool ParseVarInt(BufferSource* source, T* value) {
-  auto bytes_read = DecodeVarInt(source->begin(), source->end(), value);
-  if (!bytes_read) {
-    LOG(ERROR) << "Impossible to read VarInt from source.";
-    LOG(ERROR) << base::debug::StackTrace().ToString();
-    return false;
-  }
-  // Advance |source| beyond the VarInt value.
-  source->Skip(bytes_read);
-  return true;
-}
-
-}  // namespace patch
-
-// The *Source classes below are light-weight (i.e., allows copying) visitors to
-// read patch data. Each of them has an associated "main type", and performs the
-// following:
-// - Consumes portions of a BufferSource (required to remain valid for the
-//   lifetime of the object).
-// - Decodes consumed data, which represent a list of items with "main type".
-// - Dispenses "main type" elements (hence "Source" in the name).
-//
-// Common "core functions" implemented by *Source classes are:
-// - bool Initialize(BufferSource* source): Consumes data from BufferSource and
-//   initializes internal states. Returns true if successful, and false
-//   otherwise (|source| may be partially consumed).
-// - std::optional<MAIN_TYPE> GetNext(OPT_PARAMS): Decodes consumed data and
-//   returns the next item as std::optional (returns std::nullopt on failure).
-// - bool Done() const: Returns true if no more items remain; otherwise false.
-//
-// Usage of *Source instances don't mix, and GetNext() have dissimilar
-// interfaces. Therefore we do not use inheritance to relate *Source  classes,
-// and simply implement "core functions" with matching names.
-
-// Source for Equivalences.
-class EquivalenceSource {
- public:
-  EquivalenceSource();
-  EquivalenceSource(const EquivalenceSource&);
-  ~EquivalenceSource();
-
-  // Core functions.
-  bool Initialize(BufferSource* source);
-  std::optional<Equivalence> GetNext();
-  bool Done() const {
-    return src_skip_.empty() && dst_skip_.empty() && copy_count_.empty();
-  }
-
-  // Accessors for unittest.
-  BufferSource src_skip() const { return src_skip_; }
-  BufferSource dst_skip() const { return dst_skip_; }
-  BufferSource copy_count() const { return copy_count_; }
-
- private:
-  BufferSource src_skip_;
-  BufferSource dst_skip_;
-  BufferSource copy_count_;
-
-  base::CheckedNumeric<offset_t> previous_src_offset_ = 0;
-  base::CheckedNumeric<offset_t> previous_dst_offset_ = 0;
-};
-
-// Source for extra data.
-class ExtraDataSource {
- public:
-  ExtraDataSource();
-  ExtraDataSource(const ExtraDataSource&);
-  ~ExtraDataSource();
-
-  // Core functions.
-  bool Initialize(BufferSource* source);
-  // |size| is the size in bytes of the buffer requested.
-  std::optional<ConstBufferView> GetNext(offset_t size);
-  bool Done() const { return extra_data_.empty(); }
-
-  // Accessors for unittest.
-  BufferSource extra_data() const { return extra_data_; }
-
- private:
-  BufferSource extra_data_;
-};
-
-// Source for raw delta.
-class RawDeltaSource {
- public:
-  RawDeltaSource();
-  RawDeltaSource(const RawDeltaSource&);
-  ~RawDeltaSource();
-
-  // Core functions.
-  bool Initialize(BufferSource* source);
-  std::optional<RawDeltaUnit> GetNext();
-  bool Done() const {
-    return raw_delta_skip_.empty() && raw_delta_diff_.empty();
-  }
-
-  // Accessors for unittest.
-  BufferSource raw_delta_skip() const { return raw_delta_skip_; }
-  BufferSource raw_delta_diff() const { return raw_delta_diff_; }
-
- private:
-  BufferSource raw_delta_skip_;
-  BufferSource raw_delta_diff_;
-
-  base::CheckedNumeric<offset_t> copy_offset_compensation_ = 0;
-};
-
-// Source for reference delta.
-class ReferenceDeltaSource {
- public:
-  ReferenceDeltaSource();
-  ReferenceDeltaSource(const ReferenceDeltaSource&);
-  ~ReferenceDeltaSource();
-
-  // Core functions.
-  bool Initialize(BufferSource* source);
-  std::optional<int32_t> GetNext();
-  bool Done() const { return source_.empty(); }
-
-  // Accessors for unittest.
-  BufferSource reference_delta() const { return source_; }
-
- private:
-  BufferSource source_;
-};
-
-// Source for additional targets.
-class TargetSource {
- public:
-  TargetSource();
-  TargetSource(const TargetSource&);
-  ~TargetSource();
-
-  // Core functions.
-  bool Initialize(BufferSource* source);
-  std::optional<offset_t> GetNext();
-  bool Done() const { return extra_targets_.empty(); }
-
-  // Accessors for unittest.
-  BufferSource extra_targets() const { return extra_targets_; }
-
- private:
-  BufferSource extra_targets_;
-
-  base::CheckedNumeric<offset_t> target_compensation_ = 0;
-};
-
-// Following are utility classes providing a structured view on data forming a
-// patch.
-
-// Utility to read a patch element. A patch element contains all the information
-// necessary to patch a single element. This class provide access
-// to the multiple streams of data forming the patch element.
-class PatchElementReader {
- public:
-  PatchElementReader();
-  PatchElementReader(PatchElementReader&&);
-  ~PatchElementReader();
-
-  // If data read from |source| is well-formed, initialize cached sources to
-  // read from it, and returns true. Otherwise returns false.
-  bool Initialize(BufferSource* source);
-
-  const ElementMatch& element_match() const { return element_match_; }
-  const Element& old_element() const { return element_match_.old_element; }
-  const Element& new_element() const { return element_match_.new_element; }
-
-  // The Get*() functions below return copies of cached sources. Callers may
-  // assume the following:
-  // - Equivalences satisfy basic boundary constraints
-  //   - "Old" / "new" blocks lie entirely in "old" / "new" images.
-  //   - "New" blocks are sorted.
-  EquivalenceSource GetEquivalenceSource() const { return equivalences_; }
-  ExtraDataSource GetExtraDataSource() const { return extra_data_; }
-  RawDeltaSource GetRawDeltaSource() const { return raw_delta_; }
-  ReferenceDeltaSource GetReferenceDeltaSource() const {
-    return reference_delta_;
-  }
-  TargetSource GetExtraTargetSource(PoolTag tag) const {
-    auto pos = extra_targets_.find(tag);
-    return pos != extra_targets_.end() ? pos->second : TargetSource();
-  }
-
- private:
-  // Checks that "old" and "new" blocks of each item in |equivalences_| satisfy
-  // basic order and image bound constraints (using |element_match_| data). Also
-  // validates that the amount of extra data is correct. Returns true if
-  // successful.
-  bool ValidateEquivalencesAndExtraData();
-
-  ElementMatch element_match_;
-
-  // Cached sources.
-  EquivalenceSource equivalences_;
-  ExtraDataSource extra_data_;
-  RawDeltaSource raw_delta_;
-  ReferenceDeltaSource reference_delta_;
-  std::map<PoolTag, TargetSource> extra_targets_;
-};
-
-// Utility to read a Zucchini ensemble patch. An ensemble patch is the
-// concatenation of a patch header with a vector of patch elements.
-class EnsemblePatchReader {
- public:
-  // If data read from |buffer| is well-formed, initializes and returns
-  // an instance of EnsemblePatchReader. Otherwise returns std::nullopt.
-  static std::optional<EnsemblePatchReader> Create(ConstBufferView buffer);
-
-  EnsemblePatchReader();
-  EnsemblePatchReader(EnsemblePatchReader&&);
-  ~EnsemblePatchReader();
-
-  // If data read from |source| is well-formed, initialize internal state to
-  // read from it, and returns true. Otherwise returns false.
-  bool Initialize(BufferSource* source);
-
-  // Check old / new image file validity, comparing against expected size and
-  // CRC32. Return true if file matches expectations, false otherwise.
-  bool CheckOldFile(ConstBufferView old_image) const;
-  bool CheckNewFile(ConstBufferView new_image) const;
-
-  const PatchHeader& header() const { return header_; }
-  const std::vector<PatchElementReader>& elements() const { return elements_; }
-
- private:
-  PatchHeader header_;
-  std::vector<PatchElementReader> elements_;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_PATCH_READER_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_utils.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_utils.h
deleted file mode 100644
index 82b2b48..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_utils.h
+++ /dev/null
@@ -1,139 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_PATCH_UTILS_H_
-#define COMPONENTS_ZUCCHINI_PATCH_UTILS_H_
-
-#include <stdint.h>
-
-#include <iterator>
-#include <type_traits>
-
-#include "components/zucchini/image_utils.h"
-#include "components/zucchini/version_info.h"
-
-namespace zucchini {
-
-// A Zucchini 'ensemble' patch is the concatenation of a patch header with a
-// list of patch 'elements', each containing data for patching individual
-// elements.
-
-// Supported by MSVC, g++, and clang++. Ensures no gaps in packing.
-#pragma pack(push, 1)
-
-// Header for a Zucchini patch, found at the beginning of an ensemble patch.
-struct PatchHeader {
-  // Magic signature at the beginning of a Zucchini patch file.
-  enum : uint32_t { kMagic = 'Z' | ('u' << 8) | ('c' << 16) | ('c' << 24) };
-
-  uint32_t magic = 0;
-  uint16_t major_version = kInvalidVersion;
-  uint16_t minor_version = kInvalidVersion;
-  uint32_t old_size = 0;
-  uint32_t old_crc = 0;
-  uint32_t new_size = 0;
-  uint32_t new_crc = 0;
-};
-
-// Sanity check.
-static_assert(sizeof(PatchHeader) == 24, "PatchHeader must be 24 bytes");
-
-// Header for a patch element, found at the beginning of every patch element.
-struct PatchElementHeader {
-  uint32_t old_offset;
-  uint32_t old_length;
-  uint32_t new_offset;
-  uint32_t new_length;
-  uint32_t exe_type;  // ExecutableType.
-  uint16_t version = kInvalidVersion;
-};
-
-// Sanity check.
-static_assert(sizeof(PatchElementHeader) == 22,
-              "PatchElementHeader must be 22 bytes");
-
-#pragma pack(pop)
-
-// Descibes a raw FIX operation.
-struct RawDeltaUnit {
-  offset_t copy_offset;  // Offset in copy regions.
-  int8_t diff;           // Bytewise difference.
-};
-
-// A Zucchini patch contains data streams encoded using varint format to reduce
-// uncompressed size.
-
-// Writes |value| as a varint in |dst| and returns an iterator pointing beyond
-// the written region. |dst| is assumed to hold enough space. Typically, this
-// will write to a vector using back insertion, e.g.:
-//   EncodeVarUInt(value, std::back_inserter(vector));
-template <class T, class It>
-It EncodeVarUInt(T value, It dst) {
-  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned");
-
-  while (value >= 0x80) {
-    *dst++ = static_cast<uint8_t>(value) | 0x80;
-    value >>= 7;
-  }
-  *dst++ = static_cast<uint8_t>(value);
-  return dst;
-}
-
-// Same as EncodeVarUInt(), but for signed values.
-template <class T, class It>
-It EncodeVarInt(T value, It dst) {
-  static_assert(std::is_signed<T>::value, "Value type must be signed");
-
-  using unsigned_value_type = typename std::make_unsigned<T>::type;
-  if (value < 0)
-    return EncodeVarUInt((unsigned_value_type(~value) << 1) | 1, dst);
-  else
-    return EncodeVarUInt(unsigned_value_type(value) << 1, dst);
-}
-
-// Tries to read a varint unsigned integer from |[first, last)|. If
-// succesful, writes result into |value| and returns the number of bytes
-// read from |[first, last)|. Otherwise returns 0.
-template <class T, class It>
-typename std::iterator_traits<It>::difference_type DecodeVarUInt(It first,
-                                                                 It last,
-                                                                 T* value) {
-  static_assert(std::is_unsigned<T>::value, "Value type must be unsigned");
-
-  uint8_t sh = 0;
-  T val = 0;
-  for (auto it = first; it != last;) {
-    val |= T(*it & 0x7F) << sh;
-    if (*(it++) < 0x80) {
-      *value = val;
-      return it - first;
-    }
-    sh += 7;
-    if (sh >= sizeof(T) * 8)  // Overflow!
-      return 0;
-  }
-  return 0;
-}
-
-// Same as DecodeVarUInt(), but for signed values.
-template <class T, class It>
-typename std::iterator_traits<It>::difference_type DecodeVarInt(It first,
-                                                                It last,
-                                                                T* value) {
-  static_assert(std::is_signed<T>::value, "Value type must be signed");
-
-  typename std::make_unsigned<T>::type tmp = 0;
-  auto res = DecodeVarUInt(first, last, &tmp);
-  if (res) {
-    if (tmp & 1)
-      *value = ~static_cast<T>(tmp >> 1);
-    else
-      *value = static_cast<T>(tmp >> 1);
-  }
-  return res;
-}
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_PATCH_UTILS_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_writer.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_writer.h
deleted file mode 100644
index 9bcaad8..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/patch_writer.h
+++ /dev/null
@@ -1,272 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_PATCH_WRITER_H_
-#define COMPONENTS_ZUCCHINI_PATCH_WRITER_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <map>
-#include <optional>
-#include <utility>
-#include <vector>
-
-#include "base/check.h"
-#include "components/zucchini/buffer_sink.h"
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/image_utils.h"
-#include "components/zucchini/patch_utils.h"
-
-namespace zucchini {
-
-namespace patch {
-
-// If sufficient space is available, serializes |element_match| into |sink| and
-// returns true. Otherwise returns false, and |sink| will be in an undefined
-// state.
-bool SerializeElementMatch(const ElementMatch& element_match, BufferSink* sink);
-
-// Returns the size in bytes required to serialize |element_match|.
-size_t SerializedElementMatchSize(const ElementMatch& element_match);
-
-// If sufficient space is available, serializes |buffer| into |sink| and returns
-// true. Otherwise returns false, and |sink| will be in an undefined state.
-bool SerializeBuffer(const std::vector<uint8_t>& buffer, BufferSink* sink);
-
-// Returns the size in bytes required to serialize |buffer|.
-size_t SerializedBufferSize(const std::vector<uint8_t>& buffer);
-
-}  // namespace patch
-
-// Each of *Sink classes below has an associated "main type", and performs the
-// following:
-// - Receives multiple "main type" elements (hence "Sink" in the name).
-// - Encodes list of received data, and writes them to internal storage (e.g.,
-//   applying delta encoding).
-// - Writes encoded data to BufferSink.
-//
-// Common "core functions" implemented for *Sink classes are:
-// - void PutNext(const MAIN_TYPE& inst): Encodes and writes an instance of
-//   MAIN_TYPE to internal storage. Assumptions may be applied to successive
-//   |inst| provided.
-// - size_t SerializedSize() const: Returns the serialized size in bytes of
-//   internal storage.
-// - bool SerializeInto(BufferSink* sink) const: If |sink| has enough space,
-//   serializes internal storage into |sink|, and returns true. Otherwise
-//   returns false.
-//
-// Usage of *Sink instances don't mix, and PuttNext() have dissimilar
-// interfaces. Therefore we do not use inheritance to relate *Sink classes,
-// simply implement "core functions" with matching names.
-
-// Sink for equivalences.
-class EquivalenceSink {
- public:
-  EquivalenceSink();
-  EquivalenceSink(const std::vector<uint8_t>& src_skip,
-                  const std::vector<uint8_t>& dst_skip,
-                  const std::vector<uint8_t>& copy_count);
-
-  EquivalenceSink(EquivalenceSink&&);
-  ~EquivalenceSink();
-
-  // Core functions.
-  // Equivalences must be given by increasing |Equivalence::dst_offset|.
-  void PutNext(const Equivalence& equivalence);
-  size_t SerializedSize() const;
-  bool SerializeInto(BufferSink* sink) const;
-
- private:
-  // Offset in source, delta-encoded starting from end of last equivalence, and
-  // stored as signed varint.
-  std::vector<uint8_t> src_skip_;
-  // Offset in destination, delta-encoded starting from end of last equivalence,
-  // and stored as unsigned varint.
-  std::vector<uint8_t> dst_skip_;
-  // Length of equivalence stored as unsigned varint.
-  // TODO(etiennep): Investigate on bias.
-  std::vector<uint8_t> copy_count_;
-
-  offset_t src_offset_ = 0;  // Last offset in source.
-  offset_t dst_offset_ = 0;  // Last offset in destination.
-};
-
-// Sink for extra data.
-class ExtraDataSink {
- public:
-  ExtraDataSink();
-  explicit ExtraDataSink(const std::vector<uint8_t>& extra_data);
-  ExtraDataSink(ExtraDataSink&&);
-  ~ExtraDataSink();
-
-  // Core functions.
-  void PutNext(ConstBufferView region);
-  size_t SerializedSize() const;
-  bool SerializeInto(BufferSink* sink) const;
-
- private:
-  std::vector<uint8_t> extra_data_;
-};
-
-// Sink for raw delta.
-class RawDeltaSink {
- public:
-  RawDeltaSink();
-  RawDeltaSink(const std::vector<uint8_t>& raw_delta_skip,
-               const std::vector<uint8_t>& raw_delta_diff);
-  RawDeltaSink(RawDeltaSink&&);
-  ~RawDeltaSink();
-
-  // Core functions.
-  // Deltas must be given by increasing |RawDeltaUnit::copy_offset|.
-  void PutNext(const RawDeltaUnit& delta);
-  size_t SerializedSize() const;
-  bool SerializeInto(BufferSink* sink) const;
-
- private:
-  std::vector<uint8_t> raw_delta_skip_;  // Copy offset stating from last delta.
-  std::vector<uint8_t> raw_delta_diff_;  // Bytewise difference.
-
-  // We keep track of the compensation needed for next copy offset, taking into
-  // accound delta encoding and bias of -1. Stored delta are biased by -1, so a
-  // sequence of single byte deltas is represented as a string of 0's.
-  offset_t copy_offset_compensation_ = 0;
-};
-
-// Sink for reference delta.
-class ReferenceDeltaSink {
- public:
-  ReferenceDeltaSink();
-  explicit ReferenceDeltaSink(const std::vector<uint8_t>& reference_delta);
-  ReferenceDeltaSink(ReferenceDeltaSink&&);
-  ~ReferenceDeltaSink();
-
-  // Core functions.
-  void PutNext(int32_t diff);
-  size_t SerializedSize() const;
-  bool SerializeInto(BufferSink* sink) const;
-
- private:
-  std::vector<uint8_t> reference_delta_;
-};
-
-// Sink for additional targets.
-class TargetSink {
- public:
-  TargetSink();
-  explicit TargetSink(const std::vector<uint8_t>& extra_targets);
-  TargetSink(TargetSink&&);
-  ~TargetSink();
-
-  // Core functions.
-  // Targets must be given by increasing order.
-  void PutNext(uint32_t target);
-  size_t SerializedSize() const;
-  bool SerializeInto(BufferSink* sink) const;
-
- private:
-  // Targets are delta-encoded and biaised by 1, stored as unsigned varint.
-  std::vector<uint8_t> extra_targets_;
-
-  // We keep track of the compensation needed for next target, taking into
-  // accound delta encoding and bias of -1.
-  offset_t target_compensation_ = 0;
-};
-
-// Following are utility classes to write structured data forming a patch.
-
-// Utility to write a patch element. A patch element contains all the
-// information necessary to patch a single element. This class
-// provides an interface to individually set different building blocks of data
-// in the patch element.
-class PatchElementWriter {
- public:
-  PatchElementWriter();
-  explicit PatchElementWriter(ElementMatch element_match);
-  PatchElementWriter(PatchElementWriter&&);
-  ~PatchElementWriter();
-
-  const ElementMatch& element_match() const { return element_match_; }
-  const Element& old_element() const { return element_match_.old_element; }
-  const Element& new_element() const { return element_match_.new_element; }
-
-  // Following methods set individual blocks for this element. Previous
-  // corresponding block is replaced. All streams must be set before call to
-  // SerializedSize() of SerializeInto().
-
-  void SetEquivalenceSink(EquivalenceSink&& equivalences) {
-    equivalences_.emplace(std::move(equivalences));
-  }
-  void SetExtraDataSink(ExtraDataSink&& extra_data) {
-    extra_data_.emplace(std::move(extra_data));
-  }
-  void SetRawDeltaSink(RawDeltaSink&& raw_delta) {
-    raw_delta_.emplace(std::move(raw_delta));
-  }
-  void SetReferenceDeltaSink(ReferenceDeltaSink reference_delta) {
-    reference_delta_.emplace(std::move(reference_delta));
-  }
-  // Set additional targets for pool identified with |pool_tag|.
-  void SetTargetSink(PoolTag pool_tag, TargetSink&& extra_targets) {
-    DCHECK(pool_tag != kNoPoolTag);
-    extra_targets_.emplace(pool_tag, std::move(extra_targets));
-  }
-
-  // Returns the serialized size in bytes of the data this object is holding.
-  size_t SerializedSize() const;
-
-  // If sufficient space is available, serializes data into |sink|, which is at
-  // least SerializedSize() bytes, and returns true. Otherwise returns false.
-  bool SerializeInto(BufferSink* sink) const;
-
- private:
-  ElementMatch element_match_;
-  std::optional<EquivalenceSink> equivalences_;
-  std::optional<ExtraDataSink> extra_data_;
-  std::optional<RawDeltaSink> raw_delta_;
-  std::optional<ReferenceDeltaSink> reference_delta_;
-  std::map<PoolTag, TargetSink> extra_targets_;
-};
-
-// Utility to write a Zucchini ensemble patch. An ensemble patch is the
-// concatenation of a patch header with a vector of patch elements.
-class EnsemblePatchWriter {
- public:
-  explicit EnsemblePatchWriter(const PatchHeader& header);
-  EnsemblePatchWriter(ConstBufferView old_image, ConstBufferView new_image);
-  EnsemblePatchWriter(const EnsemblePatchWriter&) = delete;
-  const EnsemblePatchWriter& operator=(const EnsemblePatchWriter&) = delete;
-  ~EnsemblePatchWriter();
-
-  // Reserves space for |count| patch elements.
-  void ReserveElements(size_t count) { elements_.reserve(count); }
-
-  // Adds an patch element into the patch. Patch elements must be ordered by
-  // their location in the new image file.
-  void AddElement(PatchElementWriter&& patch_element);
-
-  // Returns the serialized size in bytes of the data this object is holding.
-  size_t SerializedSize() const;
-
-  // If sufficient space is available, serializes data into |sink|, which is at
-  // least SerializedSize() bytes, and returns true. Otherwise returns false.
-  bool SerializeInto(BufferSink* sink) const;
-
-  // If sufficient space is available, serializes data into |buffer|, which is
-  // at least SerializedSize() bytes, and returns true. Otherwise returns false.
-  bool SerializeInto(MutableBufferView buffer) const {
-    BufferSink sink(buffer);
-    return SerializeInto(&sink);
-  }
-
- private:
-  PatchHeader header_;
-  std::vector<PatchElementWriter> elements_;
-  offset_t current_dst_offset_ = 0;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_PATCH_WRITER_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reference_set.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reference_set.h
deleted file mode 100644
index 07940f0..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reference_set.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_REFERENCE_SET_H_
-#define COMPONENTS_ZUCCHINI_REFERENCE_SET_H_
-
-#include <stddef.h>
-
-#include <vector>
-
-#include "components/zucchini/image_utils.h"
-
-namespace zucchini {
-
-class TargetPool;
-
-// Container of distinct references of one type, along with traits, only used
-// during patch generation.
-class ReferenceSet {
- public:
-  using const_iterator = std::vector<Reference>::const_iterator;
-
-  // |traits| specifies the reference represented. |target_pool| specifies
-  // common targets shared by all reference represented, and mediates target
-  // translation between offsets and indexes.
-  ReferenceSet(const ReferenceTypeTraits& traits,
-               const TargetPool& target_pool);
-  ReferenceSet(const ReferenceSet&) = delete;
-  ReferenceSet(ReferenceSet&&);
-  ~ReferenceSet();
-
-  // Either one of the initializers below should be called exactly once. These
-  // insert all references from |ref_reader/refs| into this class. The targets
-  // of these references must be in |target_pool_|.
-  void InitReferences(ReferenceReader&& ref_reader);
-  void InitReferences(const std::vector<Reference>& refs);
-
-  const std::vector<Reference>& references() const { return references_; }
-  const ReferenceTypeTraits& traits() const { return traits_; }
-  const TargetPool& target_pool() const { return target_pool_; }
-  TypeTag type_tag() const { return traits_.type_tag; }
-  PoolTag pool_tag() const { return traits_.pool_tag; }
-  offset_t width() const { return traits_.width; }
-
-  // Looks up the Reference by an |offset| that it spans. |offset| is assumed to
-  // be valid, i.e., |offset| must be spanned by some Reference in
-  // |references_|.
-  Reference at(offset_t offset) const;
-
-  size_t size() const { return references_.size(); }
-  const_iterator begin() const { return references_.begin(); }
-  const_iterator end() const { return references_.end(); }
-
- private:
-  ReferenceTypeTraits traits_;
-  const TargetPool& target_pool_;
-  // List of distinct Reference instances sorted by location.
-  std::vector<Reference> references_;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_REFERENCE_SET_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_finder.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_finder.h
deleted file mode 100644
index 3ebeb95..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_finder.h
+++ /dev/null
@@ -1,284 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_REL32_FINDER_H_
-#define COMPONENTS_ZUCCHINI_REL32_FINDER_H_
-
-#include <stddef.h>
-
-#include <vector>
-
-#include "components/zucchini/address_translator.h"
-#include "components/zucchini/arm_utils.h"
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/image_utils.h"
-
-namespace zucchini {
-
-// See README.md for definitions on abs32 and rel32 references. The following
-// are assumed:
-// * Abs32 reference bodies have fixed widths.
-// * Rel32 locations can be identified by heuristically disassembling machine
-//   code, and errors are tolerated.
-// * The collection all abs32 and rel32 reference bodies do not overlap.
-
-// A class to visit non-empty contiguous gaps in |region| that lie outside of
-// |abs32_locations| elements, each with a body that spans |abs32_width_| bytes.
-// For example, given:
-//   region = [base_ + 4, base_ + 26),
-//   abs32_locations = {2, 6, 15, 20, 27},
-//   abs32_width_ = 4,
-// the following is obtained:
-//             111111111122222222223   -> offsets
-//   0123456789012345678901234567890
-//   ....**********************.....   -> region = *
-//     ^   ^        ^    ^      ^      -> abs32 locations
-//     aaaaaaaa     aaaa aaaa   aaaa   -> abs32 bodies
-//   ....------*****----*----**.....   -> regions excluding abs32 -> 3 gaps
-// The resulting gaps (non-empty, so [6, 6) is excluded) are:
-//   [10, 15), [19, 20), [24, 26).
-// These gaps can then be passed to Rel32Finder (below) to find rel32 references
-// with bodies that are guaranteed to not overlap with any abs32 bodies.
-class Abs32GapFinder {
- public:
-  // |abs32_locations| is a sorted list of non-overlapping abs32 locations in
-  // |image|, each spanning |abs32_width| bytes. Gaps are searched in |region|,
-  // which must be part of |image|.
-  Abs32GapFinder(ConstBufferView image,
-                 ConstBufferView region,
-                 const std::vector<offset_t>& abs32_locations,
-                 size_t abs32_width);
-  Abs32GapFinder(const Abs32GapFinder&) = delete;
-  const Abs32GapFinder& operator=(const Abs32GapFinder&) = delete;
-  ~Abs32GapFinder();
-
-  // Searches for the next available gap, and returns successfulness.
-  bool FindNext();
-
-  // Returns the cached result from the last successful FindNext().
-  ConstBufferView GetGap() const { return gap_; }
-
- private:
-  const ConstBufferView::const_iterator base_;
-  const ConstBufferView::const_iterator region_end_;
-  ConstBufferView::const_iterator cur_lo_;
-  const std::vector<offset_t>::const_iterator abs32_end_;
-  std::vector<offset_t>::const_iterator abs32_cur_;
-  const size_t abs32_width_;
-  ConstBufferView gap_;
-};
-
-// A class to scan regions within an image to find successive rel32 references.
-// Architecture-specific parsing and result extraction are delegated to
-// inherited classes (say, Rel32Finder_Impl). Sample extraction loop, combined
-// with Abs32GapFinder usage:
-//
-//   Abs32GapFinder gap_finder(...);
-//   Rel32Finder_Impl finder(...);
-//   while (gap_finder.FindNext()) {
-//     rel_finder.SetRegion(gap_finder.GetGap());
-//     while (rel_finder.FindNext()) {
-//       auto rel32 = rel_finder.GetRel32();  // In Rel32Finder_Impl.
-//       if (architecture_specific_validation(rel32)) {
-//         rel_finder.Accept();
-//         // Store rel32.
-//       }
-//     }
-//   }
-class Rel32Finder {
- public:
-  Rel32Finder(ConstBufferView image, const AddressTranslator& translator);
-  Rel32Finder(const Rel32Finder&) = delete;
-  const Rel32Finder& operator=(const Rel32Finder&) = delete;
-  virtual ~Rel32Finder();
-
-  // Assigns the scan |region| for rel32 references to enable FindNext() use.
-  void SetRegion(ConstBufferView region);
-
-  // Scans for the next rel32 reference, and returns whether any is found, so a
-  // "while" loop can be used for iterative rel32 extraction. The results are
-  // cached in Rel32Finder_Impl and obtained by Rel32Finder_Impl::GetRel32().
-  bool FindNext();
-
-  // When a rel32 reference is found, the caller needs to decide whether to keep
-  // the result (perhaps following more validation). If it decides to keep the
-  // result, then it must call Accept(), so the next call to FindNext() can skip
-  // the accepted rel32 reference.
-  void Accept();
-
-  // Accessors for unittest.
-  ConstBufferView::const_iterator accept_it() const { return accept_it_; }
-  ConstBufferView region() const { return region_; }
-
- protected:
-  // Alternatives for where to continue the next scan when a rel32 reference is
-  // found. nulls indicate that no rel32 references remain.
-  struct NextIterators {
-    // The next iterator if the caller does not call Accept().
-    ConstBufferView::const_iterator reject;
-
-    // The next iterator if the caller calls Accept().
-    ConstBufferView::const_iterator accept;
-  };
-
-  // Detects and extracts architecture-specific rel32 reference. For each one
-  // found, the implementation should cache the necessary data to be retrieved
-  // via accessors. Returns a NextIterators that stores alternatives for where
-  // to continue the scan. If no rel32 reference is found then the returned
-  // NextIterators are nulls.
-  virtual NextIterators Scan(ConstBufferView region) = 0;
-
-  const ConstBufferView image_;
-  AddressTranslator::OffsetToRvaCache offset_to_rva_;
-
- private:
-  ConstBufferView region_;
-  ConstBufferView::const_iterator accept_it_ = nullptr;
-};
-
-// Parsing for X86 or X64: we perform naive scan for opcodes that have rel32 as
-// an argument, and disregard instruction alignment.
-class Rel32FinderIntel : public Rel32Finder {
- public:
-  Rel32FinderIntel(const Rel32FinderIntel&) = delete;
-  const Rel32FinderIntel& operator=(const Rel32FinderIntel&) = delete;
-
-  // Struct to store GetRel32() results.
-  struct Result {
-    offset_t location;
-    rva_t target_rva;
-
-    // Some references must have their target in the same section as location,
-    // which we use this to heuristically reject rel32 reference candidates.
-    // When true, this constraint is relaxed.
-    bool can_point_outside_section;
-  };
-
-  using Rel32Finder::Rel32Finder;
-
-  // Returns the cached result from the last successful FindNext().
-  const Result& GetRel32() { return rel32_; }
-
- protected:
-  // Helper for Scan() that also assigns |rel32_|.
-  Rel32Finder::NextIterators SetResult(ConstBufferView::const_iterator cursor,
-                                       uint32_t code_size,
-                                       bool can_point_outside_section);
-
-  // Cached results.
-  Result rel32_;
-
-  // Rel32Finder:
-  NextIterators Scan(ConstBufferView region) override = 0;
-};
-
-// X86 instructions.
-class Rel32FinderX86 : public Rel32FinderIntel {
- public:
-  using Rel32FinderIntel::Rel32FinderIntel;
-
-  Rel32FinderX86(const Rel32FinderX86&) = delete;
-  const Rel32FinderX86& operator=(const Rel32FinderX86&) = delete;
-
- private:
-  // Rel32Finder:
-  NextIterators Scan(ConstBufferView region) override;
-};
-
-// X64 instructions.
-class Rel32FinderX64 : public Rel32FinderIntel {
- public:
-  using Rel32FinderIntel::Rel32FinderIntel;
-
-  Rel32FinderX64(const Rel32FinderX64&) = delete;
-  const Rel32FinderX64& operator=(const Rel32FinderX64&) = delete;
-
- private:
-  // Rel32Finder:
-  NextIterators Scan(ConstBufferView region) override;
-};
-
-// Base class for ARM (AArch32 and AArch64) instructions.
-template <typename ADDR_TYPE>
-class Rel32FinderArm : public Rel32Finder {
- public:
-  struct Result {
-    offset_t location;
-    rva_t target_rva;
-    ADDR_TYPE type;
-
-    // For testing.
-    bool operator==(const Result& other) const {
-      return location == other.location && target_rva == other.target_rva &&
-             type == other.type;
-    }
-  };
-
-  Rel32FinderArm(ConstBufferView image, const AddressTranslator& translator);
-  Rel32FinderArm(const Rel32FinderArm&) = delete;
-  const Rel32FinderArm& operator=(const Rel32FinderArm&) = delete;
-  ~Rel32FinderArm() override;
-
-  // Helper for Scan*() that also assigns |rel32_|.
-  NextIterators SetResult(Result&& result,
-                          ConstBufferView::const_iterator cursor,
-                          int instr_size);
-
-  // SetResult() for end of scan.
-  NextIterators SetEmptyResult();
-
- protected:
-  // Cached results.
-  Result rel32_;
-};
-
-// AArch32 instructions.
-class Rel32FinderAArch32
-    : public Rel32FinderArm<AArch32Rel32Translator::AddrType> {
- public:
-  Rel32FinderAArch32(ConstBufferView image,
-                     const AddressTranslator& translator,
-                     bool is_thumb2);
-  Rel32FinderAArch32(const Rel32FinderAArch32&) = delete;
-  const Rel32FinderAArch32& operator=(const Rel32FinderAArch32&) = delete;
-  ~Rel32FinderAArch32() override;
-
-  const Result& GetRel32() const { return rel32_; }
-
- private:
-  // Rel32 extraction, assuming segment is in ARM mode.
-  NextIterators ScanA32(ConstBufferView region);
-
-  // Rel32 extraction, assuming segment is in THUMB2 mode.
-  NextIterators ScanT32(ConstBufferView region);
-
-  // Rel32Finder:
-  NextIterators Scan(ConstBufferView region) override;
-
-  // Indicates whether segment is in THUMB2 or ARM mod. In general this can
-  // change throughout a section. However, currently we assume that this is
-  // constant for an entire section.
-  const bool is_thumb2_;
-};
-
-// AArch64 instructions.
-class Rel32FinderAArch64
-    : public Rel32FinderArm<AArch64Rel32Translator::AddrType> {
- public:
-  Rel32FinderAArch64(ConstBufferView image,
-                     const AddressTranslator& translator);
-  Rel32FinderAArch64(const Rel32FinderAArch64&) = delete;
-  const Rel32FinderAArch64& operator=(const Rel32FinderAArch64&) = delete;
-  ~Rel32FinderAArch64() override;
-
-  const Result& GetRel32() const { return rel32_; }
-
- private:
-  // Rel32Finder:
-  NextIterators Scan(ConstBufferView region) override;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_REL32_FINDER_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_utils.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_utils.h
deleted file mode 100644
index 30dd4af..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/rel32_utils.h
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_REL32_UTILS_H_
-#define COMPONENTS_ZUCCHINI_REL32_UTILS_H_
-
-#include <algorithm>
-#include <deque>
-#include <memory>
-#include <optional>
-
-#include "base/logging.h"
-#include "components/zucchini/address_translator.h"
-#include "components/zucchini/arm_utils.h"
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/image_utils.h"
-#include "components/zucchini/io_utils.h"
-
-namespace zucchini {
-
-// Reader that emits x86 / x64 References (locations and target) from a list of
-// valid locations, constrained by a portion of an image.
-class Rel32ReaderX86 : public ReferenceReader {
- public:
-  // |image| is an image containing x86 / x64 code in [|lo|, |hi|).
-  // |locations| is a sorted list of offsets of rel32 reference locations.
-  // |translator| (for |image|) is embedded into |target_rva_to_offset_| and
-  // |location_offset_to_rva_| for address translation, and therefore must
-  // outlive |*this|.
-  Rel32ReaderX86(ConstBufferView image,
-                 offset_t lo,
-                 offset_t hi,
-                 const std::deque<offset_t>* locations,
-                 const AddressTranslator& translator);
-  Rel32ReaderX86(const Rel32ReaderX86&) = delete;
-  const Rel32ReaderX86& operator=(const Rel32ReaderX86&) = delete;
-  ~Rel32ReaderX86() override;
-
-  // Returns the next reference, or std::nullopt if exhausted.
-  std::optional<Reference> GetNext() override;
-
- private:
-  ConstBufferView image_;
-  AddressTranslator::RvaToOffsetCache target_rva_to_offset_;
-  AddressTranslator::OffsetToRvaCache location_offset_to_rva_;
-  const offset_t hi_;
-  const std::deque<offset_t>::const_iterator last_;
-  std::deque<offset_t>::const_iterator current_;
-};
-
-// Writer for x86 / x64 rel32 References.
-class Rel32WriterX86 : public ReferenceWriter {
- public:
-  // |image| wraps the raw bytes of a binary in which rel32 references will be
-  // written. |translator| (for |image|) is embedded into
-  // |target_offset_to_rva_| and |location_offset_to_rva_| for address
-  // translation, and therefore must outlive |*this|.
-  Rel32WriterX86(MutableBufferView image, const AddressTranslator& translator);
-  Rel32WriterX86(const Rel32WriterX86&) = delete;
-  const Rel32WriterX86& operator=(const Rel32WriterX86&) = delete;
-  ~Rel32WriterX86() override;
-
-  void PutNext(Reference ref) override;
-
- private:
-  MutableBufferView image_;
-  AddressTranslator::OffsetToRvaCache target_offset_to_rva_;
-  AddressTranslator::OffsetToRvaCache location_offset_to_rva_;
-};
-
-// Reader that emits x86 / x64 References (locations and target) of a spcific
-// type from a list of valid locations, constrained by a portion of an image.
-template <class ADDR_TRAITS>
-class Rel32ReaderArm : public ReferenceReader {
- public:
-  using CODE_T = typename ADDR_TRAITS::code_t;
-
-  Rel32ReaderArm(const AddressTranslator& translator,
-                 ConstBufferView view,
-                 const std::deque<offset_t>& rel32_locations,
-                 offset_t lo,
-                 offset_t hi)
-      : view_(view),
-        offset_to_rva_(translator),
-        rva_to_offset_(translator),
-        hi_(hi) {
-    cur_it_ =
-        std::lower_bound(rel32_locations.begin(), rel32_locations.end(), lo);
-    rel32_end_ = rel32_locations.end();
-  }
-
-  Rel32ReaderArm(const Rel32ReaderArm&) = delete;
-  const Rel32ReaderArm& operator=(const Rel32ReaderArm&) = delete;
-
-  std::optional<Reference> GetNext() override {
-    while (cur_it_ < rel32_end_ && *cur_it_ < hi_) {
-      offset_t location = *(cur_it_++);
-      CODE_T code = ADDR_TRAITS::Fetch(view_, location);
-      rva_t instr_rva = offset_to_rva_.Convert(location);
-      rva_t target_rva = kInvalidRva;
-      if (ADDR_TRAITS::Read(instr_rva, code, &target_rva)) {
-        offset_t target = rva_to_offset_.Convert(target_rva);
-        if (target != kInvalidOffset)
-          return Reference{location, target};
-      }
-    }
-    return std::nullopt;
-  }
-
- private:
-  ConstBufferView view_;
-  AddressTranslator::OffsetToRvaCache offset_to_rva_;
-  AddressTranslator::RvaToOffsetCache rva_to_offset_;
-  std::deque<offset_t>::const_iterator cur_it_;
-  std::deque<offset_t>::const_iterator rel32_end_;
-  offset_t hi_;
-};
-
-// Writer for ARM rel32 References of a specific type.
-template <class ADDR_TRAITS>
-class Rel32WriterArm : public ReferenceWriter {
- public:
-  using CODE_T = typename ADDR_TRAITS::code_t;
-
-  Rel32WriterArm(const AddressTranslator& translator,
-                 MutableBufferView mutable_view)
-      : mutable_view_(mutable_view), offset_to_rva_(translator) {}
-
-  Rel32WriterArm(const Rel32WriterArm&) = delete;
-  const Rel32WriterArm& operator=(const Rel32WriterArm&) = delete;
-
-  void PutNext(Reference ref) override {
-    CODE_T code = ADDR_TRAITS::Fetch(mutable_view_, ref.location);
-    rva_t instr_rva = offset_to_rva_.Convert(ref.location);
-    rva_t target_rva = offset_to_rva_.Convert(ref.target);
-    if (ADDR_TRAITS::Write(instr_rva, target_rva, &code)) {
-      ADDR_TRAITS::Store(mutable_view_, ref.location, code);
-    } else {
-      LOG(ERROR) << "Write error: " << AsHex<8>(ref.location) << ": "
-                 << AsHex<static_cast<int>(sizeof(CODE_T)) * 2>(code)
-                 << " <= " << AsHex<8>(target_rva) << ".";
-    }
-  }
-
- private:
-  MutableBufferView mutable_view_;
-  AddressTranslator::OffsetToRvaCache offset_to_rva_;
-};
-
-// Type for specialized versions of ArmCopyDisp().
-// TODO(etiennep/huangs): Fold ReferenceByteMixer into Disassembler and remove
-//     direct function pointer usage.
-using ArmCopyDispFun = bool (*)(ConstBufferView src_view,
-                                offset_t src_idx,
-                                MutableBufferView dst_view,
-                                offset_t dst_idx);
-
-// Copier that makes |*dst_it| similar to |*src_it| (both assumed to point to
-// rel32 instructions of type ADDR_TRAITS) by copying the displacement (i.e.,
-// payload bits) from |src_it| to |dst_it|. If successful, updates |*dst_it|,
-// and returns true. Otherwise returns false. Note that alignment is not an
-// issue since the displacement is not translated to target RVA!
-template <class ADDR_TRAITS>
-bool ArmCopyDisp(ConstBufferView src_view,
-                 offset_t src_idx,
-                 MutableBufferView dst_view,
-                 offset_t dst_idx) {
-  using CODE_T = typename ADDR_TRAITS::code_t;
-  CODE_T src_code = ADDR_TRAITS::Fetch(src_view, src_idx);
-  arm_disp_t disp = 0;
-  if (ADDR_TRAITS::Decode(src_code, &disp)) {
-    CODE_T dst_code = ADDR_TRAITS::Fetch(dst_view, dst_idx);
-    if (ADDR_TRAITS::Encode(disp, &dst_code)) {
-      ADDR_TRAITS::Store(dst_view, dst_idx, dst_code);
-      return true;
-    }
-  }
-  return false;
-}
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_REL32_UTILS_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reloc_elf.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reloc_elf.h
deleted file mode 100644
index f53aff2..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/reloc_elf.h
+++ /dev/null
@@ -1,102 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_RELOC_ELF_H_
-#define COMPONENTS_ZUCCHINI_RELOC_ELF_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <optional>
-#include <vector>
-
-#include "base/numerics/safe_conversions.h"
-#include "components/zucchini/address_translator.h"
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/image_utils.h"
-#include "components/zucchini/type_elf.h"
-
-namespace zucchini {
-
-// Section dimensions for ELF files, to store relevant dimensions data from
-// Elf32_Shdr and Elf64_Shdr, while reducing code duplication from templates.
-struct SectionDimensionsElf {
-  SectionDimensionsElf() = default;
-
-  template <class Elf_Shdr>
-  explicit SectionDimensionsElf(const Elf_Shdr& section)
-      : region(BufferRegion{base::checked_cast<size_t>(section.sh_offset),
-                            base::checked_cast<size_t>(section.sh_size)}),
-        entry_size(base::checked_cast<offset_t>(section.sh_entsize)) {}
-
-  friend bool operator<(const SectionDimensionsElf& a,
-                        const SectionDimensionsElf& b) {
-    return a.region.offset < b.region.offset;
-  }
-
-  friend bool operator<(offset_t offset, const SectionDimensionsElf& section) {
-    return offset < section.region.offset;
-  }
-
-  BufferRegion region;
-  offset_t entry_size;  // Varies across REL / RELA sections.
-};
-
-// A Generator to visit all reloc structs located in [|lo|, |hi|) (excluding
-// truncated strct at |lo| but inlcuding truncated struct at |hi|), and emit
-// valid References with |rel_type|. This implements a nested loop unrolled into
-// a generator: the outer loop has |cur_section_dimensions_| visiting
-// |reloc_section_dims| (sorted by |region.offset|), and the inner loop has
-// |cursor_| visiting successive reloc structs within |cur_section_dimensions_|.
-class RelocReaderElf : public ReferenceReader {
- public:
-  RelocReaderElf(
-      ConstBufferView image,
-      Bitness bitness,
-      const std::vector<SectionDimensionsElf>& reloc_section_dimensions,
-      uint32_t rel_type,
-      offset_t lo,
-      offset_t hi,
-      const AddressTranslator& translator);
-  ~RelocReaderElf() override;
-
-  // If |rel| contains |r_offset| for |rel_type_|, return the RVA. Otherwise
-  // return |kInvalidRva|. These also handle Elf*_Rela, by using the fact that
-  // Elf*_Rel is a prefix of Elf*_Rela.
-  rva_t GetRelocationTarget(elf::Elf32_Rel rel) const;
-  rva_t GetRelocationTarget(elf::Elf64_Rel rel) const;
-
-  // ReferenceReader:
-  std::optional<Reference> GetNext() override;
-
- private:
-  const ConstBufferView image_;
-  const Bitness bitness_;
-  const uint32_t rel_type_;
-  const std::vector<SectionDimensionsElf>& reloc_section_dimensions_;
-  std::vector<SectionDimensionsElf>::const_iterator cur_section_dimensions_;
-  offset_t hi_;
-  offset_t cursor_;
-  AddressTranslator::RvaToOffsetCache target_rva_to_offset_;
-};
-
-class RelocWriterElf : public ReferenceWriter {
- public:
-  RelocWriterElf(MutableBufferView image,
-                 Bitness bitness,
-                 const AddressTranslator& translator);
-  ~RelocWriterElf() override;
-
-  // ReferenceWriter:
-  void PutNext(Reference ref) override;
-
- private:
-  MutableBufferView image_;
-  const Bitness bitness_;
-  AddressTranslator::OffsetToRvaCache target_offset_to_rva_;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_RELOC_ELF_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/suffix_array.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/suffix_array.h
deleted file mode 100644
index 75b3a38..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/suffix_array.h
+++ /dev/null
@@ -1,475 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_SUFFIX_ARRAY_H_
-#define COMPONENTS_ZUCCHINI_SUFFIX_ARRAY_H_
-
-#include <algorithm>
-#include <iterator>
-#include <numeric>
-#include <vector>
-
-#include "base/check.h"
-
-namespace zucchini {
-
-// A functor class that implements the naive suffix sorting algorithm that uses
-// std::sort with lexicographical compare. This is only meant as reference of
-// the interface.
-class NaiveSuffixSort {
- public:
-  // Type requirements:
-  // |InputRng| is an input random access range.
-  // |KeyType| is an unsigned integer type.
-  // |SAIt| is a random access iterator with mutable references.
-  template <class InputRng, class KeyType, class SAIt>
-  // |str| is the input string on which suffix sort is applied.
-  // Characters found in |str| must be in the range [0, |key_bound|)
-  // |suffix_array| is the beginning of the destination range, which is at least
-  // as large as |str|.
-  void operator()(const InputRng& str,
-                  KeyType key_bound,
-                  SAIt suffix_array) const {
-    using size_type = typename SAIt::value_type;
-
-    size_type n = static_cast<size_type>(std::end(str) - std::begin(str));
-
-    // |suffix_array| is first filled with ordered indices of |str|.
-    // Those indices are then sorted with lexicographical comparisons in |str|.
-    std::iota(suffix_array, suffix_array + n, 0);
-    std::sort(suffix_array, suffix_array + n, [&str](size_type i, size_type j) {
-      return std::lexicographical_compare(std::begin(str) + i, std::end(str),
-                                          std::begin(str) + j, std::end(str));
-    });
-  }
-};
-
-// A functor class that implements suffix array induced sorting (SA-IS)
-// algorithm with linear time and memory complexity,
-// see http://ieeexplore.ieee.org/abstract/document/5582081/
-class InducedSuffixSort {
- public:
-  // Type requirements:
-  // |InputRng| is an input random access range.
-  // |KeyType| is an unsigned integer type.
-  // |SAIt| is a random access iterator with mutable values.
-  template <class InputRng, class KeyType, class SAIt>
-  // |str| is the input string on which suffix sort is applied.
-  // Characters found in |str| must be in the range [0, |key_bound|)
-  // |suffix_array| is the beginning of the destination range, which is at least
-  // as large as |str|.
-  void operator()(const InputRng& str,
-                  KeyType key_bound,
-                  SAIt suffix_array) const {
-    using value_type = typename InputRng::value_type;
-    using size_type = typename SAIt::value_type;
-
-    static_assert(std::is_unsigned<value_type>::value,
-                  "SA-IS only supports input string with unsigned values");
-    static_assert(std::is_unsigned<KeyType>::value, "KeyType must be unsigned");
-
-    size_type n = static_cast<size_type>(std::end(str) - std::begin(str));
-
-    Implementation<size_type, KeyType>::SuffixSort(std::begin(str), n,
-                                                   key_bound, suffix_array);
-  }
-
-  // Given string S of length n. We assume S is terminated by a unique sentinel
-  // $, which is considered as the smallest character. This sentinel does not
-  // exist in memory and is only treated implicitly, hence |n| does not count
-  // the sentinel in this implementation. We denote suf(S,i) the suffix formed
-  // by S[i..n).
-
-  // A suffix suf(S,i) is said to be S-type or L-type, if suf(S,i) < suf(S,i+1)
-  // or suf(S,i) > suf(S,i+1), respectively.
-  enum SLType : bool { SType, LType };
-
-  // A character S[i] is said to be S-type or L-type if the suffix suf(S,i) is
-  // S-type or L-type, respectively.
-
-  // A character S[i] is called LMS (leftmost S-type), if S[i] is S-type and
-  // S[i-1] is L-type. A suffix suf(S,i) is called LMS, if S[i] is an LMS
-  // character.
-
-  // A substring S[i..j) is an LMS-substring if
-  // (1) S[i] is LMS, S[j] is LMS or the sentinel $, and S[i..j) has no other
-  //     LMS characters, or
-  // (2) S[i..j) is the sentinel $.
-
-  template <class SizeType, class KeyType>
-  struct Implementation {
-    static_assert(std::is_unsigned<SizeType>::value,
-                  "SizeType must be unsigned");
-    static_assert(std::is_unsigned<KeyType>::value, "KeyType must be unsigned");
-    using size_type = SizeType;
-    using key_type = KeyType;
-
-    using iterator = typename std::vector<size_type>::iterator;
-    using const_iterator = typename std::vector<size_type>::const_iterator;
-
-    // Partition every suffix based on SL-type. Returns the number of LMS
-    // suffixes.
-    template <class StrIt>
-    static size_type BuildSLPartition(
-        StrIt str,
-        size_type length,
-        key_type key_bound,
-        std::vector<SLType>::reverse_iterator sl_partition_it) {
-      // We will count LMS suffixes (S to L-type or last S-type).
-      size_type lms_count = 0;
-
-      // |previous_type| is initialized to L-type to avoid counting an extra
-      // LMS suffix at the end
-      SLType previous_type = LType;
-
-      // Initialized to dummy, impossible key.
-      key_type previous_key = key_bound;
-
-      // We're travelling backward to determine the partition,
-      // as if we prepend one character at a time to the string, ex:
-      // b$ is L-type because b > $.
-      // ab$ is S-type because a < b, implying ab$ < b$.
-      // bab$ is L-type because b > a, implying bab$ > ab$.
-      // bbab$ is L-type, because bab$ was also L-type, implying bbab$ > bab$.
-      for (auto str_it = std::reverse_iterator<StrIt>(str + length);
-           str_it != std::reverse_iterator<StrIt>(str);
-           ++str_it, ++sl_partition_it) {
-        key_type current_key = *str_it;
-
-        if (current_key > previous_key || previous_key == key_bound) {
-          // S[i] > S[i + 1] or S[i] is last character.
-          if (previous_type == SType)
-            // suf(S,i) is L-type and suf(S,i + 1) is S-type, therefore,
-            // suf(S,i+1) was a LMS suffix.
-            ++lms_count;
-
-          previous_type = LType;  // For next round.
-        } else if (current_key < previous_key) {
-          // S[i] < S[i + 1]
-          previous_type = SType;  // For next round.
-        }
-        // Else, S[i] == S[i + 1]:
-        // The next character that differs determines the SL-type,
-        // so we reuse the last seen type.
-
-        *sl_partition_it = previous_type;
-        previous_key = current_key;  // For next round.
-      }
-
-      return lms_count;
-    }
-
-    // Find indices of LMS suffixes and write result to |lms_indices|.
-    static void FindLmsSuffixes(const std::vector<SLType>& sl_partition,
-                                iterator lms_indices) {
-      // |previous_type| is initialized to S-type to avoid counting an extra
-      // LMS suffix at the beginning
-      SLType previous_type = SType;
-      for (size_type i = 0; i < sl_partition.size(); ++i) {
-        if (sl_partition[i] == SType && previous_type == LType)
-          *lms_indices++ = i;
-        previous_type = sl_partition[i];
-      }
-    }
-
-    template <class StrIt>
-    static std::vector<size_type> MakeBucketCount(StrIt str,
-                                                  size_type length,
-                                                  key_type key_bound) {
-      // Occurrence of every unique character is counted in |buckets|
-      std::vector<size_type> buckets(static_cast<size_type>(key_bound));
-
-      for (auto it = str; it != str + length; ++it)
-        ++buckets[*it];
-      return buckets;
-    }
-
-    // Apply induced sort from |lms_indices| to |suffix_array| associated with
-    // the string |str|.
-    template <class StrIt, class SAIt>
-    static void InducedSort(StrIt str,
-                            size_type length,
-                            const std::vector<SLType>& sl_partition,
-                            const std::vector<size_type>& lms_indices,
-                            const std::vector<size_type>& buckets,
-                            SAIt suffix_array) {
-      // All indices are first marked as unset with the illegal value |length|.
-      std::fill(suffix_array, suffix_array + length, length);
-
-      // Used to mark bucket boundaries (head or end) as indices in str.
-      DCHECK(!buckets.empty());
-      std::vector<size_type> bucket_bounds(buckets.size());
-
-      // Step 1: Assign indices for LMS suffixes, populating the end of
-      // respective buckets but keeping relative order.
-
-      // Find the end of each bucket and write it to |bucket_bounds|.
-      std::partial_sum(buckets.begin(), buckets.end(), bucket_bounds.begin());
-
-      // Process each |lms_indices| backward, and assign them to the end of
-      // their respective buckets, so relative order is preserved.
-      for (auto it = lms_indices.crbegin(); it != lms_indices.crend(); ++it) {
-        key_type key = str[*it];
-        suffix_array[--bucket_bounds[key]] = *it;
-      }
-
-      // Step 2
-      // Scan forward |suffix_array|; for each modified suf(S,i) for which
-      // suf(S,SA(i) - 1) is L-type, place suf(S,SA(i) - 1) to the current
-      // head of the corresponding bucket and forward the bucket head to the
-      // right.
-
-      // Find the head of each bucket and write it to |bucket_bounds|. Since
-      // only LMS suffixes where inserted in |suffix_array| during Step 1,
-      // |bucket_bounds| does not contains the head of each bucket and needs to
-      // be updated.
-      bucket_bounds[0] = 0;
-      std::partial_sum(buckets.begin(), buckets.end() - 1,
-                       bucket_bounds.begin() + 1);
-
-      // From Step 1, the sentinel $, which we treat implicitly, would have
-      // been placed at the beginning of |suffix_array|, since $ is always
-      // considered as the smallest character. We then have to deal with the
-      // previous (last) suffix.
-      if (sl_partition[length - 1] == LType) {
-        key_type key = str[length - 1];
-        suffix_array[bucket_bounds[key]++] = length - 1;
-      }
-      for (auto it = suffix_array; it != suffix_array + length; ++it) {
-        size_type suffix_index = *it;
-
-        // While the original algorithm marks unset suffixes with -1,
-        // we found that marking them with |length| is also possible and more
-        // convenient because we are working with unsigned integers.
-        if (suffix_index != length && suffix_index > 0 &&
-            sl_partition[--suffix_index] == LType) {
-          key_type key = str[suffix_index];
-          suffix_array[bucket_bounds[key]++] = suffix_index;
-        }
-      }
-
-      // Step 3
-      // Scan backward |suffix_array|; for each modified suf(S, i) for which
-      // suf(S,SA(i) - 1) is S-type, place suf(S,SA(i) - 1) to the current
-      // end of the corresponding bucket and forward the bucket head to the
-      // left.
-
-      // Find the end of each bucket and write it to |bucket_bounds|. Since
-      // only L-type suffixes where inserted in |suffix_array| during Step 2,
-      // |bucket_bounds| does not contain the end of each bucket and needs to
-      // be updated.
-      std::partial_sum(buckets.begin(), buckets.end(), bucket_bounds.begin());
-
-      for (auto it = std::reverse_iterator<SAIt>(suffix_array + length);
-           it != std::reverse_iterator<SAIt>(suffix_array); ++it) {
-        size_type suffix_index = *it;
-        if (suffix_index != length && suffix_index > 0 &&
-            sl_partition[--suffix_index] == SType) {
-          key_type key = str[suffix_index];
-          suffix_array[--bucket_bounds[key]] = suffix_index;
-        }
-      }
-      // Deals with the last suffix, because of the sentinel.
-      if (sl_partition[length - 1] == SType) {
-        key_type key = str[length - 1];
-        suffix_array[--bucket_bounds[key]] = length - 1;
-      }
-    }
-
-    // Given a string S starting at |str| with length |length|, an array
-    // starting at |substring_array| containing lexicographically ordered LMS
-    // terminated substring indices of S and an SL-Type partition |sl_partition|
-    // of S, assigns a unique label to every unique LMS substring. The sorted
-    // labels for all LMS substrings are written to |lms_str|, while the indices
-    // of LMS suffixes are written to |lms_indices|. In addition, returns the
-    // total number of unique labels.
-    template <class StrIt, class SAIt>
-    static size_type LabelLmsSubstrings(StrIt str,
-                                        size_type length,
-                                        const std::vector<SLType>& sl_partition,
-                                        SAIt suffix_array,
-                                        iterator lms_indices,
-                                        iterator lms_str) {
-      // Labelling starts at 0.
-      size_type label = 0;
-
-      // |previous_lms| is initialized to 0 to indicate it is unset.
-      // Note that suf(S,0) is never a LMS suffix. Substrings will be visited in
-      // lexicographical order.
-      size_type previous_lms = 0;
-      for (auto it = suffix_array; it != suffix_array + length; ++it) {
-        if (*it > 0 && sl_partition[*it] == SType &&
-            sl_partition[*it - 1] == LType) {
-          // suf(S, *it) is a LMS suffix.
-
-          size_type current_lms = *it;
-          if (previous_lms != 0) {
-            // There was a previous LMS suffix. Check if the current LMS
-            // substring is equal to the previous one.
-            SLType current_lms_type = SType;
-            SLType previous_lms_type = SType;
-            for (size_type k = 0;; ++k) {
-              // |current_lms_end| and |previous_lms_end| denote whether we have
-              // reached the end of the current and previous LMS substring,
-              // respectively
-              bool current_lms_end = false;
-              bool previous_lms_end = false;
-
-              // Check for both previous and current substring ends.
-              // Note that it is more convenient to check if
-              // suf(S,current_lms + k) is an LMS suffix than to retrieve it
-              // from lms_indices.
-              if (current_lms + k >= length ||
-                  (current_lms_type == LType &&
-                   sl_partition[current_lms + k] == SType)) {
-                current_lms_end = true;
-              }
-              if (previous_lms + k >= length ||
-                  (previous_lms_type == LType &&
-                   sl_partition[previous_lms + k] == SType)) {
-                previous_lms_end = true;
-              }
-
-              if (current_lms_end && previous_lms_end) {
-                break;  // Previous and current substrings are identical.
-              } else if (current_lms_end != previous_lms_end ||
-                         str[current_lms + k] != str[previous_lms + k]) {
-                // Previous and current substrings differ, a new label is used.
-                ++label;
-                break;
-              }
-
-              current_lms_type = sl_partition[current_lms + k];
-              previous_lms_type = sl_partition[previous_lms + k];
-            }
-          }
-          *lms_indices++ = *it;
-          *lms_str++ = label;
-          previous_lms = current_lms;
-        }
-      }
-
-      return label + 1;
-    }
-
-    // Implementation of the SA-IS algorithm. |str| must be a random access
-    // iterator pointing at the beginning of S with length |length|. The result
-    // is writtend in |suffix_array|, a random access iterator.
-    template <class StrIt, class SAIt>
-    static void SuffixSort(StrIt str,
-                           size_type length,
-                           key_type key_bound,
-                           SAIt suffix_array) {
-      if (length == 1)
-        *suffix_array = 0;
-      if (length < 2)
-        return;
-
-      std::vector<SLType> sl_partition(length);
-      size_type lms_count =
-          BuildSLPartition(str, length, key_bound, sl_partition.rbegin());
-      std::vector<size_type> lms_indices(lms_count);
-      FindLmsSuffixes(sl_partition, lms_indices.begin());
-      std::vector<size_type> buckets = MakeBucketCount(str, length, key_bound);
-
-      if (lms_indices.size() > 1) {
-        // Given |lms_indices| in the same order they appear in |str|, induce
-        // LMS substrings relative order and write result to |suffix_array|.
-        InducedSort(str, length, sl_partition, lms_indices, buckets,
-                    suffix_array);
-        std::vector<size_type> lms_str(lms_indices.size());
-
-        // Given LMS substrings in relative order found in |suffix_array|,
-        // map LMS substrings to unique labels to form a new string, |lms_str|.
-        size_type label_count =
-            LabelLmsSubstrings(str, length, sl_partition, suffix_array,
-                               lms_indices.begin(), lms_str.begin());
-
-        if (label_count < lms_str.size()) {
-          // Reorder |lms_str| to have LMS suffixes in the same order they
-          // appear in |str|.
-          for (size_type i = 0; i < lms_indices.size(); ++i)
-            suffix_array[lms_indices[i]] = lms_str[i];
-
-          SLType previous_type = SType;
-          for (size_type i = 0, j = 0; i < sl_partition.size(); ++i) {
-            if (sl_partition[i] == SType && previous_type == LType) {
-              lms_str[j] = suffix_array[i];
-              lms_indices[j++] = i;
-            }
-            previous_type = sl_partition[i];
-          }
-
-          // Recursively apply SuffixSort on |lms_str|, which is formed from
-          // labeled LMS suffixes in the same order they appear in |str|.
-          // Note that |KeyType| will be size_type because |lms_str| contains
-          // indices. |lms_str| is at most half the length of |str|.
-          Implementation<size_type, size_type>::SuffixSort(
-              lms_str.begin(), static_cast<size_type>(lms_str.size()),
-              label_count, suffix_array);
-
-          // Map LMS labels back to indices in |str| and write result to
-          // |lms_indices|. We're using |suffix_array| as a temporary buffer.
-          for (size_type i = 0; i < lms_indices.size(); ++i)
-            suffix_array[i] = lms_indices[suffix_array[i]];
-          std::copy_n(suffix_array, lms_indices.size(), lms_indices.begin());
-
-          // At this point, |lms_indices| contains sorted LMS suffixes of |str|.
-        }
-      }
-      // Given |lms_indices| where LMS suffixes are sorted, induce the full
-      // order of suffixes in |str|.
-      InducedSort(str, length, sl_partition, lms_indices, buckets,
-                  suffix_array);
-    }
-
-    Implementation() = delete;
-    Implementation(const Implementation&) = delete;
-    const Implementation& operator=(const Implementation&) = delete;
-  };
-};
-
-// Generates a sorted suffix array for the input string |str| using the functor
-// |Algorithm| which provides an interface equivalent to NaiveSuffixSort.
-/// Characters found in |str| are assumed to be in range [0, |key_bound|).
-// Returns the suffix array as a vector.
-// |StrRng| is an input random access range.
-// |KeyType| is an unsigned integer type.
-template <class Algorithm, class StrRng, class KeyType>
-std::vector<typename StrRng::size_type> MakeSuffixArray(const StrRng& str,
-                                                        KeyType key_bound) {
-  Algorithm sort;
-  std::vector<typename StrRng::size_type> suffix_array(str.end() - str.begin());
-  sort(str, key_bound, suffix_array.begin());
-  return suffix_array;
-}
-
-// Type requirements:
-// |SARng| is an input random access range.
-// |StrIt1| is a random access iterator.
-// |StrIt2| is a forward iterator.
-template <class SARng, class StrIt1, class StrIt2>
-// Lexicographical lower bound using binary search for
-// [|str2_first|, |str2_last|) in the suffix array |suffix_array| of a string
-// starting at |str1_first|. This does not necessarily return the index of
-// the longest matching substring.
-auto SuffixLowerBound(const SARng& suffix_array,
-                      StrIt1 str1_first,
-                      StrIt2 str2_first,
-                      StrIt2 str2_last) -> decltype(std::begin(suffix_array)) {
-  using size_type = typename SARng::value_type;
-
-  size_t n = std::end(suffix_array) - std::begin(suffix_array);
-  auto it = std::lower_bound(
-      std::begin(suffix_array), std::end(suffix_array), str2_first,
-      [str1_first, str2_last, n](size_type a, StrIt2 b) {
-        return std::lexicographical_compare(str1_first + a, str1_first + n, b,
-                                            str2_last);
-      });
-  return it;
-}
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_SUFFIX_ARRAY_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/target_pool.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/target_pool.h
deleted file mode 100644
index fb462b2..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/target_pool.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_TARGET_POOL_H_
-#define COMPONENTS_ZUCCHINI_TARGET_POOL_H_
-
-#include <stddef.h>
-
-#include <deque>
-#include <vector>
-
-#include "components/zucchini/image_utils.h"
-#include "components/zucchini/patch_reader.h"
-
-namespace zucchini {
-
-class OffsetMapper;
-class TargetSource;
-
-// Ordered container of distinct targets that have the same semantics, along
-// with a list of associated reference types, only used during patch generation.
-class TargetPool {
- public:
-  using const_iterator = std::deque<offset_t>::const_iterator;
-
-  TargetPool();
-  // Initializes the object with given sorted and unique |targets|.
-  explicit TargetPool(std::deque<offset_t>&& targets);
-  TargetPool(TargetPool&&);
-  TargetPool(const TargetPool&);
-  ~TargetPool();
-
-  // Insert new targets from various sources. These invalidate all previous key
-  // lookups.
-  // - From a list of targets, useful for adding extra targets in Zucchini-gen:
-  void InsertTargets(const std::vector<offset_t>& targets);
-  // - From TargetSource, useful for adding extra targets in Zucchini-apply:
-  void InsertTargets(TargetSource* targets);
-  // - From list of References, useful for listing targets in Zucchini-gen:
-  void InsertTargets(const std::vector<Reference>& references);
-  // - From ReferenceReader, useful for listing targets in Zucchini-apply:
-  void InsertTargets(ReferenceReader&& references);
-
-  // Adds |type| as a reference type associated with the pool of targets.
-  void AddType(TypeTag type) { types_.push_back(type); }
-
-  // Returns a canonical key associated with a valid target at |offset|.
-  key_t KeyForOffset(offset_t offset) const;
-
-  // Returns a canonical key associated with the target nearest to |offset|.
-  key_t KeyForNearestOffset(offset_t offset) const;
-
-  // Returns the target for a |key|, which is assumed to be valid and held by
-  // this class.
-  offset_t OffsetForKey(key_t key) const { return targets_[key]; }
-
-  // Returns whether a particular key is valid.
-  bool KeyIsValid(key_t key) const { return key < targets_.size(); }
-
-  // Uses |offset_mapper| to transform "old" |targets_| to "new" |targets_|,
-  // resulting in sorted and unique targets.
-  void FilterAndProject(const OffsetMapper& offset_mapper);
-
-  // Accessors for testing.
-  const std::deque<offset_t>& targets() const { return targets_; }
-  const std::vector<TypeTag>& types() const { return types_; }
-
-  // Returns the number of targets.
-  size_t size() const { return targets_.size(); }
-  const_iterator begin() const { return targets_.cbegin(); }
-  const_iterator end() const { return targets_.cend(); }
-
- private:
-  std::vector<TypeTag> types_;     // Enumerates type_tag for this pool.
-  std::deque<offset_t> targets_;   // Targets for pool in ascending order.
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_TARGET_POOL_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/targets_affinity.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/targets_affinity.h
deleted file mode 100644
index 163b015..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/targets_affinity.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_TARGETS_AFFINITY_H_
-#define COMPONENTS_ZUCCHINI_TARGETS_AFFINITY_H_
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <deque>
-#include <vector>
-
-#include "components/zucchini/image_utils.h"
-
-namespace zucchini {
-
-class EquivalenceMap;
-
-// Computes and stores affinity between old and new targets for a single target
-// pool. This is only used during patch generation.
-class TargetsAffinity {
- public:
-  TargetsAffinity();
-  TargetsAffinity(const TargetsAffinity&) = delete;
-  const TargetsAffinity& operator=(const TargetsAffinity&) = delete;
-  ~TargetsAffinity();
-
-  // Infers affinity between |old_targets| and |new_targets| using similarities
-  // described by |equivalence_map|, and updates internal state for retrieval of
-  // affinity scores. Both |old_targets| and |new_targets| are targets in the
-  // same pool and are sorted in ascending order.
-  void InferFromSimilarities(const EquivalenceMap& equivalence_map,
-                             const std::deque<offset_t>& old_targets,
-                             const std::deque<offset_t>& new_targets);
-
-  // Assigns labels to targets based on associations previously inferred, using
-  // |min_affinity| to reject associations with weak |affinity|. Label 0 is
-  // assigned to unassociated targets. Labels for old targets are written to
-  // |old_labels| and labels for new targets are written to |new_labels|.
-  // Returns the upper bound on assigned labels (>= 1 since 0 is used).
-  uint32_t AssignLabels(double min_affinity,
-                        std::vector<uint32_t>* old_labels,
-                        std::vector<uint32_t>* new_labels);
-
-  // Returns the affinity score between targets identified by |old_key| and
-  // |new_keys|. Affinity > 0 means an association is likely, < 0 means
-  // incompatible association, and 0 means neither targets have been associated.
-  double AffinityBetween(key_t old_key, key_t new_key) const;
-
- private:
-  struct Association {
-    key_t other = 0;
-    double affinity = 0.0;
-  };
-
-  // Forward and backward associations between old and new targets. For each
-  // Association element, if |affinity == 0.0| then no association is defined
-  // (and |other| is meaningless|. Otherwise |affinity > 0.0|, and the
-  // association between |old_labels[old_key]| and |new_labels[new_key]| is
-  // represented by:
-  //   forward_association_[old_key].other == new_key;
-  //   backward_association_[new_key].other == old_key;
-  //   forward_association_[old_key].affinity ==
-  //       backward_association_[new_key].affinity;
-  // The two lists contain the same information, but having both enables quick
-  // lookup, given |old_key| or |new_key|.
-  std::vector<Association> forward_association_;
-  std::vector<Association> backward_association_;
-};
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_TARGETS_AFFINITY_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_dex.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_dex.h
deleted file mode 100644
index ee61ecd..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_dex.h
+++ /dev/null
@@ -1,332 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_TYPE_DEX_H_
-#define COMPONENTS_ZUCCHINI_TYPE_DEX_H_
-
-#include <stdint.h>
-
-namespace zucchini {
-namespace dex {
-// Contains types that models DEX executable format data structures.
-// See https://source.android.com/devices/tech/dalvik/dex-format
-
-// The supported versions are 035, 037, 038, and 039.
-
-enum class FormatId : uint8_t {
-  b,  // 22b.
-  c,  // 21c, 22c, 31c, 35c, 3rc, 45cc, 4rcc.
-  h,  // 21h.
-  i,  // 31i.
-  l,  // 51l.
-  n,  // 11n.
-  s,  // 21s, 22s.
-  t,  // 10t, 20t, 21t, 22t, 30t, 31t.
-  x,  // 10x, 11x, 12x, 22x, 23x, 32x.
-};
-
-struct Instruction {
-  Instruction() = default;
-  constexpr Instruction(uint8_t opcode_in,
-                        uint8_t layout_in,
-                        FormatId format_in,
-                        uint8_t variant_in = 1)
-      : opcode(opcode_in),
-        layout(layout_in),
-        format(format_in),
-        variant(variant_in) {}
-
-  // The opcode that identifies the instruction.
-  uint8_t opcode;
-  // Number of uint16_t units for the instruction.
-  uint8_t layout;
-  // Identifier that groups similar instructions, as quick filter.
-  FormatId format;
-  // Number of successive opcodes that have the same format.
-  uint8_t variant = 1;
-};
-
-constexpr Instruction kByteCode[] = {
-    {0x00, 1, FormatId::x},
-    {0x01, 1, FormatId::x},
-    {0x02, 2, FormatId::x},
-    {0x03, 3, FormatId::x},
-    {0x04, 1, FormatId::x},
-    {0x05, 2, FormatId::x},
-    {0x06, 3, FormatId::x},
-    {0x07, 1, FormatId::x},
-    {0x08, 2, FormatId::x},
-    {0x09, 3, FormatId::x},
-    {0x0A, 1, FormatId::x},
-    {0x0B, 1, FormatId::x},
-    {0x0C, 1, FormatId::x},
-    {0x0D, 1, FormatId::x},
-    {0x0E, 1, FormatId::x},
-    {0x0F, 1, FormatId::x},
-    {0x10, 1, FormatId::x},
-    {0x11, 1, FormatId::x},
-    {0x12, 1, FormatId::n},
-    {0x13, 2, FormatId::s},
-    {0x14, 3, FormatId::i},
-    {0x15, 2, FormatId::h},
-    {0x16, 2, FormatId::s},
-    {0x17, 3, FormatId::i},
-    {0x18, 5, FormatId::l},
-    {0x19, 2, FormatId::h},
-    {0x1A, 2, FormatId::c},
-    {0x1B, 3, FormatId::c},
-    {0x1C, 2, FormatId::c},
-    {0x1D, 1, FormatId::x},
-    {0x1E, 1, FormatId::x},
-    {0x1F, 2, FormatId::c},
-    {0x20, 2, FormatId::c},
-    {0x21, 1, FormatId::x},
-    {0x22, 2, FormatId::c},
-    {0x23, 2, FormatId::c},
-    {0x24, 3, FormatId::c},
-    {0x25, 3, FormatId::c},
-    {0x26, 3, FormatId::t},
-    {0x27, 1, FormatId::x},
-    {0x28, 1, FormatId::t},
-    {0x29, 2, FormatId::t},
-    {0x2A, 3, FormatId::t},
-    {0x2B, 3, FormatId::t},
-    {0x2C, 3, FormatId::t},
-    {0x2D, 2, FormatId::x, 5},
-    {0x32, 2, FormatId::t, 6},
-    {0x38, 2, FormatId::t, 6},
-    // {0x3E, 1, FormatId::x, 6}, unused
-    {0x44, 2, FormatId::x, 14},
-    {0x52, 2, FormatId::c, 14},
-    {0x60, 2, FormatId::c, 14},
-    {0x6E, 3, FormatId::c, 5},
-    // {0x73, 1, FormatId::x}, unused
-    {0x74, 3, FormatId::c, 5},
-    // {0x79, 1, FormatId::x, 2}, unused
-    {0x7B, 1, FormatId::x, 21},
-    {0x90, 2, FormatId::x, 32},
-    {0xB0, 1, FormatId::x, 32},
-    {0xD0, 2, FormatId::s, 8},
-    {0xD8, 2, FormatId::b, 11},
-    // {0xE3, 1, FormatId::x, 29}, unused
-    {0xFA, 4, FormatId::c},
-    {0xFB, 4, FormatId::c},
-    {0xFC, 3, FormatId::c},
-    {0xFD, 3, FormatId::c},
-    {0xFE, 2, FormatId::c},
-    {0xFF, 2, FormatId::c},
-};
-
-// Supported by MSVC, g++, and clang++. Ensures no gaps in packing.
-#pragma pack(push, 1)
-
-// header_item: Appears in the header section.
-struct HeaderItem {
-  uint8_t magic[8];
-  uint32_t checksum;
-  uint8_t signature[20];
-  uint32_t file_size;
-  uint32_t header_size;
-  uint32_t endian_tag;
-  uint32_t link_size;
-  uint32_t link_off;
-  uint32_t map_off;
-  uint32_t string_ids_size;
-  uint32_t string_ids_off;
-  uint32_t type_ids_size;
-  uint32_t type_ids_off;
-  uint32_t proto_ids_size;
-  uint32_t proto_ids_off;
-  uint32_t field_ids_size;
-  uint32_t field_ids_off;
-  uint32_t method_ids_size;
-  uint32_t method_ids_off;
-  uint32_t class_defs_size;
-  uint32_t class_defs_off;
-  uint32_t data_size;
-  uint32_t data_off;
-};
-
-// string_id_item: String identifiers list.
-struct StringIdItem {
-  uint32_t string_data_off;
-};
-
-// type_id_item: Type identifiers list.
-struct TypeIdItem {
-  uint32_t descriptor_idx;
-};
-
-// proto_id_item: Method prototype identifiers list.
-struct ProtoIdItem {
-  uint32_t shorty_idx;
-  uint32_t return_type_idx;
-  uint32_t parameters_off;
-};
-
-// field_id_item: Field identifiers list.
-struct FieldIdItem {
-  uint16_t class_idx;
-  uint16_t type_idx;
-  uint32_t name_idx;
-};
-
-// method_id_item: Method identifiers list.
-struct MethodIdItem {
-  uint16_t class_idx;
-  uint16_t proto_idx;
-  uint32_t name_idx;
-};
-
-// class_def_item: Class definitions list.
-struct ClassDefItem {
-  uint32_t class_idx;
-  uint32_t access_flags;
-  uint32_t superclass_idx;
-  uint32_t interfaces_off;
-  uint32_t source_file_idx;
-  uint32_t annotations_off;
-  uint32_t class_data_off;
-  uint32_t static_values_off;
-};
-
-// call_site_id_item: Call site identifiers list.
-struct CallSiteIdItem {
-  uint32_t call_site_off;
-};
-
-// method_handle_type: Determines the behavior of the MethodHandleItem.
-enum class MethodHandleType : uint16_t {
-  // FieldId
-  kStaticPut = 0x00,
-  kStaticGet = 0x01,
-  kInstancePut = 0x02,
-  kInstanceGet = 0x03,
-  // MethodId
-  kInvokeStatic = 0x04,
-  kInvokeInstance = 0x05,
-  kInvokeConstructor = 0x06,
-  kInvokeDirect = 0x07,
-  kInvokeInterface = 0x08,
-  // Sentinel. If new types are added put them before this and increment.
-  kMaxMethodHandleType = 0x09
-};
-
-// method_handle_item: Method handles referred within the Dex file.
-struct MethodHandleItem {
-  uint16_t method_handle_type;
-  uint16_t unused_1;
-  uint16_t field_or_method_id;
-  uint16_t unused_2;
-};
-
-// code_item: Header of a code item.
-struct CodeItem {
-  uint16_t registers_size;
-  uint16_t ins_size;
-  uint16_t outs_size;
-  uint16_t tries_size;
-  uint32_t debug_info_off;
-  uint32_t insns_size;
-  // Variable length data follow for complete code item.
-};
-
-// Number of valid type codes for map_item elements in map_list.
-// See: https://source.android.com/devices/tech/dalvik/dex-format#type-codes
-constexpr uint32_t kMaxItemListSize = 21;
-
-constexpr uint16_t kTypeHeaderItem = 0x0000;
-constexpr uint16_t kTypeStringIdItem = 0x0001;
-constexpr uint16_t kTypeTypeIdItem = 0x0002;
-constexpr uint16_t kTypeProtoIdItem = 0x0003;
-constexpr uint16_t kTypeFieldIdItem = 0x0004;
-constexpr uint16_t kTypeMethodIdItem = 0x0005;
-constexpr uint16_t kTypeClassDefItem = 0x0006;
-constexpr uint16_t kTypeCallSiteIdItem = 0x0007;
-constexpr uint16_t kTypeMethodHandleItem = 0x0008;
-constexpr uint16_t kTypeMapList = 0x1000;
-constexpr uint16_t kTypeTypeList = 0x1001;
-constexpr uint16_t kTypeAnnotationSetRefList = 0x1002;
-constexpr uint16_t kTypeAnnotationSetItem = 0x1003;
-constexpr uint16_t kTypeClassDataItem = 0x2000;
-constexpr uint16_t kTypeCodeItem = 0x2001;
-constexpr uint16_t kTypeStringDataItem = 0x2002;
-constexpr uint16_t kTypeDebugInfoItem = 0x2003;
-constexpr uint16_t kTypeAnnotationItem = 0x2004;
-constexpr uint16_t kTypeEncodedArrayItem = 0x2005;
-constexpr uint16_t kTypeAnnotationsDirectoryItem = 0x2006;
-constexpr uint16_t kTypeHiddenApiClassDataItem = 0xF000;
-
-// map_item
-struct MapItem {
-  uint16_t type;
-  uint16_t unused;
-  uint32_t size;
-  uint32_t offset;
-};
-
-// map_list
-struct MapList {
-  uint32_t size;
-  MapItem list[kMaxItemListSize];
-};
-
-// type_item
-struct TypeItem {
-  uint16_t type_idx;
-};
-
-// annotation_set_ref_item
-struct AnnotationSetRefItem {
-  uint32_t annotations_off;
-};
-
-// annotation_off_item
-struct AnnotationOffItem {
-  uint32_t annotation_off;
-};
-
-// field_annotation
-struct FieldAnnotation {
-  uint32_t field_idx;
-  uint32_t annotations_off;
-};
-
-// method_annotation
-struct MethodAnnotation {
-  uint32_t method_idx;
-  uint32_t annotations_off;
-};
-
-// parameter_annotation
-struct ParameterAnnotation {
-  uint32_t method_idx;
-  uint32_t annotations_off;
-};
-
-// annotations_directory_item
-struct AnnotationsDirectoryItem {
-  uint32_t class_annotations_off;
-  uint32_t fields_size;
-  uint32_t annotated_methods_size;
-  uint32_t annotated_parameters_size;
-  // FieldAnnotation field_annotations[fields_size];
-  // MethodAnnotation method_annotations[annotated_methods_size];
-  // ParameterAnnotation parameter_annotations[annotated_parameters_size];
-  // All *Annotation are 8 bytes each.
-};
-
-// try_item
-struct TryItem {
-  uint32_t start_addr;
-  uint16_t insn_count;
-  uint16_t handler_off;
-};
-
-#pragma pack(pop)
-
-}  // namespace dex
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_TYPE_DEX_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_elf.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_elf.h
deleted file mode 100644
index 2a522b1..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/type_elf.h
+++ /dev/null
@@ -1,283 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_TYPE_ELF_H_
-#define COMPONENTS_ZUCCHINI_TYPE_ELF_H_
-
-#include <stdint.h>
-
-namespace zucchini {
-
-// Structures and constants taken from linux/elf.h and following identical
-// layout. This is used for parsing of Executable and Linkable Format (ELF).
-namespace elf {
-// Supported by MSVC, g++, and clang++. Ensures no gaps in packing.
-#pragma pack(push, 1)
-
-// This header defines various types from the ELF file spec, but no code
-// related to using them.
-
-typedef uint32_t Elf32_Addr;  // Unsigned program address.
-typedef uint16_t Elf32_Half;  // Unsigned medium integer.
-typedef uint32_t Elf32_Off;   // Unsigned file offset.
-typedef int32_t Elf32_Sword;  // Signed large integer.
-typedef uint32_t Elf32_Word;  // Unsigned large integer.
-
-typedef uint64_t Elf64_Addr;   // Unsigned program address.
-typedef uint16_t Elf64_Half;   // Unsigned medium integer.
-typedef uint64_t Elf64_Off;    // Unsigned file offset.
-typedef int32_t Elf64_Sword;   // Signed large integer.
-typedef uint32_t Elf64_Word;   // Unsigned large integer.
-typedef int64_t Elf64_Sxword;  // Signed extra large integer.
-typedef uint64_t Elf64_Xword;  // Unsigned extra large integer.
-
-// The header at the top of the file.
-struct Elf32_Ehdr {
-  unsigned char e_ident[16];
-  Elf32_Half e_type;
-  Elf32_Half e_machine;
-  Elf32_Word e_version;
-  Elf32_Addr e_entry;
-  Elf32_Off e_phoff;
-  Elf32_Off e_shoff;
-  Elf32_Word e_flags;
-  Elf32_Half e_ehsize;
-  Elf32_Half e_phentsize;
-  Elf32_Half e_phnum;
-  Elf32_Half e_shentsize;
-  Elf32_Half e_shnum;
-  Elf32_Half e_shstrndx;
-};
-
-struct Elf64_Ehdr {
-  unsigned char e_ident[16];
-  Elf64_Half e_type;
-  Elf64_Half e_machine;
-  Elf64_Word e_version;
-  Elf64_Addr e_entry;
-  Elf64_Off e_phoff;
-  Elf64_Off e_shoff;
-  Elf64_Word e_flags;
-  Elf64_Half e_ehsize;
-  Elf64_Half e_phentsize;
-  Elf64_Half e_phnum;
-  Elf64_Half e_shentsize;
-  Elf64_Half e_shnum;
-  Elf64_Half e_shstrndx;
-};
-
-// Identification Indexes in header->e_ident.
-enum IdentificationIndex {
-  EI_MAG0 = 0,        // File identification.
-  EI_MAG1 = 1,        // File identification.
-  EI_MAG2 = 2,        // File identification.
-  EI_MAG3 = 3,        // File identification.
-  EI_CLASS = 4,       // File class.
-  EI_DATA = 5,        // Data encoding.
-  EI_VERSION = 6,     // File version.
-  EI_OSABI = 7,       // Operating system/ABI identification.
-  EI_ABIVERSION = 8,  // ABI version.
-  EI_PAD = 9,         // Start of padding bytes.
-  EI_NIDENT = 16      // Size of e_ident[].
-};
-
-// Values for header->e_ident[EI_CLASS].
-enum FileClass {
-  ELFCLASSNONE = 0,  // Invalid class.
-  ELFCLASS32 = 1,    // 32-bit objects.
-  ELFCLASS64 = 2     // 64-bit objects.
-};
-
-// Values for header->e_type.
-enum FileType {
-  ET_NONE = 0,         // No file type
-  ET_REL = 1,          // Relocatable file
-  ET_EXEC = 2,         // Executable file
-  ET_DYN = 3,          // Shared object file
-  ET_CORE = 4,         // Core file
-  ET_LOPROC = 0xFF00,  // Processor-specific
-  ET_HIPROC = 0xFFFF   // Processor-specific
-};
-
-// Values for header->e_machine.
-enum MachineArchitecture {
-  EM_NONE = 0,       // No machine.
-  EM_386 = 3,        // Intel Architecture.
-  EM_ARM = 40,       // ARM Architecture.
-  EM_X86_64 = 62,    // Intel x86-64 Architecture.
-  EM_AARCH64 = 183,  // ARM Architecture, 64-bit.
-  // Other values skipped.
-};
-
-// A section header in the section header table.
-struct Elf32_Shdr {
-  Elf32_Word sh_name;
-  Elf32_Word sh_type;
-  Elf32_Word sh_flags;
-  Elf32_Addr sh_addr;
-  Elf32_Off sh_offset;
-  Elf32_Word sh_size;
-  Elf32_Word sh_link;
-  Elf32_Word sh_info;
-  Elf32_Word sh_addralign;
-  Elf32_Word sh_entsize;
-};
-
-struct Elf64_Shdr {
-  Elf64_Word sh_name;
-  Elf64_Word sh_type;
-  Elf64_Xword sh_flags;
-  Elf64_Addr sh_addr;
-  Elf64_Off sh_offset;
-  Elf64_Xword sh_size;
-  Elf64_Word sh_link;
-  Elf64_Word sh_info;
-  Elf64_Xword sh_addralign;
-  Elf64_Xword sh_entsize;
-};
-
-// Values for the section type field in a section header.
-enum sh_type_values {
-  SHT_NULL = 0,
-  SHT_PROGBITS = 1,
-  SHT_SYMTAB = 2,
-  SHT_STRTAB = 3,
-  SHT_RELA = 4,
-  SHT_HASH = 5,
-  SHT_DYNAMIC = 6,
-  SHT_NOTE = 7,
-  SHT_NOBITS = 8,
-  SHT_REL = 9,
-  SHT_SHLIB = 10,
-  SHT_DYNSYM = 11,
-  SHT_INIT_ARRAY = 14,
-  SHT_FINI_ARRAY = 15,
-  SHT_LOPROC = 0x70000000,
-  SHT_HIPROC = 0x7FFFFFFF,
-  SHT_LOUSER = 0x80000000,
-  SHT_HIUSER = 0xFFFFFFFF
-};
-
-enum sh_flag_masks {
-  SHF_WRITE = 1 << 0,
-  SHF_ALLOC = 1 << 1,
-  SHF_EXECINSTR = 1 << 2,
-  // 1 << 3 is reserved.
-  SHF_MERGE = 1 << 4,
-  SHF_STRINGS = 1 << 5,
-  SHF_INFO_LINK = 1 << 6,
-  SHF_LINK_ORDER = 1 << 7,
-  SHF_OS_NONCONFORMING = 1 << 8,
-  SHF_GROUP = 1 << 9,
-  SHF_TLS = 1 << 10,
-  SHF_COMPRESSED = 1 << 11,
-};
-
-struct Elf32_Phdr {
-  Elf32_Word p_type;
-  Elf32_Off p_offset;
-  Elf32_Addr p_vaddr;
-  Elf32_Addr p_paddr;
-  Elf32_Word p_filesz;
-  Elf32_Word p_memsz;
-  Elf32_Word p_flags;
-  Elf32_Word p_align;
-};
-
-struct Elf64_Phdr {
-  Elf64_Word p_type;
-  Elf64_Word p_flags;
-  Elf64_Off p_offset;
-  Elf64_Addr p_vaddr;
-  Elf64_Addr p_paddr;
-  Elf64_Xword p_filesz;
-  Elf64_Xword p_memsz;
-  Elf64_Xword p_align;
-};
-
-// Values for the segment type field in a program segment header.
-enum ph_type_values {
-  PT_NULL = 0,
-  PT_LOAD = 1,
-  PT_DYNAMIC = 2,
-  PT_INTERP = 3,
-  PT_NOTE = 4,
-  PT_SHLIB = 5,
-  PT_PHDR = 6,
-  PT_LOPROC = 0x70000000,
-  PT_HIPROC = 0x7FFFFFFF
-};
-
-struct Elf32_Rel {
-  Elf32_Addr r_offset;
-  Elf32_Word r_info;
-};
-
-struct Elf64_Rel {
-  Elf64_Addr r_offset;
-  Elf64_Xword r_info;
-};
-
-struct Elf32_Rela {
-  Elf32_Addr r_offset;
-  Elf32_Word r_info;
-  Elf32_Sword r_addend;
-};
-
-struct Elf64_Rela {
-  Elf64_Addr r_offset;
-  Elf64_Xword r_info;
-  Elf64_Sxword r_addend;
-};
-
-enum elf32_rel_386_type_values {
-  R_386_NONE = 0,
-  R_386_32 = 1,
-  R_386_PC32 = 2,
-  R_386_GOT32 = 3,
-  R_386_PLT32 = 4,
-  R_386_COPY = 5,
-  R_386_GLOB_DAT = 6,
-  R_386_JMP_SLOT = 7,
-  R_386_RELATIVE = 8,
-  R_386_GOTOFF = 9,
-  R_386_GOTPC = 10,
-  R_386_TLS_TPOFF = 14,
-};
-
-enum elf32_rel_x86_64_type_values {
-  R_X86_64_NONE = 0,
-  R_X86_64_64 = 1,
-  R_X86_64_PC32 = 2,
-  R_X86_64_GOT32 = 3,
-  R_X86_64_PLT32 = 4,
-  R_X86_64_COPY = 5,
-  R_X86_64_GLOB_DAT = 6,
-  R_X86_64_JUMP_SLOT = 7,
-  R_X86_64_RELATIVE = 8,
-  R_X86_64_GOTPCREL = 9,
-  R_X86_64_32 = 10,
-  R_X86_64_32S = 11,
-  R_X86_64_16 = 12,
-  R_X86_64_PC16 = 13,
-  R_X86_64_8 = 14,
-  R_X86_64_PC8 = 15,
-};
-
-enum elf32_rel_arm_type_values {
-  R_ARM_RELATIVE = 23,
-};
-
-enum elf64_rel_aarch64_type_values {
-  R_AARCH64_GLOB_DAT = 0x401,
-  R_AARCH64_JUMP_SLOT = 0x402,
-  R_AARCH64_RELATIVE = 0x403,
-};
-
-#pragma pack(pop)
-
-}  // namespace elf
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_TYPE_ELF_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/typed_value.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/typed_value.h
deleted file mode 100644
index 868397c..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/typed_value.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_TYPED_VALUE_H_
-#define COMPONENTS_ZUCCHINI_TYPED_VALUE_H_
-
-#include <ostream>
-
-namespace zucchini {
-
-// Strong typed values, with compare and convert functions for underlying data.
-// Typically one would use strongly typed enums for this. However, for Zucchini,
-// the number of bytes is not fixed, and must be represented as an integer for
-// iteration.
-// |Tag| is a type tag used to uniquely identify TypedValue.
-// |T| is an integral type used to hold values.
-// Example:
-//    struct Foo : TypedValue<Foo, int> {
-//      using Foo::TypedValue::TypedValue; // inheriting constructor.
-//    };
-// Foo will be used to hold values of type |int|, but with a distinct type from
-// any other TypedValue.
-template <class Tag, class T>
-class TypedValue {
- public:
-  constexpr TypedValue() = default;
-  explicit constexpr TypedValue(const T& value) : value_(value) {}
-
-  explicit operator T() const { return value_; }
-  const T value() const { return value_; }
-
-  friend bool operator==(const TypedValue& a, const TypedValue& b) {
-    return a.value_ == b.value_;
-  }
-  friend bool operator!=(const TypedValue& a, const TypedValue& b) {
-    return !(a == b);
-  }
-  friend bool operator<(const TypedValue& a, const TypedValue& b) {
-    return a.value_ < b.value_;
-  }
-  friend bool operator>(const TypedValue& a, const TypedValue& b) {
-    return b < a;
-  }
-
- private:
-  T value_ = {};
-};
-
-template <class Tag, class T>
-std::ostream& operator<<(std::ostream& os, const TypedValue<Tag, T>& tag) {
-  return os << tag.value();
-}
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_TYPED_VALUE_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/version_info.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/version_info.h
deleted file mode 100644
index c6d2fac..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/version_info.h
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2021 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_VERSION_INFO_H_
-#define COMPONENTS_ZUCCHINI_VERSION_INFO_H_
-
-// This file serves as a stable location for main Zucchini version constants,
-// whose names and types should also be stable. These allow external tools to
-// determine Zucchini version at compile time by inclusion or parsing.
-
-namespace zucchini {
-
-// A change in major version indicates breaking changes such that a patch
-// definitely cannot be applied by a zucchini binary whose major version doesn't
-// match.
-enum : uint16_t { kMajorVersion = 1 };
-
-// A change in minor version indicates possibly breaking changes at the element
-// level, such that it may not be possible to apply a patch whose minor version
-// doesn't match this version. To determine if a given patch may be applied with
-// this version, VerifyPatch() should be called.
-enum : uint16_t { kMinorVersion = 0 };
-
-// A empty or error value for major or minor version numbers.
-enum : uint16_t { kInvalidVersion = 0xffff };
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_VERSION_INFO_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini.h
deleted file mode 100644
index 9847440..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini.h
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_ZUCCHINI_H_
-#define COMPONENTS_ZUCCHINI_ZUCCHINI_H_
-
-#include <string>
-
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/patch_reader.h"
-#include "components/zucchini/patch_writer.h"
-
-// Core Zucchini library, consisting of:
-// - Global constants.
-// - Patch gen and apply functions, where "old" and "new" data are represented
-//   as buffers, and patch data represented as EnsemblePatchWriter or
-//   EnsemblePatchReader.
-
-namespace zucchini {
-
-namespace status {
-
-// Zucchini status code, which can also be used as process exit code. Therefore
-// success is explicitly 0.
-enum Code {
-  kStatusSuccess = 0,
-  kStatusInvalidParam = 1,
-  kStatusFileReadError = 2,
-  kStatusFileWriteError = 3,
-  kStatusPatchReadError = 4,
-  kStatusPatchWriteError = 5,
-  kStatusInvalidOldImage = 6,
-  kStatusInvalidNewImage = 7,
-  kStatusFatal = 8,
-};
-
-}  // namespace status
-
-// Generates ensemble patch from |old_image| to |new_image| using the default
-// element detection and matching heuristics, writes the results to
-// |patch_writer|, and returns a status::Code.
-status::Code GenerateBuffer(ConstBufferView old_image,
-                            ConstBufferView new_image,
-                            EnsemblePatchWriter* patch_writer);
-
-// Same as GenerateEnsemble(), but if |imposed_matches| is non-empty, then
-// overrides default element detection and matching heuristics with custom
-// element matching encoded in |imposed_matches|, which should be formatted as:
-//   "#+#=#+#,#+#=#+#,..."  (e.g., "1+2=3+4", "1+2=3+4,5+6=7+8"),
-// where "#+#=#+#" encodes a match as 4 unsigned integers:
-//   [offset in "old", size in "old", offset in "new", size in "new"].
-status::Code GenerateBufferImposed(ConstBufferView old_image,
-                                   ConstBufferView new_image,
-                                   std::string imposed_matches,
-                                   EnsemblePatchWriter* patch_writer);
-
-// Generates raw patch from |old_image| to |new_image|, and writes it to
-// |patch_writer|.
-status::Code GenerateBufferRaw(ConstBufferView old_image,
-                               ConstBufferView new_image,
-                               EnsemblePatchWriter* patch_writer);
-
-// Applies |patch_reader| to |old_image| to build |new_image|, which refers to
-// preallocated memory of sufficient size.
-status::Code ApplyBuffer(ConstBufferView old_image,
-                         const EnsemblePatchReader& patch_reader,
-                         MutableBufferView new_image);
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_ZUCCHINI_H_
diff --git a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini_apply.h b/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini_apply.h
deleted file mode 100644
index abab384..0000000
--- a/native/zucchini/vendor/zucchini/aosp/include/components/zucchini/zucchini_apply.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef COMPONENTS_ZUCCHINI_ZUCCHINI_APPLY_H_
-#define COMPONENTS_ZUCCHINI_ZUCCHINI_APPLY_H_
-
-#include "components/zucchini/image_utils.h"
-#include "components/zucchini/patch_reader.h"
-#include "components/zucchini/zucchini.h"
-
-namespace zucchini {
-
-// Reads equivalences from |patch_reader| to form preliminary |new_image|,
-// copying regions from |old_image| and writing extra data from |patch_reader|.
-bool ApplyEquivalenceAndExtraData(ConstBufferView old_image,
-                                  const PatchElementReader& patch_reader,
-                                  MutableBufferView new_image);
-
-// Reads raw delta from |patch_reader| and applies corrections to |new_image|.
-bool ApplyRawDelta(const PatchElementReader& patch_reader,
-                   MutableBufferView new_image);
-
-// Corrects references in |new_image| by projecting references from |old_image|
-// and applying corrections from |patch_reader|. Both |old_image| and
-// |new_image| are matching elements associated with |exe_type|.
-bool ApplyReferencesCorrection(ExecutableType exe_type,
-                               ConstBufferView old_image,
-                               const PatchElementReader& patch_reader,
-                               MutableBufferView new_image);
-
-// Applies patch element with type |exe_type| from |patch_reader| on |old_image|
-// to produce |new_image|.
-bool ApplyElement(ExecutableType exe_type,
-                  ConstBufferView old_image,
-                  const PatchElementReader& patch_reader,
-                  MutableBufferView new_image);
-
-}  // namespace zucchini
-
-#endif  // COMPONENTS_ZUCCHINI_ZUCCHINI_APPLY_H_
diff --git a/native/zucchini/vendor/zucchini/arm_utils.cc b/native/zucchini/vendor/zucchini/arm_utils.cc
deleted file mode 100644
index 2a915a8..0000000
--- a/native/zucchini/vendor/zucchini/arm_utils.cc
+++ /dev/null
@@ -1,597 +0,0 @@
-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/arm_utils.h"
-
-#include "components/zucchini/algorithm.h"
-
-namespace zucchini {
-
-namespace {
-
-inline bool IsMisaligned(rva_t rva, ArmAlign align) {
-  return (rva & (align - 1)) != 0;
-}
-
-}  // namespace
-
-/******** AArch32Rel32Translator ********/
-
-AArch32Rel32Translator::AArch32Rel32Translator() = default;
-
-// The mapping between ARM instruction "Code" to "Displacement" involves complex
-// bit manipulation. The comments below annotate bits mappings using a string.
-// * Bits are listed from highest-order to lowerst-order (like in the manual).
-// * '0' and '1' denote literals.
-// * Uppercase letters denote a single bit in "Code". For example, 'S' denotes
-//   a sign bit that gets extended in "Displacement". To follow naming in the
-//   manual, these may enumerated, and written as "(I1)", "(I2)", etc.
-// * Lowercase letters denote bit fields with orders preserved.
-
-// static
-ArmAlign AArch32Rel32Translator::DecodeA24(uint32_t code32, arm_disp_t* disp) {
-  // Handle multiple instructions. Let cccc != 1111:
-  // B encoding A1:
-  //   Code:         cccc1010 Siiiiiii iiiiiiii iiiiiiii
-  //   Displacement: SSSSSSSi iiiiiiii iiiiiiii iiiiii00
-  // BL encoding A1:
-  //   Code:         cccc1011 Siiiiiii iiiiiiii iiiiiiii
-  //   Displacement: SSSSSSSi iiiiiiii iiiiiiii iiiiii00
-  // BLX encoding A2:
-  //   Code:         1111101H Siiiiiii iiiiiiii iiiiiiii
-  //   Displacement: SSSSSSSi iiiiiiii iiiiiiii iiiiiiH0
-  uint8_t bits = GetUnsignedBits<24, 27>(code32);
-  if (bits == 0xA || bits == 0xB) {  // B, BL, or BLX.
-    *disp = GetSignedBits<0, 23>(code32) << 2;
-    uint8_t cond = GetUnsignedBits<28, 31>(code32);
-    if (cond == 0xF) {  // BLX.
-      uint32_t H = GetBit<24>(code32);
-      *disp |= H << 1;
-      return kArmAlign2;
-    }
-    return kArmAlign4;
-  }
-  return kArmAlignFail;
-}
-
-// static
-bool AArch32Rel32Translator::EncodeA24(arm_disp_t disp, uint32_t* code32) {
-  uint32_t t = *code32;
-  uint8_t bits = GetUnsignedBits<24, 27>(t);
-  if (bits == 0xA || bits == 0xB) {
-    // B, BL, or BLX.
-    if (!SignedFit<26>(disp))  // Detect overflow.
-      return false;
-    uint8_t cond = GetUnsignedBits<28, 31>(t);
-    if (cond == 0xF) {
-      if (disp % 2)  // BLX (encoding A2) requires 2-byte alignment.
-        return false;
-      uint32_t H = GetBit<1>(disp);
-      t = (t & 0xFEFFFFFF) | (H << 24);
-    } else {
-      if (disp % 4)  // B and BL require 4-byte alignment.
-        return false;
-    }
-    t = (t & 0xFF000000) | ((disp >> 2) & 0x00FFFFFF);
-    *code32 = t;
-    return true;
-  }
-  return false;
-}
-
-// static
-bool AArch32Rel32Translator::ReadA24(rva_t instr_rva,
-                                     uint32_t code32,
-                                     rva_t* target_rva) {
-  constexpr ArmAlign kInstrAlign = kArmAlign4;
-  if (IsMisaligned(instr_rva, kInstrAlign))
-    return false;
-  arm_disp_t disp;
-  ArmAlign target_align = DecodeA24(code32, &disp);
-  if (target_align == kArmAlignFail)
-    return false;
-  *target_rva = GetArmTargetRvaFromDisp(instr_rva, disp, target_align);
-  return true;
-}
-
-// static
-bool AArch32Rel32Translator::WriteA24(rva_t instr_rva,
-                                      rva_t target_rva,
-                                      uint32_t* code32) {
-  constexpr ArmAlign kInstrAlign = kArmAlign4;
-  if (IsMisaligned(instr_rva, kInstrAlign))
-    return false;
-  // Dummy decode to get |target_align|.
-  arm_disp_t dummy_disp;
-  ArmAlign target_align = DecodeA24(*code32, &dummy_disp);
-  if (target_align == kArmAlignFail || IsMisaligned(target_rva, target_align))
-    return false;
-  arm_disp_t disp =
-      GetArmDispFromTargetRva(instr_rva, target_rva, target_align);
-  return EncodeA24(disp, code32);
-}
-
-// static
-ArmAlign AArch32Rel32Translator::DecodeT8(uint16_t code16, arm_disp_t* disp) {
-  if ((code16 & 0xF000) == 0xD000 && (code16 & 0x0F00) != 0x0F00) {
-    // B encoding T1:
-    //   Code:         1101cccc Siiiiiii
-    //   Displacement: SSSSSSSS SSSSSSSS SSSSSSSS iiiiiii0
-    *disp = GetSignedBits<0, 7>(code16) << 1;
-    return kArmAlign2;
-  }
-  return kArmAlignFail;
-}
-
-// static
-bool AArch32Rel32Translator::EncodeT8(arm_disp_t disp, uint16_t* code16) {
-  uint16_t t = *code16;
-  if ((t & 0xF000) == 0xD000 && (t & 0x0F00) != 0x0F00) {
-    if (disp % 2)  // Require 2-byte alignment.
-      return false;
-    if (!SignedFit<9>(disp))  // Detect overflow.
-      return false;
-    t = (t & 0xFF00) | ((disp >> 1) & 0x00FF);
-    *code16 = t;
-    return true;
-  }
-  return false;
-}
-
-// static
-bool AArch32Rel32Translator::ReadT8(rva_t instr_rva,
-                                    uint16_t code16,
-                                    rva_t* target_rva) {
-  constexpr ArmAlign kInstrAlign = kArmAlign2;
-  if (IsMisaligned(instr_rva, kInstrAlign))
-    return false;
-  arm_disp_t disp;
-  ArmAlign target_align = DecodeT8(code16, &disp);
-  if (target_align == kArmAlignFail)
-    return false;
-  *target_rva = GetThumb2TargetRvaFromDisp(instr_rva, disp, target_align);
-  return true;
-}
-
-// static
-bool AArch32Rel32Translator::WriteT8(rva_t instr_rva,
-                                     rva_t target_rva,
-                                     uint16_t* code16) {
-  constexpr ArmAlign kInstrAlign = kArmAlign2;
-  constexpr ArmAlign kTargetAlign = kArmAlign2;
-  if (IsMisaligned(instr_rva, kInstrAlign) ||
-      IsMisaligned(target_rva, kTargetAlign)) {
-    return false;
-  }
-  arm_disp_t disp =
-      GetThumb2DispFromTargetRva(instr_rva, target_rva, kTargetAlign);
-  return EncodeT8(disp, code16);
-}
-
-// static
-ArmAlign AArch32Rel32Translator::DecodeT11(uint16_t code16, arm_disp_t* disp) {
-  if ((code16 & 0xF800) == 0xE000) {
-    // B encoding T2:
-    //   Code:         11100Sii iiiiiiii
-    //   Displacement: SSSSSSSS SSSSSSSS SSSSSiii iiiiiii0
-    *disp = GetSignedBits<0, 10>(code16) << 1;
-    return kArmAlign2;
-  }
-  return kArmAlignFail;
-}
-
-// static
-bool AArch32Rel32Translator::EncodeT11(arm_disp_t disp, uint16_t* code16) {
-  uint16_t t = *code16;
-  if ((t & 0xF800) == 0xE000) {
-    if (disp % 2)  // Require 2-byte alignment.
-      return false;
-    if (!SignedFit<12>(disp))  // Detect overflow.
-      return false;
-    t = (t & 0xF800) | ((disp >> 1) & 0x07FF);
-    *code16 = t;
-    return true;
-  }
-  return false;
-}
-
-// static
-bool AArch32Rel32Translator::ReadT11(rva_t instr_rva,
-                                     uint16_t code16,
-                                     rva_t* target_rva) {
-  constexpr ArmAlign kInstrAlign = kArmAlign2;
-  if (IsMisaligned(instr_rva, kInstrAlign))
-    return false;
-  arm_disp_t disp;
-  ArmAlign target_align = DecodeT11(code16, &disp);
-  if (target_align == kArmAlignFail)
-    return false;
-  *target_rva = GetThumb2TargetRvaFromDisp(instr_rva, disp, target_align);
-  return true;
-}
-
-// static
-bool AArch32Rel32Translator::WriteT11(rva_t instr_rva,
-                                      rva_t target_rva,
-                                      uint16_t* code16) {
-  constexpr ArmAlign kInstrAlign = kArmAlign2;
-  constexpr ArmAlign kTargetAlign = kArmAlign2;
-  if (IsMisaligned(instr_rva, kInstrAlign) ||
-      IsMisaligned(target_rva, kTargetAlign)) {
-    return false;
-  }
-  arm_disp_t disp =
-      GetThumb2DispFromTargetRva(instr_rva, target_rva, kTargetAlign);
-  return EncodeT11(disp, code16);
-}
-
-// static
-ArmAlign AArch32Rel32Translator::DecodeT20(uint32_t code32, arm_disp_t* disp) {
-  if ((code32 & 0xF800D000) == 0xF0008000 &&
-      (code32 & 0x03C00000) != 0x03C00000) {
-    // B encoding T3. Note the reversal of "(J1)" and "(J2)".
-    //   Code:         11110Scc cciiiiii 10(J1)0(J2)jjj jjjjjjjj
-    //   Displacement: SSSSSSSS SSSS(J2)(J1)ii iiiijjjj jjjjjjj0
-    uint32_t imm11 = GetUnsignedBits<0, 10>(code32);  // jj...j.
-    uint32_t J2 = GetBit<11>(code32);
-    uint32_t J1 = GetBit<13>(code32);
-    uint32_t imm6 = GetUnsignedBits<16, 21>(code32);  // ii...i.
-    uint32_t S = GetBit<26>(code32);
-    uint32_t t = (imm6 << 12) | (imm11 << 1);
-    t |= (S << 20) | (J2 << 19) | (J1 << 18);
-    *disp = SignExtend<20, int32_t>(t);
-    return kArmAlign2;
-  }
-  return kArmAlignFail;
-}
-
-// static
-bool AArch32Rel32Translator::EncodeT20(arm_disp_t disp, uint32_t* code32) {
-  uint32_t t = *code32;
-  if ((t & 0xF800D000) == 0xF0008000 && (t & 0x03C00000) != 0x03C00000) {
-    if (disp % 2)  // Require 2-byte alignment.
-      return false;
-    if (!SignedFit<21>(disp))  // Detect overflow.
-      return false;
-    uint32_t S = GetBit<20>(disp);
-    uint32_t J2 = GetBit<19>(disp);
-    uint32_t J1 = GetBit<18>(disp);
-    uint32_t imm6 = GetUnsignedBits<12, 17>(disp);  // ii...i.
-    uint32_t imm11 = GetUnsignedBits<1, 11>(disp);  // jj...j.
-    t &= 0xFBC0D000;
-    t |= (S << 26) | (imm6 << 16) | (J1 << 13) | (J2 << 11) | imm11;
-    *code32 = t;
-    return true;
-  }
-  return false;
-}
-
-// static
-bool AArch32Rel32Translator::ReadT20(rva_t instr_rva,
-                                     uint32_t code32,
-                                     rva_t* target_rva) {
-  constexpr ArmAlign kInstrAlign = kArmAlign2;
-  if (IsMisaligned(instr_rva, kInstrAlign))
-    return false;
-  arm_disp_t disp;
-  ArmAlign target_align = DecodeT20(code32, &disp);
-  if (target_align == kArmAlignFail)
-    return false;
-  *target_rva = GetThumb2TargetRvaFromDisp(instr_rva, disp, target_align);
-  return true;
-}
-
-// static
-bool AArch32Rel32Translator::WriteT20(rva_t instr_rva,
-                                      rva_t target_rva,
-                                      uint32_t* code32) {
-  constexpr ArmAlign kInstrAlign = kArmAlign2;
-  constexpr ArmAlign kTargetAlign = kArmAlign2;
-  if (IsMisaligned(instr_rva, kInstrAlign) ||
-      IsMisaligned(target_rva, kTargetAlign)) {
-    return false;
-  }
-  arm_disp_t disp =
-      GetThumb2DispFromTargetRva(instr_rva, target_rva, kTargetAlign);
-  return EncodeT20(disp, code32);
-}
-
-// static
-ArmAlign AArch32Rel32Translator::DecodeT24(uint32_t code32, arm_disp_t* disp) {
-  uint32_t bits = code32 & 0xF800D000;
-  if (bits == 0xF0009000 || bits == 0xF000D000 || bits == 0xF000C000) {
-    // Let I1 = J1 ^ S ^ 1, I2 = J2 ^ S ^ 1.
-    // B encoding T4:
-    //   Code:         11110Sii iiiiiiii 10(J1)1(J2)jjj jjjjjjjj
-    //   Displacement: SSSSSSSS (I1)(I2)iiiiii iiiijjjj jjjjjjj0
-    // BL encoding T1:
-    //   Code:         11110Sii iiiiiiii 11(J1)1(J2)jjj jjjjjjjj
-    //   Displacement: SSSSSSSS (I1)(I2)iiiiii iiiijjjj jjjjjjj0
-    // BLX encoding T2: H should be 0:
-    //   Code:         11110Sii iiiiiiii 11(J1)0(J2)jjj jjjjjjjH
-    //   Displacement: SSSSSSSS (I1)(I2)iiiiii iiiijjjj jjjjjjH0
-    uint32_t imm11 = GetUnsignedBits<0, 10>(code32);  // jj...j.
-    uint32_t J2 = GetBit<11>(code32);
-    uint32_t J1 = GetBit<13>(code32);
-    uint32_t imm10 = GetUnsignedBits<16, 25>(code32);  // ii...i.
-    uint32_t S = GetBit<26>(code32);
-    uint32_t t = (imm10 << 12) | (imm11 << 1);
-    t |= (S << 24) | ((J1 ^ S ^ 1) << 23) | ((J2 ^ S ^ 1) << 22);
-    t = SignExtend<24, int32_t>(t);
-    // BLX encoding T2 requires final target to be 4-byte aligned by rounding
-    // downward. This is applied to |t| *after* clipping.
-    ArmAlign target_align = kArmAlign2;
-    if (bits == 0xF000C000) {
-      uint32_t H = GetBit<0>(code32);
-      if (H)
-        return kArmAlignFail;  // Illegal instruction: H must be 0.
-      target_align = kArmAlign4;
-    }
-    *disp = static_cast<int32_t>(t);
-    return target_align;
-  }
-  return kArmAlignFail;
-}
-
-// static
-bool AArch32Rel32Translator::EncodeT24(arm_disp_t disp, uint32_t* code32) {
-  uint32_t t = *code32;
-  uint32_t bits = t & 0xF800D000;
-  if (bits == 0xF0009000 || bits == 0xF000D000 || bits == 0xF000C000) {
-    if (disp % 2)  // Require 2-byte alignment.
-      return false;
-    // BLX encoding T2 requires H == 0, and that |disp| results in |target_rva|
-    // with a 4-byte aligned address.
-    if (bits == 0xF000C000) {
-      uint32_t H = GetBit<1>(disp);
-      if (H)
-        return false;  // Illegal |disp|: H must be 0.
-    }
-    if (!SignedFit<25>(disp))  // Detect overflow.
-      return false;
-    uint32_t imm11 = GetUnsignedBits<1, 11>(disp);   // jj...j.
-    uint32_t imm10 = GetUnsignedBits<12, 21>(disp);  // ii...i.
-    uint32_t I2 = GetBit<22>(disp);
-    uint32_t I1 = GetBit<23>(disp);
-    uint32_t S = GetBit<24>(disp);
-    t &= 0xF800D000;
-    t |= (S << 26) | (imm10 << 16) | ((I1 ^ S ^ 1) << 13) |
-         ((I2 ^ S ^ 1) << 11) | imm11;
-    *code32 = t;
-    return true;
-  }
-  return false;
-}
-
-// static
-bool AArch32Rel32Translator::ReadT24(rva_t instr_rva,
-                                     uint32_t code32,
-                                     rva_t* target_rva) {
-  constexpr ArmAlign kInstrAlign = kArmAlign2;
-  if (IsMisaligned(instr_rva, kInstrAlign))
-    return false;
-  arm_disp_t disp;
-  ArmAlign target_align = DecodeT24(code32, &disp);
-  if (target_align == kArmAlignFail)
-    return false;
-  *target_rva = GetThumb2TargetRvaFromDisp(instr_rva, disp, target_align);
-  return true;
-}
-
-// static
-bool AArch32Rel32Translator::WriteT24(rva_t instr_rva,
-                                      rva_t target_rva,
-                                      uint32_t* code32) {
-  constexpr ArmAlign kInstrAlign = kArmAlign2;
-  if (IsMisaligned(instr_rva, kInstrAlign))
-    return false;
-  // Dummy decode to get |target_align|.
-  arm_disp_t dummy_disp;
-  ArmAlign target_align = DecodeT24(*code32, &dummy_disp);
-  if (target_align == kArmAlignFail || IsMisaligned(target_rva, target_align))
-    return false;
-  arm_disp_t disp =
-      GetThumb2DispFromTargetRva(instr_rva, target_rva, target_align);
-  return EncodeT24(disp, code32);
-}
-
-/******** AArch64Rel32Translator ********/
-
-AArch64Rel32Translator::AArch64Rel32Translator() = default;
-
-// static
-ArmAlign AArch64Rel32Translator::DecodeImmd14(uint32_t code32,
-                                              arm_disp_t* disp) {
-  // TBZ:
-  //   Code:         b0110110 bbbbbSii iiiiiiii iiittttt
-  //   Displacement: SSSSSSSS SSSSSSSS Siiiiiii iiiiii00
-  // TBNZ:
-  //   Code:         b0110111 bbbbbSii iiiiiiii iiittttt
-  //   Displacement: SSSSSSSS SSSSSSSS Siiiiiii iiiiii00
-  uint32_t bits = code32 & 0x7F000000;
-  if (bits == 0x36000000 || bits == 0x37000000) {
-    *disp = GetSignedBits<5, 18>(code32) << 2;
-    return kArmAlign4;
-  }
-  return kArmAlignFail;
-}
-
-// static
-bool AArch64Rel32Translator::EncodeImmd14(arm_disp_t disp, uint32_t* code32) {
-  uint32_t t = *code32;
-  uint32_t bits = t & 0x7F000000;
-  if (bits == 0x36000000 || bits == 0x37000000) {
-    if (disp % 4)  // Require 4-byte alignment.
-      return false;
-    if (!SignedFit<16>(disp))  // Detect overflow.
-      return false;
-    uint32_t imm14 = GetUnsignedBits<2, 15>(disp);  // ii...i.
-    t &= 0xFFF8001F;
-    t |= imm14 << 5;
-    *code32 = t;
-    return true;
-  }
-  return false;
-}
-
-// static
-bool AArch64Rel32Translator::ReadImmd14(rva_t instr_rva,
-                                        uint32_t code32,
-                                        rva_t* target_rva) {
-  constexpr ArmAlign kInstrAlign = kArmAlign4;
-  if (IsMisaligned(instr_rva, kInstrAlign))
-    return false;
-  arm_disp_t disp;
-  if (DecodeImmd14(code32, &disp) == kArmAlignFail)
-    return false;
-  *target_rva = GetTargetRvaFromDisp(instr_rva, disp);
-  return true;
-}
-
-// static
-bool AArch64Rel32Translator::WriteImmd14(rva_t instr_rva,
-                                         rva_t target_rva,
-                                         uint32_t* code32) {
-  constexpr ArmAlign kInstrAlign = kArmAlign4;
-  constexpr ArmAlign kTargetAlign = kArmAlign4;
-  if (IsMisaligned(instr_rva, kInstrAlign) ||
-      IsMisaligned(target_rva, kTargetAlign)) {
-    return false;
-  }
-  arm_disp_t disp = GetDispFromTargetRva(instr_rva, target_rva);
-  return EncodeImmd14(disp, code32);
-}
-
-// static
-ArmAlign AArch64Rel32Translator::DecodeImmd19(uint32_t code32,
-                                              arm_disp_t* disp) {
-  // B.cond:
-  //   Code:         01010100 Siiiiiii iiiiiiii iii0cccc
-  //   Displacement: SSSSSSSS SSSSiiii iiiiiiii iiiiii00
-  // CBZ:
-  //   Code:         z0110100 Siiiiiii iiiiiiii iiittttt
-  //   Displacement: SSSSSSSS SSSSiiii iiiiiiii iiiiii00
-  // CBNZ:
-  //   Code:         z0110101 Siiiiiii iiiiiiii iiittttt
-  //   Displacement: SSSSSSSS SSSSiiii iiiiiiii iiiiii00
-  uint32_t bits1 = code32 & 0xFF000010;
-  uint32_t bits2 = code32 & 0x7F000000;
-  if (bits1 == 0x54000000 || bits2 == 0x34000000 || bits2 == 0x35000000) {
-    *disp = GetSignedBits<5, 23>(code32) << 2;
-    return kArmAlign4;
-  }
-  return kArmAlignFail;
-}
-
-// static
-bool AArch64Rel32Translator::EncodeImmd19(arm_disp_t disp, uint32_t* code32) {
-  uint32_t t = *code32;
-  uint32_t bits1 = t & 0xFF000010;
-  uint32_t bits2 = t & 0x7F000000;
-  if (bits1 == 0x54000000 || bits2 == 0x34000000 || bits2 == 0x35000000) {
-    if (disp % 4)  // Require 4-byte alignment.
-      return false;
-    if (!SignedFit<21>(disp))  // Detect overflow.
-      return false;
-    uint32_t imm19 = GetUnsignedBits<2, 20>(disp);  // ii...i.
-    t &= 0xFF00001F;
-    t |= imm19 << 5;
-    *code32 = t;
-    return true;
-  }
-  return false;
-}
-
-// static
-bool AArch64Rel32Translator::ReadImmd19(rva_t instr_rva,
-                                        uint32_t code32,
-                                        rva_t* target_rva) {
-  constexpr ArmAlign kInstrAlign = kArmAlign4;
-  if (IsMisaligned(instr_rva, kInstrAlign))
-    return false;
-  arm_disp_t disp;
-  if (DecodeImmd19(code32, &disp) == kArmAlignFail)
-    return false;
-  *target_rva = GetTargetRvaFromDisp(instr_rva, disp);
-  return true;
-}
-
-// static
-bool AArch64Rel32Translator::WriteImmd19(rva_t instr_rva,
-                                         rva_t target_rva,
-                                         uint32_t* code32) {
-  constexpr ArmAlign kInstrAlign = kArmAlign4;
-  constexpr ArmAlign kTargetAlign = kArmAlign4;
-  if (IsMisaligned(instr_rva, kInstrAlign) ||
-      IsMisaligned(target_rva, kTargetAlign)) {
-    return false;
-  }
-  arm_disp_t disp = GetDispFromTargetRva(instr_rva, target_rva);
-  return EncodeImmd19(disp, code32);
-}
-
-// static
-ArmAlign AArch64Rel32Translator::DecodeImmd26(uint32_t code32,
-                                              arm_disp_t* disp) {
-  // B:
-  //   Code:         000101Si iiiiiiii iiiiiiii iiiiiiii
-  //   Displacement: SSSSSiii iiiiiiii iiiiiiii iiiiii00
-  // BL:
-  //   Code:         100101Si iiiiiiii iiiiiiii iiiiiiii
-  //   Displacement: SSSSSiii iiiiiiii iiiiiiii iiiiii00
-  uint32_t bits = code32 & 0xFC000000;
-  if (bits == 0x14000000 || bits == 0x94000000) {
-    *disp = GetSignedBits<0, 25>(code32) << 2;
-    return kArmAlign4;
-  }
-  return kArmAlignFail;
-}
-
-// static
-bool AArch64Rel32Translator::EncodeImmd26(arm_disp_t disp, uint32_t* code32) {
-  uint32_t t = *code32;
-  uint32_t bits = t & 0xFC000000;
-  if (bits == 0x14000000 || bits == 0x94000000) {
-    if (disp % 4)  // Require 4-byte alignment.
-      return false;
-    if (!SignedFit<28>(disp))  // Detect overflow.
-      return false;
-    uint32_t imm26 = GetUnsignedBits<2, 27>(disp);  // ii...i.
-    t &= 0xFC000000;
-    t |= imm26;
-    *code32 = t;
-    return true;
-  }
-  return false;
-}
-
-// static
-bool AArch64Rel32Translator::ReadImmd26(rva_t instr_rva,
-                                        uint32_t code32,
-                                        rva_t* target_rva) {
-  constexpr ArmAlign kInstrAlign = kArmAlign4;
-  if (IsMisaligned(instr_rva, kInstrAlign))
-    return false;
-  arm_disp_t disp;
-  if (DecodeImmd26(code32, &disp) == kArmAlignFail)
-    return false;
-  *target_rva = GetTargetRvaFromDisp(instr_rva, disp);
-  return true;
-}
-
-// static
-bool AArch64Rel32Translator::WriteImmd26(rva_t instr_rva,
-                                         rva_t target_rva,
-                                         uint32_t* code32) {
-  constexpr ArmAlign kInstrAlign = kArmAlign4;
-  constexpr ArmAlign kTargetAlign = kArmAlign4;
-  if (IsMisaligned(instr_rva, kInstrAlign) ||
-      IsMisaligned(target_rva, kTargetAlign)) {
-    return false;
-  }
-  arm_disp_t disp = GetDispFromTargetRva(instr_rva, target_rva);
-  return EncodeImmd26(disp, code32);
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/buffer_source.cc b/native/zucchini/vendor/zucchini/buffer_source.cc
deleted file mode 100644
index d72d329..0000000
--- a/native/zucchini/vendor/zucchini/buffer_source.cc
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/buffer_source.h"
-
-#include <algorithm>
-
-#include "components/zucchini/algorithm.h"
-
-namespace zucchini {
-
-BufferSource::BufferSource(ConstBufferView buffer) : ConstBufferView(buffer) {}
-
-BufferSource& BufferSource::Skip(size_type n) {
-  remove_prefix(std::min(n, Remaining()));
-  return *this;
-}
-
-bool BufferSource::CheckNextBytes(std::initializer_list<uint8_t> bytes) const {
-  if (Remaining() < bytes.size())
-    return false;
-  return std::mismatch(bytes.begin(), bytes.end(), begin()).first ==
-         bytes.end();
-}
-
-bool BufferSource::ConsumeBytes(std::initializer_list<uint8_t> bytes) {
-  if (!CheckNextBytes(bytes))
-    return false;
-  remove_prefix(bytes.size());
-  return true;
-}
-
-bool BufferSource::GetRegion(size_type count, ConstBufferView* buffer) {
-  DCHECK_NE(begin(), nullptr);
-  if (Remaining() < count)
-    return false;
-  *buffer = ConstBufferView(begin(), count);
-  remove_prefix(count);
-  return true;
-}
-
-// [0aaaaaaa] => 00000000'00000000'00000000'0aaaaaaa
-// [1aaaaaaa 0bbbbbbb] => 00000000'00000000'00bbbbbb'baaaaaaa
-// [1aaaaaaa 1bbbbbbb 0ccccccc] => 00000000'000ccccc'ccbbbbbb'baaaaaaa
-// [1aaaaaaa 1bbbbbbb 1ccccccc 0ddddddd] => 0000dddd'dddccccc'ccbbbbbb'baaaaaaa
-// [1aaaaaaa 1bbbbbbb 1ccccccc 1ddddddd 0???eeee]
-//     => eeeedddd'dddccccc'ccbbbbbb'baaaaaaa
-// Note that "???" is discarded. Meanwhile, 1???eeee is invalid.
-bool BufferSource::GetUleb128(uint32_t* ret) {
-  int shift_lim =
-      static_cast<int>(std::min<size_type>(kMaxLeb128Size, size())) * 7;
-  const_iterator cur = cbegin();
-  uint32_t value = 0U;
-  for (int shift = 0; shift < shift_lim; shift += 7, ++cur) {
-    uint32_t b = *cur;
-    // When |shift == 28|, |(b & 0x7F) << shift| discards the "???" bits.
-    value |= static_cast<uint32_t>(b & 0x7F) << shift;
-    if (!(b & 0x80)) {
-      *ret = value;
-      seek(cur + 1);
-      return true;
-    }
-  }
-  return false;
-}
-
-// [0Saaaaaa] => SSSSSSSS'SSSSSSSS'SSSSSSSS'SSaaaaaa
-// [1aaaaaaa 0Sbbbbbb] => SSSSSSSS'SSSSSSSS'SSSbbbbb'baaaaaaa
-// [1aaaaaaa 1bbbbbbb 0Scccccc] => SSSSSSSS'SSSScccc'ccbbbbbb'baaaaaaa
-// [1aaaaaaa 1bbbbbbb 1ccccccc 0Sdddddd] => SSSSSddd'dddccccc'ccbbbbbb'baaaaaaa
-// [1aaaaaaa 1bbbbbbb 1ccccccc 1ddddddd 0???Seee]
-//     => Seeedddd'dddccccc'ccbbbbbb'baaaaaaa
-// Note that "???" is discarded. Meanwhile, 1???eeee is invalid.
-bool BufferSource::GetSleb128(int32_t* ret) {
-  int shift_lim =
-      static_cast<int>(std::min<size_type>(kMaxLeb128Size, size())) * 7;
-  const_iterator cur = cbegin();
-  int32_t value = 0;
-  for (int shift = 0; shift < shift_lim; shift += 7, ++cur) {
-    uint32_t b = *cur;
-    // When |shift == 28|, |(b & 0x7F) << shift| discards the "???" bits.
-    value |= static_cast<int32_t>(static_cast<uint32_t>(b & 0x7F) << shift);
-    if (!(b & 0x80)) {
-      *ret = (shift == 28) ? value : SignExtend(shift + 6, value);
-      seek(cur + 1);
-      return true;
-    }
-  }
-  return false;
-}
-
-bool BufferSource::SkipLeb128() {
-  int lim = static_cast<int>(std::min<size_type>(kMaxLeb128Size, size()));
-  const_iterator cur = cbegin();
-  for (int i = 0; i < lim; ++i, ++cur) {
-    if (!(*cur & 0x80)) {
-      seek(cur + 1);
-      return true;
-    }
-  }
-  return false;
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/crc32.cc b/native/zucchini/vendor/zucchini/crc32.cc
deleted file mode 100644
index 1c45dfe..0000000
--- a/native/zucchini/vendor/zucchini/crc32.cc
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/crc32.h"
-
-#include <array>
-
-#include "base/check_op.h"
-
-namespace zucchini {
-
-namespace {
-
-std::array<uint32_t, 256> MakeCrc32Table() {
-  constexpr uint32_t kCrc32Poly = 0xEDB88320;
-
-  std::array<uint32_t, 256> crc32Table;
-  for (uint32_t i = 0; i < 256; ++i) {
-    uint32_t r = i;
-    for (int j = 0; j < 8; ++j)
-      r = (r >> 1) ^ (kCrc32Poly & ~((r & 1) - 1));
-    crc32Table[i] = r;
-  }
-  return crc32Table;
-}
-
-}  // namespace
-
-// Minimalistic CRC-32 implementation for Zucchini usage. Adapted from LZMA SDK
-// (found at third_party/lzma_sdk/7zCrc.c), which is public domain.
-uint32_t CalculateCrc32(const uint8_t* first, const uint8_t* last) {
-  DCHECK_GE(last, first);
-
-  static const std::array<uint32_t, 256> kCrc32Table = MakeCrc32Table();
-
-  uint32_t ret = 0xFFFFFFFF;
-  for (; first != last; ++first)
-    ret = kCrc32Table[(ret ^ *first) & 0xFF] ^ (ret >> 8);
-  return ret ^ 0xFFFFFFFF;
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/disassembler.cc b/native/zucchini/vendor/zucchini/disassembler.cc
deleted file mode 100644
index 5dce221..0000000
--- a/native/zucchini/vendor/zucchini/disassembler.cc
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/disassembler.h"
-
-#include "base/check_op.h"
-
-namespace zucchini {
-
-/******** EmptyReferenceReader ********/
-
-std::optional<Reference> EmptyReferenceReader::GetNext() {
-  return std::nullopt;
-}
-
-/******** EmptyReferenceWriter ********/
-
-void EmptyReferenceWriter::PutNext(Reference /* reference */) {}
-
-/******** ReferenceGroup ********/
-
-std::unique_ptr<ReferenceReader> ReferenceGroup::GetReader(
-    offset_t lower,
-    offset_t upper,
-    Disassembler* disasm) const {
-  DCHECK_LE(lower, upper);
-  DCHECK_LE(upper, disasm->size());
-  return (disasm->*reader_factory_)(lower, upper);
-}
-
-std::unique_ptr<ReferenceReader> ReferenceGroup::GetReader(
-    Disassembler* disasm) const {
-  return (disasm->*reader_factory_)(0, static_cast<offset_t>(disasm->size()));
-}
-
-std::unique_ptr<ReferenceWriter> ReferenceGroup::GetWriter(
-    MutableBufferView image,
-    Disassembler* disasm) const {
-  DCHECK_EQ(image.begin(), disasm->image().begin());
-  DCHECK_EQ(image.size(), disasm->size());
-  return (disasm->*writer_factory_)(image);
-}
-
-/******** Disassembler ********/
-
-Disassembler::Disassembler(int num_equivalence_iterations)
-    : num_equivalence_iterations_(num_equivalence_iterations) {}
-
-Disassembler::~Disassembler() = default;
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/disassembler_dex.cc b/native/zucchini/vendor/zucchini/disassembler_dex.cc
deleted file mode 100644
index fe1110f..0000000
--- a/native/zucchini/vendor/zucchini/disassembler_dex.cc
+++ /dev/null
@@ -1,1890 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/disassembler_dex.h"
-
-#include <stddef.h>
-#include <stdlib.h>
-
-#include <algorithm>
-#include <cctype>
-#include <cmath>
-#include <iterator>
-#include <optional>
-#include <set>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/logging.h"
-#include "base/numerics/checked_math.h"
-#include "base/numerics/safe_conversions.h"
-#include "base/strings/stringprintf.h"
-#include "components/zucchini/buffer_source.h"
-#include "components/zucchini/buffer_view.h"
-#include "components/zucchini/io_utils.h"
-
-namespace zucchini {
-
-namespace {
-
-// A DEX item specified by an offset, if absent, has a sentinel value of 0 since
-// 0 is never a valid item offset (it points to magic at start of DEX).
-constexpr offset_t kDexSentinelOffset = 0U;
-
-// A DEX item specified by an index, if absent, has a sentinel value of
-// NO_INDEX = 0xFFFFFFFF. This is represented as an offset_t for uniformity.
-constexpr offset_t kDexSentinelIndexAsOffset = 0xFFFFFFFFU;
-
-static_assert(kDexSentinelIndexAsOffset != kInvalidOffset,
-              "Sentinel should not be confused with invalid offset.");
-
-// Size of a Dalvik instruction unit. Need to cast to signed int because
-// sizeof() gives size_t, which dominates when operated on ptrdiff_t, then
-// wrecks havoc for base::checked_cast<int16_t>().
-constexpr int kInstrUnitSize = static_cast<int>(sizeof(uint16_t));
-
-// Checks if |offset| is byte aligned to 32 bits or 4 bytes.
-bool Is32BitAligned(offset_t offset) {
-  return offset % 4 == 0;
-}
-
-// Returns a lower bound for the size of an item of type |type_item_code|.
-// - For fixed-length items (e.g., kTypeFieldIdItem) this is the exact size.
-// - For variant-length items (e.g., kTypeCodeItem), returns a value that is
-//   known to be less than the item length (e.g., header size).
-// - For items not handled by this function, returns 1 for sanity check.
-size_t GetItemBaseSize(uint16_t type_item_code) {
-  switch (type_item_code) {
-    case dex::kTypeStringIdItem:
-      return sizeof(dex::StringIdItem);
-    case dex::kTypeTypeIdItem:
-      return sizeof(dex::TypeIdItem);
-    case dex::kTypeProtoIdItem:
-      return sizeof(dex::ProtoIdItem);
-    case dex::kTypeFieldIdItem:
-      return sizeof(dex::FieldIdItem);
-    case dex::kTypeMethodIdItem:
-      return sizeof(dex::MethodIdItem);
-    case dex::kTypeClassDefItem:
-      return sizeof(dex::ClassDefItem);
-    case dex::kTypeCallSiteIdItem:
-      return sizeof(dex::CallSiteIdItem);
-    case dex::kTypeMethodHandleItem:
-      return sizeof(dex::MethodHandleItem);
-    // No need to handle dex::kTypeMapList.
-    case dex::kTypeTypeList:
-      return sizeof(uint32_t);  // Variable-length.
-    case dex::kTypeAnnotationSetRefList:
-      return sizeof(uint32_t);  // Variable-length.
-    case dex::kTypeAnnotationSetItem:
-      return sizeof(uint32_t);  // Variable-length.
-    case dex::kTypeCodeItem:
-      return sizeof(dex::CodeItem);  // Variable-length.
-    case dex::kTypeAnnotationsDirectoryItem:
-      return sizeof(dex::AnnotationsDirectoryItem);  // Variable-length.
-    default:
-      return 1U;  // Unhandled item. For sanity check assume size >= 1.
-  }
-}
-
-/******** CodeItemParser ********/
-
-// A parser to extract successive code items from a DEX image whose header has
-// been parsed.
-class CodeItemParser {
- public:
-  using size_type = BufferSource::size_type;
-
-  explicit CodeItemParser(ConstBufferView image) : image_(image) {}
-
-  // Initializes the parser, returns true on success and false on error.
-  bool Init(const dex::MapItem& code_map_item) {
-    // Sanity check to quickly fail if |code_map_item.offset| or
-    // |code_map_item.size| is too large. This is a heuristic because code item
-    // sizes need to be parsed (sizeof(dex::CodeItem) is a lower bound).
-    if (!image_.covers_array(code_map_item.offset, code_map_item.size,
-                             sizeof(dex::CodeItem))) {
-      return false;
-    }
-    source_ = std::move(BufferSource(image_).Skip(code_map_item.offset));
-    return true;
-  }
-
-  // Extracts the header of the next code item, and skips the variable-length
-  // data. Returns the offset of the code item if successful. Otherwise returns
-  // kInvalidOffset, and thereafter the parser becomes valid. For reference,
-  // here's a pseudo-struct of a complete code item:
-  //
-  // struct code_item {
-  //   // 4-byte aligned here.
-  //   // 16-byte header defined (dex::CodeItem).
-  //   uint16_t registers_size;
-  //   uint16_t ins_size;
-  //   uint16_t outs_size;
-  //   uint16_t tries_size;
-  //   uint32_t debug_info_off;
-  //   uint32_t insns_size;
-  //
-  //   // Variable-length data follow.
-  //   uint16_t insns[insns_size];  // Instruction bytes.
-  //   uint16_t padding[(tries_size > 0 && insns_size % 2 == 1) ? 1 : 0];
-  //
-  //   if (tries_size > 0) {
-  //     // 4-byte aligned here.
-  //     struct try_item {  // dex::TryItem.
-  //       uint32_t start_addr;
-  //       uint16_t insn_count;
-  //       uint16_t handler_off;
-  //     } tries[tries_size];
-  //
-  //     struct encoded_catch_handler_list {
-  //       uleb128 handlers_size;
-  //       struct encoded_catch_handler {
-  //         sleb128 encoded_catch_handler_size;
-  //         struct encoded_type_addr_pair {
-  //           uleb128 type_idx;
-  //           uleb128 addr;
-  //         } handlers[abs(encoded_catch_handler_size)];
-  //         if (encoded_catch_handler_size <= 0) {
-  //           uleb128 catch_all_addr;
-  //         }
-  //       } handlers_list[handlers_size];
-  //     } handlers_group;  // Confusingly called "handlers" in DEX doc.
-  //   }
-  //
-  //   // Padding to 4-bytes align next code_item *only if more exist*.
-  // }
-  offset_t GetNext() {
-    // Read header CodeItem.
-    if (!source_.AlignOn(image_, 4U))
-      return kInvalidOffset;
-    const offset_t code_item_offset =
-        base::checked_cast<offset_t>(source_.begin() - image_.begin());
-    const auto* code_item = source_.GetPointer<const dex::CodeItem>();
-    if (!code_item)
-      return kInvalidOffset;
-    DCHECK(Is32BitAligned(code_item_offset));
-
-    // TODO(huangs): Fail if |code_item->insns_size == 0| (Constraint A1).
-    // Skip instruction bytes.
-    if (!source_.GetArray<uint16_t>(code_item->insns_size))
-      return kInvalidOffset;
-    // Skip padding if present.
-    if (code_item->tries_size > 0 && !source_.AlignOn(image_, 4U))
-      return kInvalidOffset;
-
-    // Skip tries[] and handlers_group to arrive at the next code item. Parsing
-    // is nontrivial due to use of uleb128 / sleb128.
-    if (code_item->tries_size > 0) {
-      // Skip (try_item) tries[].
-      if (!source_.GetArray<dex::TryItem>(code_item->tries_size))
-        return kInvalidOffset;
-
-      // Skip handlers_group.
-      uint32_t handlers_size = 0;
-      if (!source_.GetUleb128(&handlers_size))
-        return kInvalidOffset;
-      // Sanity check to quickly reject excessively large |handlers_size|.
-      if (source_.Remaining() < static_cast<size_type>(handlers_size))
-        return kInvalidOffset;
-
-      // Skip (encoded_catch_handler) handlers_list[].
-      for (uint32_t k = 0; k < handlers_size; ++k) {
-        int32_t encoded_catch_handler_size = 0;
-        if (!source_.GetSleb128(&encoded_catch_handler_size))
-          return kInvalidOffset;
-        const size_type abs_size = std::abs(encoded_catch_handler_size);
-        if (source_.Remaining() < abs_size)  // Sanity check.
-          return kInvalidOffset;
-        // Skip (encoded_type_addr_pair) handlers[].
-        for (size_type j = 0; j < abs_size; ++j) {
-          if (!source_.SkipLeb128() || !source_.SkipLeb128())
-            return kInvalidOffset;
-        }
-        // Skip catch_all_addr.
-        if (encoded_catch_handler_size <= 0) {
-          if (!source_.SkipLeb128())
-            return kInvalidOffset;
-        }
-      }
-    }
-    // Success! |code_item->insns_size| is validated, but its content is still
-    // considered unsafe and requires validation.
-    return code_item_offset;
-  }
-
-  // Given |code_item_offset| that points to the start of a valid code item in
-  // |image|, returns |insns| bytes as ConstBufferView.
-  static ConstBufferView GetCodeItemInsns(ConstBufferView image,
-                                          offset_t code_item_offset) {
-    BufferSource source(BufferSource(image).Skip(code_item_offset));
-    const auto* code_item = source.GetPointer<const dex::CodeItem>();
-    DCHECK(code_item);
-    BufferRegion insns{0, code_item->insns_size * kInstrUnitSize};
-    DCHECK(source.covers(insns));
-    return source[insns];
-  }
-
- private:
-  ConstBufferView image_;
-  BufferSource source_;
-};
-
-/******** InstructionParser ********/
-
-// A class that successively reads |code_item| for Dalvik instructions, which
-// are found at |insns|, spanning |insns_size| uint16_t "units". These units
-// store instructions followed by optional non-instruction "payload". Finding
-// payload boundary requires parsing: On finding an instruction that uses (and
-// points to) payload, the boundary is updated.
-class InstructionParser {
- public:
-  struct Value {
-    offset_t instr_offset;
-    const dex::Instruction* instr = nullptr;  // null for unknown instructions.
-  };
-
-  // Returns pointer to DEX Instruction data for |opcode|, or null if |opcode|
-  // is unknown. An internal initialize-on-first-use table is used for fast
-  // lookup.
-  const dex::Instruction* FindDalvikInstruction(uint8_t opcode) {
-    static bool is_init = false;
-    static const dex::Instruction* instruction_table[256];
-    if (!is_init) {
-      is_init = true;
-      std::fill(std::begin(instruction_table), std::end(instruction_table),
-                nullptr);
-      for (const dex::Instruction& instr : dex::kByteCode) {
-        std::fill(instruction_table + instr.opcode,
-                  instruction_table + instr.opcode + instr.variant, &instr);
-      }
-    }
-    return instruction_table[opcode];
-  }
-
-  InstructionParser() = default;
-
-  InstructionParser(ConstBufferView image, offset_t base_offset)
-      : image_begin_(image.begin()),
-        insns_(CodeItemParser::GetCodeItemInsns(image, base_offset)),
-        payload_boundary_(insns_.end()) {}
-
-  // Reads the next instruction. On success, makes the data read available via
-  // value() and returns true. Otherwise (done or found error) returns false.
-  bool ReadNext() {
-    // Do not scan past payload boundary.
-    if (insns_.begin() >= payload_boundary_)
-      return false;
-
-    const offset_t instr_offset =
-        base::checked_cast<offset_t>(insns_.begin() - image_begin_);
-    const uint8_t op = insns_.read<uint8_t>(0);
-    const dex::Instruction* instr = FindDalvikInstruction(op);
-
-    // Stop on finding unknown instructions. ODEX files might trigger this.
-    if (!instr) {
-      LOG(WARNING) << "Unknown Dalvik instruction detected at "
-                   << AsHex<8>(instr_offset) << ".";
-      return false;
-    }
-
-    const int instr_length_units = instr->layout;
-    const size_t instr_length_bytes = instr_length_units * kInstrUnitSize;
-    if (insns_.size() < instr_length_bytes)
-      return false;
-
-    // Handle instructions with variable-length data payload (31t).
-    if (instr->opcode == 0x26 ||  // fill-array-data
-        instr->opcode == 0x2B ||  // packed-switch
-        instr->opcode == 0x2C) {  // sparse-switch
-      const int32_t unsafe_payload_rel_units = insns_.read<int32_t>(2);
-      // Payload must be in current code item, after current instruction.
-      if (unsafe_payload_rel_units < instr_length_units ||
-          static_cast<uint32_t>(unsafe_payload_rel_units) >=
-              insns_.size() / kInstrUnitSize) {
-        LOG(WARNING) << "Invalid payload found.";
-        return false;
-      }
-      // Update boundary between instructions and payload.
-      const ConstBufferView::const_iterator payload_it =
-          insns_.begin() + unsafe_payload_rel_units * kInstrUnitSize;
-      payload_boundary_ = std::min(payload_boundary_, payload_it);
-    }
-
-    insns_.remove_prefix(instr_length_bytes);
-    value_ = {instr_offset, instr};
-    return true;
-  }
-
-  const Value& value() const { return value_; }
-
- private:
-  ConstBufferView::const_iterator image_begin_;
-  ConstBufferView insns_;
-  ConstBufferView::const_iterator payload_boundary_;
-  Value value_;
-};
-
-/******** InstructionReferenceReader ********/
-
-// A class to visit |code_items|, parse instructions, and emit embedded
-// References of a type determined by |filter_| and |mapper_|. Only References
-// located in |[lo, hi)| are emitted. |lo| and |hi| are assumed to never
-// straddle the body of a Reference.
-class InstructionReferenceReader : public ReferenceReader {
- public:
-  // A function that takes a parsed Dalvik instruction and decides whether it
-  // contains a specific type of Reference. If true, then returns the Reference
-  // location. Otherwise returns kInvalidOffset.
-  using Filter =
-      base::RepeatingCallback<offset_t(const InstructionParser::Value&)>;
-  // A function that takes Reference location from |filter_| to extract the
-  // stored target. If valid, returns it. Otherwise returns kInvalidOffset.
-  using Mapper = base::RepeatingCallback<offset_t(offset_t)>;
-
-  InstructionReferenceReader(ConstBufferView image,
-                             offset_t lo,
-                             offset_t hi,
-                             const std::vector<offset_t>& code_item_offsets,
-                             Filter&& filter,
-                             Mapper&& mapper)
-      : image_(image),
-        lo_(lo),
-        hi_(hi),
-        end_it_(code_item_offsets.end()),
-        filter_(std::move(filter)),
-        mapper_(std::move(mapper)) {
-    const auto begin_it = code_item_offsets.begin();
-    // Use binary search to find the code item that contains |lo_|.
-    auto comp = [](offset_t test_offset, offset_t code_item_offset) {
-      return test_offset < code_item_offset;
-    };
-    cur_it_ = std::upper_bound(begin_it, end_it_, lo_, comp);
-    if (cur_it_ != begin_it)
-      --cur_it_;
-    parser_ = InstructionParser(image_, *cur_it_);
-  }
-
-  // ReferenceReader:
-  std::optional<Reference> GetNext() override {
-    while (true) {
-      while (parser_.ReadNext()) {
-        const auto& v = parser_.value();
-        DCHECK_NE(v.instr, nullptr);
-        if (v.instr_offset >= hi_)
-          return std::nullopt;
-        const offset_t location = filter_.Run(v);
-        if (location == kInvalidOffset || location < lo_)
-          continue;
-        // The general check is |location + reference_width > hi_|. However, by
-        // assumption |hi_| and |lo_| do not straddle the body of a Reference.
-        // So |reference_width| is unneeded.
-        if (location >= hi_)
-          return std::nullopt;
-        offset_t target = mapper_.Run(location);
-        if (target != kInvalidOffset)
-          return Reference{location, target};
-        else
-          LOG(WARNING) << "Invalid target at " << AsHex<8>(location) << ".";
-      }
-      ++cur_it_;
-      if (cur_it_ == end_it_)
-        return std::nullopt;
-      parser_ = InstructionParser(image_, *cur_it_);
-    }
-  }
-
- private:
-  const ConstBufferView image_;
-  const offset_t lo_;
-  const offset_t hi_;
-  const std::vector<offset_t>::const_iterator end_it_;
-  const Filter filter_;
-  const Mapper mapper_;
-  std::vector<offset_t>::const_iterator cur_it_;
-  InstructionParser parser_;
-};
-
-/******** ItemReferenceReader ********/
-
-// A class to visit fixed-size item elements (determined by |item_size|) and
-// emit a "member variable of interest" (MVI, determined by |rel_location| and
-// |mapper|) as Reference. Only MVIs lying in |[lo, hi)| are emitted. |lo| and
-// |hi| are assumed to never straddle the body of a Reference.
-class ItemReferenceReader : public ReferenceReader {
- public:
-  // A function that takes an MVI's location and emit its target offset.
-  using Mapper = base::RepeatingCallback<offset_t(offset_t)>;
-
-  // |item_size| is the size of a fixed-size item. |rel_location| is the
-  // relative location of MVI from the start of the item containing it.
-  // |rel_item_offset| is the offset to use relative to |item_offset| in cases
-  // where a value other than |rel_location| is required. For an example of this
-  // see ReadMethodHandleFieldOrMethodId.
-  ItemReferenceReader(offset_t lo,
-                      offset_t hi,
-                      const dex::MapItem& map_item,
-                      size_t item_size,
-                      size_t rel_location,
-                      Mapper&& mapper,
-                      bool mapper_wants_item = false)
-      : hi_(hi),
-        item_base_offset_(base::checked_cast<offset_t>(map_item.offset)),
-        num_items_(base::checked_cast<uint32_t>(map_item.size)),
-        item_size_(base::checked_cast<uint32_t>(item_size)),
-        rel_location_(base::checked_cast<uint32_t>(rel_location)),
-        mapper_input_delta_(
-            mapper_wants_item ? 0 : base::checked_cast<uint32_t>(rel_location)),
-        mapper_(std::move(mapper)) {
-    static_assert(sizeof(decltype(map_item.offset)) <= sizeof(offset_t),
-                  "map_item.offset too large.");
-    static_assert(sizeof(decltype(map_item.size)) <= sizeof(offset_t),
-                  "map_item.size too large.");
-    if (!item_base_offset_) {
-      // Empty item: Assign |cur_idx| to |num_items_| to skip everything.
-      cur_idx_ = num_items_;
-    } else if (lo < item_base_offset_) {
-      cur_idx_ = 0;
-    } else if (lo < OffsetOfIndex(num_items_)) {
-      cur_idx_ = (lo - item_base_offset_) / item_size_;
-      // Fine-tune: Advance if |lo| lies beyond the MVI.
-      if (lo > OffsetOfIndex(cur_idx_) + rel_location_)
-        ++cur_idx_;
-    } else {
-      cur_idx_ = num_items_;
-    }
-  }
-
-  // ReferenceReader:
-  std::optional<Reference> GetNext() override {
-    while (cur_idx_ < num_items_) {
-      const offset_t item_offset = OffsetOfIndex(cur_idx_);
-      const offset_t location = item_offset + rel_location_;
-      // The general check is |location + reference_width > hi_|. However, by
-      // assumption |hi_| and |lo_| do not straddle the body of a Reference. So
-      // |reference_width| is unneeded.
-      if (location >= hi_)
-        break;
-
-      // |location == item_offset + mapper_input_delta_| in the majority of
-      // cases. The exception is when |mapper_| wants an item aligned location
-      // instead e.g. ReadMethodHandleFieldOrMethodId.
-      const offset_t target = mapper_.Run(item_offset + mapper_input_delta_);
-
-      // kDexSentinelOffset (0) may appear for the following:
-      // - ProtoIdItem: parameters_off.
-      // - ClassDefItem: interfaces_off, annotations_off, class_data_off,
-      //   static_values_off.
-      // - AnnotationsDirectoryItem: class_annotations_off.
-      // - AnnotationSetRefItem: annotations_off.
-      // kDexSentinelIndexAsOffset (0xFFFFFFFF) may appear for the following:
-      // - ClassDefItem: superclass_idx, source_file_idx.
-      // - MethodHandleItem: |mapper_| uses ReadMethodHandleFieldOrMethodId and
-      //   determines the item at |cur_idx_| is not of the required reference
-      //   type.
-      if (target == kDexSentinelOffset || target == kDexSentinelIndexAsOffset) {
-        ++cur_idx_;
-        continue;
-      }
-
-      if (target == kInvalidOffset) {
-        LOG(WARNING) << "Invalid item target at " << AsHex<8>(location) << ".";
-        break;
-      }
-      ++cur_idx_;
-      return Reference{location, target};
-    }
-    return std::nullopt;
-  }
-
- private:
-  offset_t OffsetOfIndex(uint32_t idx) {
-    return base::checked_cast<uint32_t>(item_base_offset_ + idx * item_size_);
-  }
-
-  const offset_t hi_;
-  const offset_t item_base_offset_;
-  const uint32_t num_items_;
-  const uint32_t item_size_;
-  const uint32_t rel_location_;
-  const uint32_t mapper_input_delta_;
-  const Mapper mapper_;
-  offset_t cur_idx_ = 0;
-};
-
-// Parses a flattened jagged list of lists of items that looks like:
-//   NTTT|NTT|NTTTT|N|NTT...
-// where |N| is an uint32_t representing the number of items in each sub-list,
-// and "T" is a fixed-size item (|item_width|) of type "T". On success, stores
-// the offset of each |T| into |item_offsets|, and returns true. Otherwise
-// (e.g., on finding any structural problem) returns false.
-bool ParseItemOffsets(ConstBufferView image,
-                      const dex::MapItem& map_item,
-                      size_t item_width,
-                      std::vector<offset_t>* item_offsets) {
-  // Sanity check: |image| should at least fit |map_item.size| copies of "N".
-  if (!image.covers_array(map_item.offset, map_item.size, sizeof(uint32_t)))
-    return false;
-  BufferSource source = std::move(BufferSource(image).Skip(map_item.offset));
-  item_offsets->clear();
-  for (uint32_t i = 0; i < map_item.size; ++i) {
-    if (!source.AlignOn(image, 4U))
-      return false;
-    uint32_t unsafe_size;
-    if (!source.GetValue<uint32_t>(&unsafe_size))
-      return false;
-    DCHECK(Is32BitAligned(
-        base::checked_cast<offset_t>(source.begin() - image.begin())));
-    if (!source.covers_array(0, unsafe_size, item_width))
-      return false;
-    for (uint32_t j = 0; j < unsafe_size; ++j) {
-      item_offsets->push_back(
-          base::checked_cast<offset_t>(source.begin() - image.begin()));
-      source.Skip(item_width);
-    }
-  }
-  return true;
-}
-
-// Parses AnnotationDirectoryItems of the format (using RegEx) "(AF*M*P*)*",
-// where:
-//   A = AnnotationsDirectoryItem (contains class annotation),
-//   F = FieldAnnotation,
-//   M = MethodAnnotation,
-//   P = ParameterAnnotation.
-// On success, stores the offsets of each class, field, method and parameter
-// annotation for each item into |*_annotation_offsets|. Otherwise on finding
-// structural issues returns false.
-bool ParseAnnotationsDirectoryItems(
-    ConstBufferView image,
-    const dex::MapItem& annotations_directory_map_item,
-    std::vector<offset_t>* annotations_directory_item_offsets,
-    std::vector<offset_t>* field_annotation_offsets,
-    std::vector<offset_t>* method_annotation_offsets,
-    std::vector<offset_t>* parameter_annotation_offsets) {
-  // Sanity check: |image| should at least fit
-  // |annotations_directory_map_item.size| copies of "A".
-  if (!image.covers_array(annotations_directory_map_item.offset,
-                          annotations_directory_map_item.size,
-                          sizeof(dex::AnnotationsDirectoryItem))) {
-    return false;
-  }
-  BufferSource source = std::move(
-      BufferSource(image).Skip(annotations_directory_map_item.offset));
-  annotations_directory_item_offsets->clear();
-  field_annotation_offsets->clear();
-  method_annotation_offsets->clear();
-  parameter_annotation_offsets->clear();
-
-  // Helper to process sublists.
-  auto parse_list = [&source, image](uint32_t unsafe_size, size_t item_width,
-                                     std::vector<offset_t>* item_offsets) {
-    DCHECK(Is32BitAligned(
-        base::checked_cast<offset_t>(source.begin() - image.begin())));
-    if (!source.covers_array(0, unsafe_size, item_width))
-      return false;
-    item_offsets->reserve(item_offsets->size() + unsafe_size);
-    for (uint32_t i = 0; i < unsafe_size; ++i) {
-      item_offsets->push_back(
-          base::checked_cast<offset_t>(source.begin() - image.begin()));
-      source.Skip(item_width);
-    }
-    return true;
-  };
-
-  annotations_directory_item_offsets->reserve(
-      annotations_directory_map_item.size);
-  for (uint32_t i = 0; i < annotations_directory_map_item.size; ++i) {
-    if (!source.AlignOn(image, 4U))
-      return false;
-    // Parse header.
-    annotations_directory_item_offsets->push_back(
-        base::checked_cast<offset_t>(source.begin() - image.begin()));
-    dex::AnnotationsDirectoryItem unsafe_annotations_directory_item;
-    if (!source.GetValue(&unsafe_annotations_directory_item))
-      return false;
-    // Parse sublists.
-    if (!(parse_list(unsafe_annotations_directory_item.fields_size,
-                     sizeof(dex::FieldAnnotation), field_annotation_offsets) &&
-          parse_list(unsafe_annotations_directory_item.annotated_methods_size,
-                     sizeof(dex::MethodAnnotation),
-                     method_annotation_offsets) &&
-          parse_list(
-              unsafe_annotations_directory_item.annotated_parameters_size,
-              sizeof(dex::ParameterAnnotation),
-              parameter_annotation_offsets))) {
-      return false;
-    }
-  }
-  return true;
-}
-
-/******** CachedItemListReferenceReader ********/
-
-// A class that takes sorted |item_offsets|, and emits all member variable of
-// interest (MVIs) that fall inside |[lo, hi)|. The MVI of each item has
-// location of |rel_location| from item offset, and has target extracted with
-// |mapper| (which performs validation). By the "atomicity assumption",
-// [|lo, hi)| never cut across an MVI.
-class CachedItemListReferenceReader : public ReferenceReader {
- public:
-  // A function that takes an MVI's location and emit its target offset.
-  using Mapper = base::RepeatingCallback<offset_t(offset_t)>;
-
-  CachedItemListReferenceReader(offset_t lo,
-                                offset_t hi,
-                                uint32_t rel_location,
-                                const std::vector<offset_t>& item_offsets,
-                                Mapper&& mapper)
-      : hi_(hi),
-        rel_location_(rel_location),
-        end_it_(item_offsets.cend()),
-        mapper_(mapper) {
-    cur_it_ = std::upper_bound(item_offsets.cbegin(), item_offsets.cend(), lo);
-    // Adding |rel_location_| is necessary as references can be offset from the
-    // start of the item.
-    if (cur_it_ != item_offsets.begin() && *(cur_it_ - 1) + rel_location_ >= lo)
-      --cur_it_;
-  }
-  CachedItemListReferenceReader(const CachedItemListReferenceReader&) = delete;
-  const CachedItemListReferenceReader& operator=(
-      const CachedItemListReferenceReader&) = delete;
-
-  // ReferenceReader:
-  std::optional<Reference> GetNext() override {
-    while (cur_it_ < end_it_) {
-      const offset_t location = *cur_it_ + rel_location_;
-      if (location >= hi_)  // Check is simplified by atomicity assumption.
-        break;
-      const offset_t target = mapper_.Run(location);
-      if (target == kInvalidOffset) {
-        LOG(WARNING) << "Invalid item target at " << AsHex<8>(location) << ".";
-        break;
-      }
-      ++cur_it_;
-
-      // kDexSentinelOffset is a sentinel for;
-      // - AnnotationsDirectoryItem: class_annotations_off
-      if (target == kDexSentinelOffset)
-        continue;
-      return Reference{location, target};
-    }
-    return std::nullopt;
-  }
-
- private:
-  const offset_t hi_;
-  const uint32_t rel_location_;
-  const std::vector<offset_t>::const_iterator end_it_;
-  const Mapper mapper_;
-  std::vector<offset_t>::const_iterator cur_it_;
-};
-
-// Reads an INT index at |location| in |image| and translates the index to the
-// offset of a fixed-size item specified by |target_map_item| and
-// |target_item_size|. Returns the target offset if valid, or kInvalidOffset
-// otherwise. This is compatible with
-// CachedReferenceListReferenceReader::Mapper,
-// InstructionReferenceReader::Mapper, and ItemReferenceReader::Mapper.
-template <typename INT>
-static offset_t ReadTargetIndex(ConstBufferView image,
-                                const dex::MapItem& target_map_item,
-                                size_t target_item_size,
-                                offset_t location) {
-  static_assert(sizeof(INT) <= sizeof(offset_t),
-                "INT may not fit into offset_t.");
-  const offset_t unsafe_idx = image.read<INT>(location);
-  // kDexSentinalIndexAsOffset (0xFFFFFFFF) is a sentinel for
-  // - ClassDefItem: superclass_idx, source_file_idx.
-  if (unsafe_idx == kDexSentinelIndexAsOffset)
-    return unsafe_idx;
-  if (unsafe_idx >= target_map_item.size)
-    return kInvalidOffset;
-  return target_map_item.offset +
-         base::checked_cast<offset_t>(unsafe_idx * target_item_size);
-}
-
-// Reads a field or method index of the MethodHandleItem located at |location|
-// in |image| and translates |method_handle_item.field_or_method_id| to the
-// offset of a fixed-size item specified by |target_map_item| and
-// |target_item_size|. The index is deemed to be of the correct target type if
-// |method_handle_item.method_handle_type| falls within the range [|min_type|,
-// |max_type|]. If the target type is correct ReadTargetIndex is called.
-// Returns the target offset if valid, or kDexSentinelIndexAsOffset if
-// |method_handle_item.method_handle_type| is of the wrong type, or
-// kInvalidOffset otherwise.
-//
-// As of DEX version 39 MethodHandleType values for FieldId and MethodId each
-// form one consecutive block of values. If this changes, then the interface to
-// this function will need to be redesigned.
-static offset_t ReadMethodHandleFieldOrMethodId(
-    ConstBufferView image,
-    const dex::MapItem& target_map_item,
-    size_t target_item_size,
-    dex::MethodHandleType min_type,
-    dex::MethodHandleType max_type,
-    offset_t location) {
-  dex::MethodHandleItem method_handle_item =
-      image.read<dex::MethodHandleItem>(location);
-
-  // Cannot use base::checked_cast as dex::MethodHandleType is an enum class so
-  // static_assert on the size instead.
-  static_assert(sizeof(decltype(dex::MethodHandleItem::method_handle_type)) <=
-                    sizeof(dex::MethodHandleType),
-                "dex::MethodHandleItem::method_handle_type may not fit into "
-                "dex::MethodHandleType.");
-  dex::MethodHandleType method_handle_type =
-      static_cast<dex::MethodHandleType>(method_handle_item.method_handle_type);
-
-  if (method_handle_type >= dex::MethodHandleType::kMaxMethodHandleType) {
-    return kInvalidOffset;
-  }
-
-  // Use DexSentinelIndexAsOffset to skip the item as it isn't of the
-  // corresponding method handle type.
-  if (method_handle_type < min_type || method_handle_type > max_type) {
-    return kDexSentinelIndexAsOffset;
-  }
-
-  return ReadTargetIndex<decltype(dex::MethodHandleItem::field_or_method_id)>(
-      image, target_map_item, target_item_size,
-      location + offsetof(dex::MethodHandleItem, field_or_method_id));
-}
-
-// Reads uint32_t value in |image| at (valid) |location| and checks whether it
-// is a safe offset of a fixed-size item. Returns the target offset (possibly a
-// sentinel) if valid, or kInvalidOffset otherwise. This is compatible with
-// CachedReferenceListReferenceReader::Mapper,
-// InstructionReferenceReader::Mapper, and ItemReferenceReader::Mapper.
-static offset_t ReadTargetOffset32(ConstBufferView image, offset_t location) {
-  const offset_t unsafe_target =
-      static_cast<offset_t>(image.read<uint32_t>(location));
-  // Skip and don't validate kDexSentinelOffset as it is indicative of an
-  // empty reference.
-  if (unsafe_target == kDexSentinelOffset)
-    return unsafe_target;
-
-  // TODO(huangs): Check that |unsafe_target| is within the correct data
-  // section.
-  if (unsafe_target >= image.size())
-    return kInvalidOffset;
-  return unsafe_target;
-}
-
-/******** ReferenceWriterAdaptor ********/
-
-// A ReferenceWriter that adapts a callback that performs type-specific
-// Reference writes.
-class ReferenceWriterAdaptor : public ReferenceWriter {
- public:
-  using Writer = base::RepeatingCallback<void(Reference, MutableBufferView)>;
-
-  ReferenceWriterAdaptor(MutableBufferView image, Writer&& writer)
-      : image_(image), writer_(std::move(writer)) {}
-
-  // ReferenceWriter:
-  void PutNext(Reference ref) override { writer_.Run(ref, image_); }
-
- private:
-  MutableBufferView image_;
-  Writer writer_;
-};
-
-// Helper that's compatible with ReferenceWriterAdaptor::Writer.
-// Given that |ref.target| points to the start of a fixed size DEX item (e.g.,
-// FieldIdItem), translates |ref.target| to item index, and writes the result to
-// |ref.location| as |INT|.
-template <typename INT>
-static void WriteTargetIndex(const dex::MapItem& target_map_item,
-                             size_t target_item_size,
-                             Reference ref,
-                             MutableBufferView image) {
-  const size_t unsafe_idx =
-      (ref.target - target_map_item.offset) / target_item_size;
-  // Verify that index is within bound.
-  if (unsafe_idx >= target_map_item.size) {
-    LOG(ERROR) << "Target index out of bounds at: " << AsHex<8>(ref.location)
-               << ".";
-    return;
-  }
-  // Verify that |ref.target| points to start of item.
-  DCHECK_EQ(ref.target, target_map_item.offset + unsafe_idx * target_item_size);
-  image.write<INT>(ref.location, base::checked_cast<INT>(unsafe_idx));
-}
-
-// Buffer for ReadDexHeader() to optionally return results.
-struct ReadDexHeaderResults {
-  BufferSource source;
-  const dex::HeaderItem* header;
-  int dex_version;
-};
-
-// Returns whether |image| points to a DEX file. If this is a possibility and
-// |opt_results| is not null, then uses it to pass extracted data to enable
-// further parsing.
-bool ReadDexHeader(ConstBufferView image, ReadDexHeaderResults* opt_results) {
-  // This part needs to be fairly efficient since it may be called many times.
-  BufferSource source(image);
-  const dex::HeaderItem* header = source.GetPointer<dex::HeaderItem>();
-  if (!header)
-    return false;
-  if (header->magic[0] != 'd' || header->magic[1] != 'e' ||
-      header->magic[2] != 'x' || header->magic[3] != '\n' ||
-      header->magic[7] != '\0') {
-    return false;
-  }
-
-  // Magic matches: More detailed tests can be conducted.
-  int dex_version = 0;
-  for (int i = 4; i < 7; ++i) {
-    if (!isdigit(header->magic[i]))
-      return false;
-    dex_version = dex_version * 10 + (header->magic[i] - '0');
-  }
-
-  // Only support DEX versions 35, 37, 38, and 39
-  if (dex_version != 35 && dex_version != 37 && dex_version != 38 &&
-      dex_version != 39) {
-    return false;
-  }
-
-  if (header->file_size > image.size() ||
-      header->file_size < sizeof(dex::HeaderItem) ||
-      header->map_off < sizeof(dex::HeaderItem)) {
-    return false;
-  }
-
-  if (opt_results)
-    *opt_results = {source, header, dex_version};
-  return true;
-}
-
-}  // namespace
-
-/******** DisassemblerDex ********/
-
-DisassemblerDex::DisassemblerDex() : Disassembler(4) {}
-
-DisassemblerDex::~DisassemblerDex() = default;
-
-// static.
-bool DisassemblerDex::QuickDetect(ConstBufferView image) {
-  return ReadDexHeader(image, nullptr);
-}
-
-ExecutableType DisassemblerDex::GetExeType() const {
-  return kExeTypeDex;
-}
-
-std::string DisassemblerDex::GetExeTypeString() const {
-  return base::StringPrintf("DEX (version %d)", dex_version_);
-}
-
-std::vector<ReferenceGroup> DisassemblerDex::MakeReferenceGroups() const {
-  // Must follow DisassemblerDex::ReferenceType order. Initialized on first use.
-  return {
-      {{4, TypeTag(kTypeIdToDescriptorStringId), PoolTag(kStringId)},
-       &DisassemblerDex::MakeReadTypeIdToDescriptorStringId32,
-       &DisassemblerDex::MakeWriteStringId32},
-      {{4, TypeTag(kProtoIdToShortyStringId), PoolTag(kStringId)},
-       &DisassemblerDex::MakeReadProtoIdToShortyStringId32,
-       &DisassemblerDex::MakeWriteStringId32},
-      {{4, TypeTag(kFieldIdToNameStringId), PoolTag(kStringId)},
-       &DisassemblerDex::MakeReadFieldToNameStringId32,
-       &DisassemblerDex::MakeWriteStringId32},
-      {{4, TypeTag(kMethodIdToNameStringId), PoolTag(kStringId)},
-       &DisassemblerDex::MakeReadMethodIdToNameStringId32,
-       &DisassemblerDex::MakeWriteStringId32},
-      {{4, TypeTag(kClassDefToSourceFileStringId), PoolTag(kStringId)},
-       &DisassemblerDex::MakeReadClassDefToSourceFileStringId32,
-       &DisassemblerDex::MakeWriteStringId32},
-      {{2, TypeTag(kCodeToStringId16), PoolTag(kStringId)},
-       &DisassemblerDex::MakeReadCodeToStringId16,
-       &DisassemblerDex::MakeWriteStringId16},
-      {{4, TypeTag(kCodeToStringId32), PoolTag(kStringId)},
-       &DisassemblerDex::MakeReadCodeToStringId32,
-       &DisassemblerDex::MakeWriteStringId32},
-      {{4, TypeTag(kProtoIdToReturnTypeId), PoolTag(kTypeId)},
-       &DisassemblerDex::MakeReadProtoIdToReturnTypeId32,
-       &DisassemblerDex::MakeWriteTypeId32},
-      {{2, TypeTag(kFieldIdToClassTypeId), PoolTag(kTypeId)},
-       &DisassemblerDex::MakeReadFieldToClassTypeId16,
-       &DisassemblerDex::MakeWriteTypeId16},
-      {{2, TypeTag(kFieldIdToTypeId), PoolTag(kTypeId)},
-       &DisassemblerDex::MakeReadFieldToTypeId16,
-       &DisassemblerDex::MakeWriteTypeId16},
-      {{2, TypeTag(kMethodIdToClassTypeId), PoolTag(kTypeId)},
-       &DisassemblerDex::MakeReadMethodIdToClassTypeId16,
-       &DisassemblerDex::MakeWriteTypeId16},
-      {{4, TypeTag(kClassDefToClassTypeId), PoolTag(kTypeId)},
-       &DisassemblerDex::MakeReadClassDefToClassTypeId32,
-       &DisassemblerDex::MakeWriteTypeId32},
-      {{4, TypeTag(kClassDefToSuperClassTypeId), PoolTag(kTypeId)},
-       &DisassemblerDex::MakeReadClassDefToSuperClassTypeId32,
-       &DisassemblerDex::MakeWriteTypeId32},
-      {{2, TypeTag(kTypeListToTypeId), PoolTag(kTypeId)},
-       &DisassemblerDex::MakeReadTypeListToTypeId16,
-       &DisassemblerDex::MakeWriteTypeId16},
-      {{2, TypeTag(kCodeToTypeId), PoolTag(kTypeId)},
-       &DisassemblerDex::MakeReadCodeToTypeId16,
-       &DisassemblerDex::MakeWriteTypeId16},
-      {{2, TypeTag(kCodeToProtoId), PoolTag(kProtoId)},
-       &DisassemblerDex::MakeReadCodeToProtoId16,
-       &DisassemblerDex::MakeWriteProtoId16},
-      {{2, TypeTag(kMethodIdToProtoId), PoolTag(kProtoId)},
-       &DisassemblerDex::MakeReadMethodIdToProtoId16,
-       &DisassemblerDex::MakeWriteProtoId16},
-      {{2, TypeTag(kCodeToFieldId), PoolTag(kFieldId)},
-       &DisassemblerDex::MakeReadCodeToFieldId16,
-       &DisassemblerDex::MakeWriteFieldId16},
-      {{2, TypeTag(kMethodHandleToFieldId), PoolTag(kFieldId)},
-       &DisassemblerDex::MakeReadMethodHandleToFieldId16,
-       &DisassemblerDex::MakeWriteFieldId16},
-      {{4, TypeTag(kAnnotationsDirectoryToFieldId), PoolTag(kFieldId)},
-       &DisassemblerDex::MakeReadAnnotationsDirectoryToFieldId32,
-       &DisassemblerDex::MakeWriteFieldId32},
-      {{2, TypeTag(kCodeToMethodId), PoolTag(kMethodId)},
-       &DisassemblerDex::MakeReadCodeToMethodId16,
-       &DisassemblerDex::MakeWriteMethodId16},
-      {{2, TypeTag(kMethodHandleToMethodId), PoolTag(kMethodId)},
-       &DisassemblerDex::MakeReadMethodHandleToMethodId16,
-       &DisassemblerDex::MakeWriteMethodId16},
-      {{4, TypeTag(kAnnotationsDirectoryToMethodId), PoolTag(kMethodId)},
-       &DisassemblerDex::MakeReadAnnotationsDirectoryToMethodId32,
-       &DisassemblerDex::MakeWriteMethodId32},
-      {{4, TypeTag(kAnnotationsDirectoryToParameterMethodId),
-        PoolTag(kMethodId)},
-       &DisassemblerDex::MakeReadAnnotationsDirectoryToParameterMethodId32,
-       &DisassemblerDex::MakeWriteMethodId32},
-      {{2, TypeTag(kCodeToCallSiteId), PoolTag(kCallSiteId)},
-       &DisassemblerDex::MakeReadCodeToCallSiteId16,
-       &DisassemblerDex::MakeWriteCallSiteId16},
-      {{2, TypeTag(kCodeToMethodHandle), PoolTag(kMethodHandle)},
-       &DisassemblerDex::MakeReadCodeToMethodHandle16,
-       &DisassemblerDex::MakeWriteMethodHandle16},
-      {{4, TypeTag(kProtoIdToParametersTypeList), PoolTag(kTypeList)},
-       &DisassemblerDex::MakeReadProtoIdToParametersTypeList,
-       &DisassemblerDex::MakeWriteAbs32},
-      {{4, TypeTag(kClassDefToInterfacesTypeList), PoolTag(kTypeList)},
-       &DisassemblerDex::MakeReadClassDefToInterfacesTypeList,
-       &DisassemblerDex::MakeWriteAbs32},
-      {{4, TypeTag(kAnnotationsDirectoryToParameterAnnotationSetRef),
-        PoolTag(kAnnotationSetRefList)},
-       &DisassemblerDex::
-           MakeReadAnnotationsDirectoryToParameterAnnotationSetRef,
-       &DisassemblerDex::MakeWriteAbs32},
-      {{4, TypeTag(kAnnotationSetRefListToAnnotationSet),
-        PoolTag(kAnnotionSet)},
-       &DisassemblerDex::MakeReadAnnotationSetRefListToAnnotationSet,
-       &DisassemblerDex::MakeWriteAbs32},
-      {{4, TypeTag(kAnnotationsDirectoryToClassAnnotationSet),
-        PoolTag(kAnnotionSet)},
-       &DisassemblerDex::MakeReadAnnotationsDirectoryToClassAnnotationSet,
-       &DisassemblerDex::MakeWriteAbs32},
-      {{4, TypeTag(kAnnotationsDirectoryToFieldAnnotationSet),
-        PoolTag(kAnnotionSet)},
-       &DisassemblerDex::MakeReadAnnotationsDirectoryToFieldAnnotationSet,
-       &DisassemblerDex::MakeWriteAbs32},
-      {{4, TypeTag(kAnnotationsDirectoryToMethodAnnotationSet),
-        PoolTag(kAnnotionSet)},
-       &DisassemblerDex::MakeReadAnnotationsDirectoryToMethodAnnotationSet,
-       &DisassemblerDex::MakeWriteAbs32},
-      {{4, TypeTag(kClassDefToClassData), PoolTag(kClassData)},
-       &DisassemblerDex::MakeReadClassDefToClassData,
-       &DisassemblerDex::MakeWriteAbs32},
-      {{1, TypeTag(kCodeToRelCode8), PoolTag(kCode)},
-       &DisassemblerDex::MakeReadCodeToRelCode8,
-       &DisassemblerDex::MakeWriteRelCode8},
-      {{2, TypeTag(kCodeToRelCode16), PoolTag(kCode)},
-       &DisassemblerDex::MakeReadCodeToRelCode16,
-       &DisassemblerDex::MakeWriteRelCode16},
-      {{4, TypeTag(kCodeToRelCode32), PoolTag(kCode)},
-       &DisassemblerDex::MakeReadCodeToRelCode32,
-       &DisassemblerDex::MakeWriteRelCode32},
-      {{4, TypeTag(kStringIdToStringData), PoolTag(kStringData)},
-       &DisassemblerDex::MakeReadStringIdToStringData,
-       &DisassemblerDex::MakeWriteAbs32},
-      {{4, TypeTag(kAnnotationSetToAnnotation), PoolTag(kAnnotation)},
-       &DisassemblerDex::MakeReadAnnotationSetToAnnotation,
-       &DisassemblerDex::MakeWriteAbs32},
-      {{4, TypeTag(kClassDefToStaticValuesEncodedArray),
-        PoolTag(kEncodedArray)},
-       &DisassemblerDex::MakeReadClassDefToStaticValuesEncodedArray,
-       &DisassemblerDex::MakeWriteAbs32},
-      {{4, TypeTag(kClassDefToAnnotationDirectory),
-        PoolTag(kAnnotationsDirectory)},
-       &DisassemblerDex::MakeReadClassDefToAnnotationDirectory,
-       &DisassemblerDex::MakeWriteAbs32},
-      {{4, TypeTag(kCallSiteIdToCallSite), PoolTag(kCallSite)},
-       &DisassemblerDex::MakeReadCallSiteIdToCallSite32,
-       &DisassemblerDex::MakeWriteAbs32},
-  };
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadStringIdToStringData(
-    offset_t lo,
-    offset_t hi) {
-  // dex::StringIdItem::string_data_off mapper.
-  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, string_map_item_, sizeof(dex::StringIdItem),
-      offsetof(dex::StringIdItem, string_data_off), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadTypeIdToDescriptorStringId32(offset_t lo,
-                                                      offset_t hi) {
-  auto mapper = base::BindRepeating(
-      ReadTargetIndex<decltype(dex::TypeIdItem::descriptor_idx)>, image_,
-      string_map_item_, sizeof(dex::StringIdItem));
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, type_map_item_, sizeof(dex::TypeIdItem),
-      offsetof(dex::TypeIdItem, descriptor_idx), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadProtoIdToShortyStringId32(offset_t lo, offset_t hi) {
-  auto mapper = base::BindRepeating(
-      ReadTargetIndex<decltype(dex::ProtoIdItem::shorty_idx)>, image_,
-      string_map_item_, sizeof(dex::StringIdItem));
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, proto_map_item_, sizeof(dex::ProtoIdItem),
-      offsetof(dex::ProtoIdItem, shorty_idx), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadProtoIdToReturnTypeId32(offset_t lo, offset_t hi) {
-  auto mapper = base::BindRepeating(
-      ReadTargetIndex<decltype(dex::ProtoIdItem::return_type_idx)>, image_,
-      type_map_item_, sizeof(dex::TypeIdItem));
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, proto_map_item_, sizeof(dex::ProtoIdItem),
-      offsetof(dex::ProtoIdItem, return_type_idx), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadProtoIdToParametersTypeList(offset_t lo, offset_t hi) {
-  // dex::ProtoIdItem::parameters_off mapper.
-  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, proto_map_item_, sizeof(dex::ProtoIdItem),
-      offsetof(dex::ProtoIdItem, parameters_off), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadFieldToClassTypeId16(
-    offset_t lo,
-    offset_t hi) {
-  auto mapper = base::BindRepeating(
-      ReadTargetIndex<decltype(dex::FieldIdItem::class_idx)>, image_,
-      type_map_item_, sizeof(dex::TypeIdItem));
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, field_map_item_, sizeof(dex::FieldIdItem),
-      offsetof(dex::FieldIdItem, class_idx), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadFieldToTypeId16(
-    offset_t lo,
-    offset_t hi) {
-  auto mapper =
-      base::BindRepeating(ReadTargetIndex<decltype(dex::FieldIdItem::type_idx)>,
-                          image_, type_map_item_, sizeof(dex::TypeIdItem));
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, field_map_item_, sizeof(dex::FieldIdItem),
-      offsetof(dex::FieldIdItem, type_idx), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadFieldToNameStringId32(
-    offset_t lo,
-    offset_t hi) {
-  auto mapper =
-      base::BindRepeating(ReadTargetIndex<decltype(dex::FieldIdItem::name_idx)>,
-                          image_, string_map_item_, sizeof(dex::StringIdItem));
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, field_map_item_, sizeof(dex::FieldIdItem),
-      offsetof(dex::FieldIdItem, name_idx), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadMethodIdToClassTypeId16(offset_t lo, offset_t hi) {
-  auto mapper = base::BindRepeating(
-      ReadTargetIndex<decltype(dex::MethodIdItem::class_idx)>, image_,
-      type_map_item_, sizeof(dex::TypeIdItem));
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, method_map_item_, sizeof(dex::MethodIdItem),
-      offsetof(dex::MethodIdItem, class_idx), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadMethodIdToProtoId16(
-    offset_t lo,
-    offset_t hi) {
-  auto mapper = base::BindRepeating(
-      ReadTargetIndex<decltype(dex::MethodIdItem::proto_idx)>, image_,
-      proto_map_item_, sizeof(dex::ProtoIdItem));
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, method_map_item_, sizeof(dex::MethodIdItem),
-      offsetof(dex::MethodIdItem, proto_idx), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadMethodIdToNameStringId32(offset_t lo, offset_t hi) {
-  auto mapper = base::BindRepeating(
-      ReadTargetIndex<decltype(dex::MethodIdItem::name_idx)>, image_,
-      string_map_item_, sizeof(dex::StringIdItem));
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, method_map_item_, sizeof(dex::MethodIdItem),
-      offsetof(dex::MethodIdItem, name_idx), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadClassDefToClassTypeId32(offset_t lo, offset_t hi) {
-  auto mapper = base::BindRepeating(
-      ReadTargetIndex<decltype(dex::ClassDefItem::superclass_idx)>, image_,
-      type_map_item_, sizeof(dex::TypeIdItem));
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
-      offsetof(dex::ClassDefItem, class_idx), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadClassDefToSuperClassTypeId32(offset_t lo,
-                                                      offset_t hi) {
-  auto mapper = base::BindRepeating(
-      ReadTargetIndex<decltype(dex::ClassDefItem::superclass_idx)>, image_,
-      type_map_item_, sizeof(dex::TypeIdItem));
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
-      offsetof(dex::ClassDefItem, superclass_idx), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadClassDefToInterfacesTypeList(offset_t lo,
-                                                      offset_t hi) {
-  // dex::ClassDefItem::interfaces_off mapper.
-  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
-      offsetof(dex::ClassDefItem, interfaces_off), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadClassDefToSourceFileStringId32(offset_t lo,
-                                                        offset_t hi) {
-  auto mapper = base::BindRepeating(
-      ReadTargetIndex<decltype(dex::ClassDefItem::source_file_idx)>, image_,
-      string_map_item_, sizeof(dex::StringIdItem));
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
-      offsetof(dex::ClassDefItem, source_file_idx), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadClassDefToAnnotationDirectory(offset_t lo,
-                                                       offset_t hi) {
-  // dex::ClassDefItem::annotations_off mapper.
-  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
-      offsetof(dex::ClassDefItem, annotations_off), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadClassDefToClassData(
-    offset_t lo,
-    offset_t hi) {
-  // dex::ClassDefItem::class_data_off mapper.
-  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
-      offsetof(dex::ClassDefItem, class_data_off), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadClassDefToStaticValuesEncodedArray(offset_t lo,
-                                                            offset_t hi) {
-  // dex::ClassDefItem::static_values_off mapper.
-  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
-      offsetof(dex::ClassDefItem, static_values_off), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadCallSiteIdToCallSite32(offset_t lo, offset_t hi) {
-  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, call_site_map_item_, sizeof(dex::CallSiteIdItem),
-      offsetof(dex::CallSiteIdItem, call_site_off), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadMethodHandleToFieldId16(offset_t lo, offset_t hi) {
-  auto mapper = base::BindRepeating(ReadMethodHandleFieldOrMethodId, image_,
-                                    field_map_item_, sizeof(dex::FieldIdItem),
-                                    dex::MethodHandleType::kStaticPut,
-                                    dex::MethodHandleType::kInstanceGet);
-  // Use |mapper_wants_item == true| for ItemReferenceReader such that
-  // |location| is aligned with MethodHandleItem when passed to |mapper|. This
-  // allows ReadMethodHandleFieldOrMethodId to safely determine whether the
-  // reference in the MethodHandleItem is of the correct type to be emitted.
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, method_handle_map_item_, sizeof(dex::MethodHandleItem),
-      offsetof(dex::MethodHandleItem, field_or_method_id), std::move(mapper),
-      /*mapper_wants_item=*/true);
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadMethodHandleToMethodId16(offset_t lo, offset_t hi) {
-  auto mapper = base::BindRepeating(ReadMethodHandleFieldOrMethodId, image_,
-                                    method_map_item_, sizeof(dex::MethodIdItem),
-                                    dex::MethodHandleType::kInvokeStatic,
-                                    dex::MethodHandleType::kInvokeInterface);
-  // Use |mapper_wants_item == true| for ItemReferenceReader such that
-  // |location| is aligned with MethodHandleItem when passed to |mapper|. This
-  // allows ReadMethodHandleFieldOrMethodId to safely determine whether the
-  // reference in the MethodHandleItem is of the correct type to be emitted.
-  return std::make_unique<ItemReferenceReader>(
-      lo, hi, method_handle_map_item_, sizeof(dex::MethodHandleItem),
-      offsetof(dex::MethodHandleItem, field_or_method_id), std::move(mapper),
-      /*mapper_wants_item=*/true);
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadTypeListToTypeId16(
-    offset_t lo,
-    offset_t hi) {
-  auto mapper =
-      base::BindRepeating(ReadTargetIndex<decltype(dex::TypeItem::type_idx)>,
-                          image_, type_map_item_, sizeof(dex::TypeIdItem));
-  return std::make_unique<CachedItemListReferenceReader>(
-      lo, hi, offsetof(dex::TypeItem, type_idx), type_list_offsets_,
-      std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadAnnotationSetToAnnotation(offset_t lo, offset_t hi) {
-  // dex::AnnotationOffItem::annotation_off mapper.
-  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
-  return std::make_unique<CachedItemListReferenceReader>(
-      lo, hi, offsetof(dex::AnnotationOffItem, annotation_off),
-      annotation_set_offsets_, std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadAnnotationSetRefListToAnnotationSet(offset_t lo,
-                                                             offset_t hi) {
-  // dex::AnnotationSetRefItem::annotations_off mapper.
-  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
-  return std::make_unique<CachedItemListReferenceReader>(
-      lo, hi, offsetof(dex::AnnotationSetRefItem, annotations_off),
-      annotation_set_ref_list_offsets_, std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadAnnotationsDirectoryToClassAnnotationSet(offset_t lo,
-                                                                  offset_t hi) {
-  // dex::AnnotationsDirectoryItem::class_annotations_off mapper.
-  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
-  return std::make_unique<CachedItemListReferenceReader>(
-      lo, hi, offsetof(dex::AnnotationsDirectoryItem, class_annotations_off),
-      annotations_directory_item_offsets_, std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadAnnotationsDirectoryToFieldId32(offset_t lo,
-                                                         offset_t hi) {
-  auto mapper = base::BindRepeating(
-      ReadTargetIndex<decltype(dex::FieldAnnotation::field_idx)>, image_,
-      field_map_item_, sizeof(dex::FieldIdItem));
-  return std::make_unique<CachedItemListReferenceReader>(
-      lo, hi, offsetof(dex::FieldAnnotation, field_idx),
-      annotations_directory_item_field_annotation_offsets_, std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadAnnotationsDirectoryToFieldAnnotationSet(offset_t lo,
-                                                                  offset_t hi) {
-  // dex::FieldAnnotation::annotations_off mapper.
-  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
-  return std::make_unique<CachedItemListReferenceReader>(
-      lo, hi, offsetof(dex::FieldAnnotation, annotations_off),
-      annotations_directory_item_field_annotation_offsets_, std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadAnnotationsDirectoryToMethodId32(offset_t lo,
-                                                          offset_t hi) {
-  auto mapper = base::BindRepeating(
-      ReadTargetIndex<decltype(dex::MethodAnnotation::method_idx)>, image_,
-      method_map_item_, sizeof(dex::MethodIdItem));
-  return std::make_unique<CachedItemListReferenceReader>(
-      lo, hi, offsetof(dex::MethodAnnotation, method_idx),
-      annotations_directory_item_method_annotation_offsets_, std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadAnnotationsDirectoryToMethodAnnotationSet(
-    offset_t lo,
-    offset_t hi) {
-  // dex::MethodAnnotation::annotations_off mapper.
-  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
-  return std::make_unique<CachedItemListReferenceReader>(
-      lo, hi, offsetof(dex::MethodAnnotation, annotations_off),
-      annotations_directory_item_method_annotation_offsets_, std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadAnnotationsDirectoryToParameterMethodId32(
-    offset_t lo,
-    offset_t hi) {
-  auto mapper = base::BindRepeating(
-      ReadTargetIndex<decltype(dex::ParameterAnnotation::method_idx)>, image_,
-      method_map_item_, sizeof(dex::MethodIdItem));
-  return std::make_unique<CachedItemListReferenceReader>(
-      lo, hi, offsetof(dex::ParameterAnnotation, method_idx),
-      annotations_directory_item_parameter_annotation_offsets_,
-      std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader>
-DisassemblerDex::MakeReadAnnotationsDirectoryToParameterAnnotationSetRef(
-    offset_t lo,
-    offset_t hi) {
-  // dex::ParameterAnnotation::annotations_off mapper.
-  auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
-  return std::make_unique<CachedItemListReferenceReader>(
-      lo, hi, offsetof(dex::ParameterAnnotation, annotations_off),
-      annotations_directory_item_parameter_annotation_offsets_,
-      std::move(mapper));
-}
-
-// MakeReadCode* readers use offset relative to the instruction beginning based
-// on the instruction format ID.
-// See https://source.android.com/devices/tech/dalvik/instruction-formats
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToStringId16(
-    offset_t lo,
-    offset_t hi) {
-  auto filter = base::BindRepeating(
-      [](const InstructionParser::Value& value) -> offset_t {
-        if (value.instr->format == dex::FormatId::c &&
-            (value.instr->opcode == 0x1A)) {  // const-string
-          // BBBB from e.g., const-string vAA, string@BBBB.
-          return value.instr_offset + 2;
-        }
-        return kInvalidOffset;
-      });
-  auto mapper =
-      base::BindRepeating(ReadTargetIndex<uint16_t>, image_, string_map_item_,
-                          sizeof(dex::StringIdItem));
-  return std::make_unique<InstructionReferenceReader>(
-      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToStringId32(
-    offset_t lo,
-    offset_t hi) {
-  auto filter = base::BindRepeating(
-      [](const InstructionParser::Value& value) -> offset_t {
-        if (value.instr->format == dex::FormatId::c &&
-            (value.instr->opcode == 0x1B)) {  // const-string/jumbo
-          // BBBBBBBB from e.g., const-string/jumbo vAA, string@BBBBBBBB.
-          return value.instr_offset + 2;
-        }
-        return kInvalidOffset;
-      });
-  auto mapper =
-      base::BindRepeating(ReadTargetIndex<uint32_t>, image_, string_map_item_,
-                          sizeof(dex::StringIdItem));
-  return std::make_unique<InstructionReferenceReader>(
-      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToTypeId16(
-    offset_t lo,
-    offset_t hi) {
-  auto filter = base::BindRepeating(
-      [](const InstructionParser::Value& value) -> offset_t {
-        if (value.instr->format == dex::FormatId::c &&
-            (value.instr->opcode == 0x1C ||   // const-class
-             value.instr->opcode == 0x1F ||   // check-cast
-             value.instr->opcode == 0x20 ||   // instance-of
-             value.instr->opcode == 0x22 ||   // new-instance
-             value.instr->opcode == 0x23 ||   // new-array
-             value.instr->opcode == 0x24 ||   // filled-new-array
-             value.instr->opcode == 0x25)) {  // filled-new-array/range
-          // BBBB from e.g., const-class vAA, type@BBBB.
-          return value.instr_offset + 2;
-        }
-        return kInvalidOffset;
-      });
-  auto mapper = base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
-                                    type_map_item_, sizeof(dex::TypeIdItem));
-  return std::make_unique<InstructionReferenceReader>(
-      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToProtoId16(
-    offset_t lo,
-    offset_t hi) {
-  auto filter = base::BindRepeating(
-      [](const InstructionParser::Value& value) -> offset_t {
-        if (value.instr->format == dex::FormatId::c) {
-          if (value.instr->opcode == 0xFA ||  // invoke-polymorphic
-              value.instr->opcode == 0xFB) {  // invoke-polymorphic/range
-            // HHHH from e.g, invoke-polymorphic {vC, vD, vE, vF, vG},
-            //   meth@BBBB, proto@HHHH
-            return value.instr_offset + 6;
-          }
-          if (value.instr->opcode == 0xFF) {  // const-method-type
-            // BBBB from e.g., const-method-type vAA, proto@BBBB
-            return value.instr_offset + 2;
-          }
-        }
-        return kInvalidOffset;
-      });
-  auto mapper = base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
-                                    proto_map_item_, sizeof(dex::ProtoIdItem));
-  return std::make_unique<InstructionReferenceReader>(
-      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToCallSiteId16(
-    offset_t lo,
-    offset_t hi) {
-  auto filter = base::BindRepeating(
-      [](const InstructionParser::Value& value) -> offset_t {
-        if (value.instr->format == dex::FormatId::c &&
-            (value.instr->opcode == 0xFC ||   // invoke-custom
-             value.instr->opcode == 0xFD)) {  // invoke-custom/range
-          // BBBB from e.g, invoke-custom {vC, vD, vE, vF, vG},
-          //   call_site@BBBB
-          return value.instr_offset + 2;
-        }
-        return kInvalidOffset;
-      });
-  auto mapper =
-      base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
-                          call_site_map_item_, sizeof(dex::CallSiteIdItem));
-  return std::make_unique<InstructionReferenceReader>(
-      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToMethodHandle16(
-    offset_t lo,
-    offset_t hi) {
-  auto filter = base::BindRepeating(
-      [](const InstructionParser::Value& value) -> offset_t {
-        if (value.instr->format == dex::FormatId::c &&
-            value.instr->opcode == 0xFE) {  // const-method-handle
-          // BBBB from e.g, const-method-handle vAA, method_handle@BBBB
-          return value.instr_offset + 2;
-        }
-        return kInvalidOffset;
-      });
-  auto mapper = base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
-                                    method_handle_map_item_,
-                                    sizeof(dex::MethodHandleItem));
-  return std::make_unique<InstructionReferenceReader>(
-      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToFieldId16(
-    offset_t lo,
-    offset_t hi) {
-  auto filter = base::BindRepeating(
-      [](const InstructionParser::Value& value) -> offset_t {
-        if (value.instr->format == dex::FormatId::c &&
-            (value.instr->opcode == 0x52 ||   // iinstanceop (iget-*, iput-*)
-             value.instr->opcode == 0x60)) {  // sstaticop (sget-*, sput-*)
-          // CCCC from e.g., iget vA, vB, field@CCCC.
-          return value.instr_offset + 2;
-        }
-        return kInvalidOffset;
-      });
-  auto mapper = base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
-                                    field_map_item_, sizeof(dex::FieldIdItem));
-  return std::make_unique<InstructionReferenceReader>(
-      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToMethodId16(
-    offset_t lo,
-    offset_t hi) {
-  auto filter = base::BindRepeating(
-      [](const InstructionParser::Value& value) -> offset_t {
-        if (value.instr->format == dex::FormatId::c &&
-            (value.instr->opcode == 0x6E ||   // invoke-kind
-             value.instr->opcode == 0x74 ||   // invoke-kind/range
-             value.instr->opcode == 0xFA ||   // invoke-polymorphic
-             value.instr->opcode == 0xFB)) {  // invoke-polymorphic/range
-          // BBBB from e.g., invoke-virtual {vC, vD, vE, vF, vG}, meth@BBBB.
-          return value.instr_offset + 2;
-        }
-        return kInvalidOffset;
-      });
-  auto mapper =
-      base::BindRepeating(ReadTargetIndex<uint16_t>, image_, method_map_item_,
-                          sizeof(dex::MethodIdItem));
-  return std::make_unique<InstructionReferenceReader>(
-      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToRelCode8(
-    offset_t lo,
-    offset_t hi) {
-  auto filter = base::BindRepeating(
-      [](const InstructionParser::Value& value) -> offset_t {
-        if (value.instr->format == dex::FormatId::t &&
-            value.instr->opcode == 0x28) {  // goto
-          // +AA from e.g., goto +AA.
-          return value.instr_offset + 1;
-        }
-        return kInvalidOffset;
-      });
-  auto mapper = base::BindRepeating(
-      [](DisassemblerDex* dis, offset_t location) {
-        // Address is relative to the current instruction, which begins 1 unit
-        // before |location|. This needs to be subtracted out. Also, store as
-        // int32_t so |unsafe_delta - 1| won't underflow!
-        int32_t unsafe_delta = dis->image_.read<int8_t>(location);
-        offset_t unsafe_target = static_cast<offset_t>(
-            location + (unsafe_delta - 1) * kInstrUnitSize);
-        // TODO(huangs): Check that |unsafe_target| stays within code item.
-        return unsafe_target;
-      },
-      base::Unretained(this));
-  return std::make_unique<InstructionReferenceReader>(
-      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToRelCode16(
-    offset_t lo,
-    offset_t hi) {
-  auto filter = base::BindRepeating(
-      [](const InstructionParser::Value& value) -> offset_t {
-        if (value.instr->format == dex::FormatId::t &&
-            (value.instr->opcode == 0x29 ||   // goto/16
-             value.instr->opcode == 0x32 ||   // if-test
-             value.instr->opcode == 0x38)) {  // if-testz
-          // +AAAA from e.g., goto/16 +AAAA.
-          return value.instr_offset + 2;
-        }
-        return kInvalidOffset;
-      });
-  auto mapper = base::BindRepeating(
-      [](DisassemblerDex* dis, offset_t location) {
-        // Address is relative to the current instruction, which begins 1 unit
-        // before |location|. This needs to be subtracted out. Also, store as
-        // int32_t so |unsafe_delta - 1| won't underflow!
-        int32_t unsafe_delta = dis->image_.read<int16_t>(location);
-        offset_t unsafe_target = static_cast<offset_t>(
-            location + (unsafe_delta - 1) * kInstrUnitSize);
-        // TODO(huangs): Check that |unsafe_target| stays within code item.
-        return unsafe_target;
-      },
-      base::Unretained(this));
-  return std::make_unique<InstructionReferenceReader>(
-      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToRelCode32(
-    offset_t lo,
-    offset_t hi) {
-  auto filter = base::BindRepeating(
-      [](const InstructionParser::Value& value) -> offset_t {
-        if (value.instr->format == dex::FormatId::t &&
-            (value.instr->opcode == 0x26 ||   // fill-array-data
-             value.instr->opcode == 0x2A ||   // goto/32
-             value.instr->opcode == 0x2B ||   // packed-switch
-             value.instr->opcode == 0x2C)) {  // sparse-switch
-          // +BBBBBBBB from e.g., fill-array-data vAA, +BBBBBBBB.
-          // +AAAAAAAA from e.g., goto/32 +AAAAAAAA.
-          return value.instr_offset + 2;
-        }
-        return kInvalidOffset;
-      });
-  auto mapper = base::BindRepeating(
-      [](DisassemblerDex* dis, offset_t location) {
-        // Address is relative to the current instruction, which begins 1 unit
-        // before |location|. This needs to be subtracted out. Use int64_t to
-        // avoid underflow and overflow.
-        int64_t unsafe_delta = dis->image_.read<int32_t>(location);
-        int64_t unsafe_target = location + (unsafe_delta - 1) * kInstrUnitSize;
-
-        // TODO(huangs): Check that |unsafe_target| stays within code item.
-        offset_t checked_unsafe_target =
-            static_cast<offset_t>(base::CheckedNumeric<offset_t>(unsafe_target)
-                                      .ValueOrDefault(kInvalidOffset));
-        return checked_unsafe_target < kOffsetBound ? checked_unsafe_target
-                                                    : kInvalidOffset;
-      },
-      base::Unretained(this));
-  return std::make_unique<InstructionReferenceReader>(
-      image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteStringId16(
-    MutableBufferView image) {
-  auto writer = base::BindRepeating(
-      WriteTargetIndex<uint16_t>, string_map_item_, sizeof(dex::StringIdItem));
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteStringId32(
-    MutableBufferView image) {
-  auto writer = base::BindRepeating(
-      WriteTargetIndex<uint32_t>, string_map_item_, sizeof(dex::StringIdItem));
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteTypeId16(
-    MutableBufferView image) {
-  auto writer = base::BindRepeating(WriteTargetIndex<uint16_t>, type_map_item_,
-                                    sizeof(dex::TypeIdItem));
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteTypeId32(
-    MutableBufferView image) {
-  auto writer = base::BindRepeating(WriteTargetIndex<uint32_t>, type_map_item_,
-                                    sizeof(dex::TypeIdItem));
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteProtoId16(
-    MutableBufferView image) {
-  auto writer = base::BindRepeating(WriteTargetIndex<uint16_t>, proto_map_item_,
-                                    sizeof(dex::ProtoIdItem));
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteFieldId16(
-    MutableBufferView image) {
-  auto writer = base::BindRepeating(WriteTargetIndex<uint16_t>, field_map_item_,
-                                    sizeof(dex::FieldIdItem));
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteFieldId32(
-    MutableBufferView image) {
-  auto writer = base::BindRepeating(WriteTargetIndex<uint32_t>, field_map_item_,
-                                    sizeof(dex::FieldIdItem));
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteMethodId16(
-    MutableBufferView image) {
-  auto writer = base::BindRepeating(
-      WriteTargetIndex<uint16_t>, method_map_item_, sizeof(dex::MethodIdItem));
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteMethodId32(
-    MutableBufferView image) {
-  auto writer = base::BindRepeating(
-      WriteTargetIndex<uint32_t>, method_map_item_, sizeof(dex::MethodIdItem));
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteCallSiteId16(
-    MutableBufferView image) {
-  auto writer =
-      base::BindRepeating(WriteTargetIndex<uint16_t>, call_site_map_item_,
-                          sizeof(dex::CallSiteIdItem));
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteMethodHandle16(
-    MutableBufferView image) {
-  auto writer =
-      base::BindRepeating(WriteTargetIndex<uint16_t>, method_handle_map_item_,
-                          sizeof(dex::MethodHandleItem));
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteRelCode8(
-    MutableBufferView image) {
-  auto writer = base::BindRepeating([](Reference ref, MutableBufferView image) {
-    ptrdiff_t unsafe_byte_diff =
-        static_cast<ptrdiff_t>(ref.target) - ref.location;
-    DCHECK_EQ(0, unsafe_byte_diff % kInstrUnitSize);
-    // |delta| is relative to start of instruction, which is 1 unit before
-    // |ref.location|. The subtraction above removed too much, so +1 to fix.
-    base::CheckedNumeric<int8_t> delta((unsafe_byte_diff / kInstrUnitSize) + 1);
-    if (!delta.IsValid()) {
-      LOG(ERROR) << "Invalid reference at: " << AsHex<8>(ref.location) << ".";
-      return;
-    }
-    image.write<int8_t>(ref.location, delta.ValueOrDie());
-  });
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteRelCode16(
-    MutableBufferView image) {
-  auto writer = base::BindRepeating([](Reference ref, MutableBufferView image) {
-    ptrdiff_t unsafe_byte_diff =
-        static_cast<ptrdiff_t>(ref.target) - ref.location;
-    DCHECK_EQ(0, unsafe_byte_diff % kInstrUnitSize);
-    // |delta| is relative to start of instruction, which is 1 unit before
-    // |ref.location|. The subtraction above removed too much, so +1 to fix.
-    base::CheckedNumeric<int16_t> delta((unsafe_byte_diff / kInstrUnitSize) +
-                                        1);
-    if (!delta.IsValid()) {
-      LOG(ERROR) << "Invalid reference at: " << AsHex<8>(ref.location) << ".";
-      return;
-    }
-    image.write<int16_t>(ref.location, delta.ValueOrDie());
-  });
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteRelCode32(
-    MutableBufferView image) {
-  auto writer = base::BindRepeating([](Reference ref, MutableBufferView image) {
-    ptrdiff_t unsafe_byte_diff =
-        static_cast<ptrdiff_t>(ref.target) - ref.location;
-    DCHECK_EQ(0, unsafe_byte_diff % kInstrUnitSize);
-    // |delta| is relative to start of instruction, which is 1 unit before
-    // |ref.location|. The subtraction above removed too much, so +1 to fix.
-    base::CheckedNumeric<int32_t> delta((unsafe_byte_diff / kInstrUnitSize) +
-                                        1);
-    if (!delta.IsValid()) {
-      LOG(ERROR) << "Invalid reference at: " << AsHex<8>(ref.location) << ".";
-      return;
-    }
-    image.write<int32_t>(ref.location, delta.ValueOrDie());
-  });
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteAbs32(
-    MutableBufferView image) {
-  auto writer = base::BindRepeating([](Reference ref, MutableBufferView image) {
-    image.write<uint32_t>(ref.location, ref.target);
-  });
-  return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
-}
-
-bool DisassemblerDex::Parse(ConstBufferView image) {
-  image_ = image;
-  return ParseHeader();
-}
-
-bool DisassemblerDex::ParseHeader() {
-  ReadDexHeaderResults results;
-  if (!ReadDexHeader(image_, &results))
-    return false;
-
-  header_ = results.header;
-  dex_version_ = results.dex_version;
-  BufferSource source = results.source;
-
-  // DEX header contains file size, so use it to resize |image_| right away.
-  image_.shrink(header_->file_size);
-
-  // Read map list. This is not a fixed-size array, so instead of reading
-  // MapList directly, read |MapList::size| first, then visit elements in
-  // |MapList::list|.
-  static_assert(
-      offsetof(dex::MapList, list) == sizeof(decltype(dex::MapList::size)),
-      "MapList size error.");
-  source = std::move(BufferSource(image_).Skip(header_->map_off));
-  decltype(dex::MapList::size) list_size = 0;
-  if (!source.GetValue(&list_size) || list_size > dex::kMaxItemListSize)
-    return false;
-  const auto* item_list = source.GetArray<const dex::MapItem>(list_size);
-  if (!item_list)
-    return false;
-
-  // Read and validate map list, ensuring that required item types are present.
-  // GetItemBaseSize() should have an entry for each item.
-  for (offset_t i = 0; i < list_size; ++i) {
-    const dex::MapItem* item = &item_list[i];
-    // Reject unreasonably large |item->size|.
-    size_t item_size = GetItemBaseSize(item->type);
-    // Confusing name: |item->size| is actually the number of items.
-    if (!image_.covers_array(item->offset, item->size, item_size))
-      return false;
-    if (!map_item_map_.insert(std::make_pair(item->type, item)).second)
-      return false;  // A given type must appear at most once.
-  }
-
-  // Make local copies of main map items.
-  if (map_item_map_.count(dex::kTypeStringIdItem)) {
-    string_map_item_ = *map_item_map_[dex::kTypeStringIdItem];
-  }
-  if (map_item_map_.count(dex::kTypeTypeIdItem)) {
-    type_map_item_ = *map_item_map_[dex::kTypeTypeIdItem];
-  }
-  if (map_item_map_.count(dex::kTypeProtoIdItem)) {
-    proto_map_item_ = *map_item_map_[dex::kTypeProtoIdItem];
-  }
-  if (map_item_map_.count(dex::kTypeFieldIdItem)) {
-    field_map_item_ = *map_item_map_[dex::kTypeFieldIdItem];
-  }
-  if (map_item_map_.count(dex::kTypeMethodIdItem)) {
-    method_map_item_ = *map_item_map_[dex::kTypeMethodIdItem];
-  }
-  if (map_item_map_.count(dex::kTypeClassDefItem)) {
-    class_def_map_item_ = *map_item_map_[dex::kTypeClassDefItem];
-  }
-  if (map_item_map_.count(dex::kTypeCallSiteIdItem)) {
-    call_site_map_item_ = *map_item_map_[dex::kTypeCallSiteIdItem];
-  }
-  if (map_item_map_.count(dex::kTypeMethodHandleItem)) {
-    method_handle_map_item_ = *map_item_map_[dex::kTypeMethodHandleItem];
-  }
-  if (map_item_map_.count(dex::kTypeTypeList)) {
-    type_list_map_item_ = *map_item_map_[dex::kTypeTypeList];
-  }
-  if (map_item_map_.count(dex::kTypeAnnotationSetRefList)) {
-    annotation_set_ref_list_map_item_ =
-        *map_item_map_[dex::kTypeAnnotationSetRefList];
-  }
-  if (map_item_map_.count(dex::kTypeAnnotationSetItem)) {
-    annotation_set_map_item_ = *map_item_map_[dex::kTypeAnnotationSetItem];
-  }
-  if (map_item_map_.count(dex::kTypeCodeItem)) {
-    code_map_item_ = *map_item_map_[dex::kTypeCodeItem];
-  }
-  if (map_item_map_.count(dex::kTypeAnnotationsDirectoryItem)) {
-    annotations_directory_map_item_ =
-        *map_item_map_[dex::kTypeAnnotationsDirectoryItem];
-  }
-
-  // Iteratively parse variable length lists, annotations directory items, and
-  // code items blocks. Any failure would indicate invalid DEX. Success
-  // indicates that no structural problem is found. However, contained
-  // references data read from parsed items still require validation.
-  if (!(ParseItemOffsets(image_, type_list_map_item_, sizeof(dex::TypeItem),
-                         &type_list_offsets_) &&
-        ParseItemOffsets(image_, annotation_set_ref_list_map_item_,
-                         sizeof(dex::AnnotationSetRefItem),
-                         &annotation_set_ref_list_offsets_) &&
-        ParseItemOffsets(image_, annotation_set_map_item_,
-                         sizeof(dex::AnnotationOffItem),
-                         &annotation_set_offsets_) &&
-        ParseAnnotationsDirectoryItems(
-            image_, annotations_directory_map_item_,
-            &annotations_directory_item_offsets_,
-            &annotations_directory_item_field_annotation_offsets_,
-            &annotations_directory_item_method_annotation_offsets_,
-            &annotations_directory_item_parameter_annotation_offsets_))) {
-    return false;
-  }
-  CodeItemParser code_item_parser(image_);
-  if (!code_item_parser.Init(code_map_item_))
-    return false;
-  code_item_offsets_.resize(code_map_item_.size);
-  for (size_t i = 0; i < code_map_item_.size; ++i) {
-    const offset_t code_item_offset = code_item_parser.GetNext();
-    if (code_item_offset == kInvalidOffset)
-      return false;
-    code_item_offsets_[i] = code_item_offset;
-  }
-  // DEX files are required to have parsable code items.
-  return !code_item_offsets_.empty();
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/disassembler_elf.cc b/native/zucchini/vendor/zucchini/disassembler_elf.cc
deleted file mode 100644
index 22a29ba..0000000
--- a/native/zucchini/vendor/zucchini/disassembler_elf.cc
+++ /dev/null
@@ -1,758 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/disassembler_elf.h"
-
-#include <stddef.h>
-
-#include <utility>
-
-#include "base/logging.h"
-#include "base/numerics/checked_math.h"
-#include "base/numerics/safe_conversions.h"
-#include "components/zucchini/abs32_utils.h"
-#include "components/zucchini/algorithm.h"
-#include "components/zucchini/arm_utils.h"
-#include "components/zucchini/buffer_source.h"
-
-namespace zucchini {
-
-namespace {
-
-constexpr uint64_t kElfImageBase = 0;
-constexpr size_t kSizeBound = 0x7FFF0000;
-
-// Threshold value for heuristics to detect THUMB2 code.
-constexpr double kAArch32BitCondAlwaysDensityThreshold = 0.4;
-
-// Bit fields for JudgeSection() return value.
-enum SectionJudgement : int {
-  // Bit: Section does not invalidate ELF, but may or may not be useful.
-  SECTION_BIT_SAFE = 1 << 0,
-  // Bit: Section useful for AddressTranslator, to map between offsets and RVAs.
-  SECTION_BIT_USEFUL_FOR_ADDRESS_TRANSLATOR = 1 << 1,
-  // Bit: Section useful for |offset_bound|, to estimate ELF size.
-  SECTION_BIT_USEFUL_FOR_OFFSET_BOUND = 1 << 2,
-  // Bit: Section potentially useful for pointer extraction.
-  SECTION_BIT_MAYBE_USEFUL_FOR_POINTERS = 1 << 3,
-
-  // The following are verdicts from combining bits, to improve semantics.
-  // Default value: A section is malformed and invalidates ELF.
-  SECTION_IS_MALFORMED = 0,
-  // Section does not invalidate ELF, but is also not used for anything.
-  SECTION_IS_USELESS = SECTION_BIT_SAFE,
-};
-
-// Decides how a section affects ELF parsing, and returns a bit field composed
-// from SectionJudgement values.
-template <class TRAITS>
-int JudgeSection(size_t image_size, const typename TRAITS::Elf_Shdr* section) {
-  // BufferRegion uses |size_t| this can be 32-bit in some cases. For Elf64
-  // |sh_addr|, |sh_offset| and |sh_size| are 64-bit this can result in
-  // overflows in the subsequent validation steps.
-  if (!base::IsValueInRangeForNumericType<size_t>(section->sh_addr) ||
-      !base::IsValueInRangeForNumericType<size_t>(section->sh_offset) ||
-      !base::IsValueInRangeForNumericType<size_t>(section->sh_size)) {
-    return SECTION_IS_MALFORMED;
-  }
-
-  // Examine RVA range: Reject if numerical overflow may happen.
-  if (!BufferRegion{static_cast<size_t>(section->sh_addr),
-                    static_cast<size_t>(section->sh_size)}
-           .FitsIn(kSizeBound))
-    return SECTION_IS_MALFORMED;
-
-  // Examine offset range: If section takes up |image| data then be stricter.
-  size_t offset_bound =
-      (section->sh_type == elf::SHT_NOBITS) ? kSizeBound : image_size;
-  if (!BufferRegion{static_cast<size_t>(section->sh_offset),
-                    static_cast<size_t>(section->sh_size)}
-           .FitsIn(offset_bound))
-    return SECTION_IS_MALFORMED;
-
-  // Empty sections don't contribute to offset-RVA mapping. For consistency, it
-  // should also not affect |offset_bounds|.
-  if (section->sh_size == 0)
-    return SECTION_IS_USELESS;
-
-  // Sections with |sh_addr == 0| are ignored because these tend to duplicates
-  // (can cause problems for lookup) and uninteresting. For consistency, it
-  // should also not affect |offset_bounds|.
-  if (section->sh_addr == 0)
-    return SECTION_IS_USELESS;
-
-  if (section->sh_type == elf::SHT_NOBITS) {
-    // Special case for .tbss sections: These should be ignored because they may
-    // have offset-RVA map that don't match other sections.
-    if (section->sh_flags & elf::SHF_TLS)
-      return SECTION_IS_USELESS;
-
-    // Section is useful for offset-RVA translation, but does not affect
-    // |offset_bounds| since it can have large virtual size (e.g., .bss).
-    return SECTION_BIT_SAFE | SECTION_BIT_USEFUL_FOR_ADDRESS_TRANSLATOR;
-  }
-
-  return SECTION_BIT_SAFE | SECTION_BIT_USEFUL_FOR_ADDRESS_TRANSLATOR |
-         SECTION_BIT_USEFUL_FOR_OFFSET_BOUND |
-         SECTION_BIT_MAYBE_USEFUL_FOR_POINTERS;
-}
-
-// Determines whether |section| is a reloc section.
-template <class TRAITS>
-bool IsRelocSection(const typename TRAITS::Elf_Shdr& section) {
-  DCHECK_GT(section.sh_size, 0U);
-  if (section.sh_type == elf::SHT_REL) {
-    // Also validate |section.sh_entsize|, which gets used later.
-    return section.sh_entsize == sizeof(typename TRAITS::Elf_Rel);
-  }
-  if (section.sh_type == elf::SHT_RELA)
-    return section.sh_entsize == sizeof(typename TRAITS::Elf_Rela);
-  return false;
-}
-
-// Determines whether |section| is a section with executable code.
-template <class TRAITS>
-bool IsExecSection(const typename TRAITS::Elf_Shdr& section) {
-  DCHECK_GT(section.sh_size, 0U);
-  return section.sh_type == elf::SHT_PROGBITS &&
-         (section.sh_flags & elf::SHF_EXECINSTR) != 0;
-}
-
-}  // namespace
-
-/******** Elf32Traits ********/
-
-// static
-constexpr Bitness Elf32Traits::kBitness;
-constexpr elf::FileClass Elf32Traits::kIdentificationClass;
-
-/******** Elf32IntelTraits ********/
-
-// static
-constexpr ExecutableType Elf32IntelTraits::kExeType;
-const char Elf32IntelTraits::kExeTypeString[] = "ELF x86";
-constexpr elf::MachineArchitecture Elf32IntelTraits::kMachineValue;
-constexpr uint32_t Elf32IntelTraits::kRelType;
-
-/******** ElfAArch32Traits ********/
-
-// static
-constexpr ExecutableType ElfAArch32Traits::kExeType;
-const char ElfAArch32Traits::kExeTypeString[] = "ELF ARM";
-constexpr elf::MachineArchitecture ElfAArch32Traits::kMachineValue;
-constexpr uint32_t ElfAArch32Traits::kRelType;
-
-/******** Elf64Traits ********/
-
-// static
-constexpr Bitness Elf64Traits::kBitness;
-constexpr elf::FileClass Elf64Traits::kIdentificationClass;
-
-/******** Elf64IntelTraits ********/
-
-// static
-constexpr ExecutableType Elf64IntelTraits::kExeType;
-const char Elf64IntelTraits::kExeTypeString[] = "ELF x64";
-constexpr elf::MachineArchitecture Elf64IntelTraits::kMachineValue;
-constexpr uint32_t Elf64IntelTraits::kRelType;
-
-/******** ElfAArch64Traits ********/
-
-// static
-constexpr ExecutableType ElfAArch64Traits::kExeType;
-const char ElfAArch64Traits::kExeTypeString[] = "ELF ARM64";
-constexpr elf::MachineArchitecture ElfAArch64Traits::kMachineValue;
-constexpr uint32_t ElfAArch64Traits::kRelType;
-
-/******** DisassemblerElf ********/
-
-// static.
-template <class TRAITS>
-bool DisassemblerElf<TRAITS>::QuickDetect(ConstBufferView image) {
-  BufferSource source(image);
-
-  // Do not consume the bytes for the magic value, as they are part of the
-  // header.
-  if (!source.CheckNextBytes({0x7F, 'E', 'L', 'F'}))
-    return false;
-
-  auto* header = source.GetPointer<typename Traits::Elf_Ehdr>();
-  if (!header)
-    return false;
-
-  if (header->e_ident[elf::EI_CLASS] != Traits::kIdentificationClass)
-    return false;
-
-  if (header->e_ident[elf::EI_DATA] != 1)  // Only ELFDATA2LSB is supported.
-    return false;
-
-  if (header->e_type != elf::ET_EXEC && header->e_type != elf::ET_DYN)
-    return false;
-
-  if (header->e_version != 1 || header->e_ident[elf::EI_VERSION] != 1)
-    return false;
-
-  if (header->e_machine != supported_architecture())
-    return false;
-
-  if (header->e_shentsize != sizeof(typename Traits::Elf_Shdr))
-    return false;
-
-  return true;
-}
-
-template <class TRAITS>
-DisassemblerElf<TRAITS>::~DisassemblerElf() = default;
-
-template <class TRAITS>
-ExecutableType DisassemblerElf<TRAITS>::GetExeType() const {
-  return Traits::kExeType;
-}
-
-template <class TRAITS>
-std::string DisassemblerElf<TRAITS>::GetExeTypeString() const {
-  return Traits::kExeTypeString;
-}
-
-// |num_equivalence_iterations_| = 2 for reloc -> abs32.
-template <class TRAITS>
-DisassemblerElf<TRAITS>::DisassemblerElf() : Disassembler(2) {}
-
-template <class TRAITS>
-bool DisassemblerElf<TRAITS>::Parse(ConstBufferView image) {
-  image_ = image;
-  if (!ParseHeader())
-    return false;
-  ParseSections();
-  return true;
-}
-
-template <class TRAITS>
-std::unique_ptr<ReferenceReader> DisassemblerElf<TRAITS>::MakeReadRelocs(
-    offset_t lo,
-    offset_t hi) {
-  DCHECK_LE(lo, hi);
-  DCHECK_LE(hi, image_.size());
-
-  if (reloc_section_dims_.empty())
-    return std::make_unique<EmptyReferenceReader>();
-
-  return std::make_unique<RelocReaderElf>(
-      image_, Traits::kBitness, reloc_section_dims_,
-      supported_relocation_type(), lo, hi, translator_);
-}
-
-template <class TRAITS>
-std::unique_ptr<ReferenceWriter> DisassemblerElf<TRAITS>::MakeWriteRelocs(
-    MutableBufferView image) {
-  return std::make_unique<RelocWriterElf>(image, Traits::kBitness, translator_);
-}
-
-template <class TRAITS>
-bool DisassemblerElf<TRAITS>::ParseHeader() {
-  BufferSource source(image_);
-  // Ensure any offsets will fit within the |image_|'s bounds.
-  if (!base::IsValueInRangeForNumericType<offset_t>(image_.size()))
-    return false;
-
-  // Ensures |header_| is valid later on.
-  if (!QuickDetect(image_))
-    return false;
-
-  header_ = source.GetPointer<typename Traits::Elf_Ehdr>();
-
-  sections_count_ = header_->e_shnum;
-  source = std::move(BufferSource(image_).Skip(header_->e_shoff));
-  sections_ = source.GetArray<typename Traits::Elf_Shdr>(sections_count_);
-  if (!sections_)
-    return false;
-  offset_t section_table_end =
-      base::checked_cast<offset_t>(source.begin() - image_.begin());
-
-  segments_count_ = header_->e_phnum;
-  source = std::move(BufferSource(image_).Skip(header_->e_phoff));
-  segments_ = source.GetArray<typename Traits::Elf_Phdr>(segments_count_);
-  if (!segments_)
-    return false;
-  offset_t segment_table_end =
-      base::checked_cast<offset_t>(source.begin() - image_.begin());
-
-  // Check string section -- even though we've stopped using them.
-  elf::Elf32_Half string_section_id = header_->e_shstrndx;
-  if (string_section_id >= sections_count_)
-    return false;
-  size_t section_names_size = sections_[string_section_id].sh_size;
-  if (section_names_size > 0) {
-    // If nonempty, then last byte of string section must be null.
-    const char* section_names = nullptr;
-    source = std::move(
-        BufferSource(image_).Skip(sections_[string_section_id].sh_offset));
-    section_names = source.GetArray<char>(section_names_size);
-    if (!section_names || section_names[section_names_size - 1] != '\0')
-      return false;
-  }
-
-  // Establish bound on encountered offsets.
-  offset_t offset_bound = std::max(section_table_end, segment_table_end);
-
-  // Visits |segments_| to get estimate on |offset_bound|.
-  for (const typename Traits::Elf_Phdr* segment = segments_;
-       segment != segments_ + segments_count_; ++segment) {
-    // |image_.covers()| is a sufficient check except when size_t is 32 bit and
-    // parsing ELF64. In such cases a value-in-range check is needed on the
-    // segment. This fixes crbug/1035603.
-    offset_t segment_end;
-    base::CheckedNumeric<offset_t> checked_segment_end = segment->p_offset;
-    checked_segment_end += segment->p_filesz;
-    if (!checked_segment_end.AssignIfValid(&segment_end) ||
-        !image_.covers({static_cast<size_t>(segment->p_offset),
-                        static_cast<size_t>(segment->p_filesz)})) {
-      return false;
-    }
-    offset_bound = std::max(offset_bound, segment_end);
-  }
-
-  // Visit and validate each section; add address translation data to |units|.
-  std::vector<AddressTranslator::Unit> units;
-  units.reserve(sections_count_);
-  section_judgements_.reserve(sections_count_);
-
-  for (int i = 0; i < sections_count_; ++i) {
-    const typename Traits::Elf_Shdr* section = &sections_[i];
-    int judgement = JudgeSection<Traits>(image_.size(), section);
-    section_judgements_.push_back(judgement);
-    if ((judgement & SECTION_BIT_SAFE) == 0)
-      return false;
-
-    uint32_t sh_size = base::checked_cast<uint32_t>(section->sh_size);
-    offset_t sh_offset = base::checked_cast<offset_t>(section->sh_offset);
-    rva_t sh_addr = base::checked_cast<rva_t>(section->sh_addr);
-    if ((judgement & SECTION_BIT_USEFUL_FOR_ADDRESS_TRANSLATOR) != 0) {
-      // Store mappings between RVA and offset.
-      units.push_back({sh_offset, sh_size, sh_addr, sh_size});
-    }
-    if ((judgement & SECTION_BIT_USEFUL_FOR_OFFSET_BOUND) != 0) {
-      offset_t section_end = base::checked_cast<offset_t>(sh_offset + sh_size);
-      offset_bound = std::max(offset_bound, section_end);
-    }
-  }
-
-  // Initialize |translator_| for offset-RVA translations. Any inconsistency
-  // (e.g., 2 offsets correspond to the same RVA) would invalidate the ELF file.
-  if (translator_.Initialize(std::move(units)) != AddressTranslator::kSuccess)
-    return false;
-
-  DCHECK_LE(offset_bound, image_.size());
-  image_.shrink(offset_bound);
-  return true;
-}
-
-template <class TRAITS>
-void DisassemblerElf<TRAITS>::ExtractInterestingSectionHeaders() {
-  DCHECK(reloc_section_dims_.empty());
-  DCHECK(exec_headers_.empty());
-  for (elf::Elf32_Half i = 0; i < sections_count_; ++i) {
-    const typename Traits::Elf_Shdr* section = sections_ + i;
-    if ((section_judgements_[i] & SECTION_BIT_MAYBE_USEFUL_FOR_POINTERS) != 0) {
-      if (IsRelocSection<Traits>(*section))
-        reloc_section_dims_.emplace_back(*section);
-      else if (IsExecSection<Traits>(*section))
-        exec_headers_.push_back(section);
-    }
-  }
-  auto comp = [](const typename Traits::Elf_Shdr* a,
-                 const typename Traits::Elf_Shdr* b) {
-    return a->sh_offset < b->sh_offset;
-  };
-  std::sort(reloc_section_dims_.begin(), reloc_section_dims_.end());
-  std::sort(exec_headers_.begin(), exec_headers_.end(), comp);
-}
-
-template <class TRAITS>
-void DisassemblerElf<TRAITS>::GetAbs32FromRelocSections() {
-  constexpr int kAbs32Width = Traits::kVAWidth;
-  DCHECK(abs32_locations_.empty());
-
-  // Read reloc targets to get preliminary abs32 locations.
-  std::unique_ptr<ReferenceReader> relocs = MakeReadRelocs(0, offset_t(size()));
-  for (auto ref = relocs->GetNext(); ref.has_value(); ref = relocs->GetNext())
-    abs32_locations_.push_back(ref->target);
-
-  std::sort(abs32_locations_.begin(), abs32_locations_.end());
-
-  // Abs32 references must have targets translatable to offsets. Remove those
-  // that are unable to do so.
-  size_t num_untranslatable =
-      RemoveUntranslatableAbs32(image_, {Traits::kBitness, kElfImageBase},
-                                translator_, &abs32_locations_);
-  LOG_IF(WARNING, num_untranslatable) << "Removed " << num_untranslatable
-                                      << " untranslatable abs32 references.";
-
-  // Abs32 reference bodies must not overlap. If found, simply remove them.
-  size_t num_overlapping =
-      RemoveOverlappingAbs32Locations(kAbs32Width, &abs32_locations_);
-  LOG_IF(WARNING, num_overlapping)
-      << "Removed " << num_overlapping
-      << " abs32 references with overlapping bodies.";
-
-  abs32_locations_.shrink_to_fit();
-}
-
-template <class TRAITS>
-void DisassemblerElf<TRAITS>::GetRel32FromCodeSections() {
-  for (const typename Traits::Elf_Shdr* section : exec_headers_)
-    ParseExecSection(*section);
-  PostProcessRel32();
-}
-
-template <class TRAITS>
-void DisassemblerElf<TRAITS>::ParseSections() {
-  ExtractInterestingSectionHeaders();
-  GetAbs32FromRelocSections();
-  GetRel32FromCodeSections();
-}
-
-/******** DisassemblerElfIntel ********/
-
-template <class TRAITS>
-DisassemblerElfIntel<TRAITS>::DisassemblerElfIntel() = default;
-
-template <class TRAITS>
-DisassemblerElfIntel<TRAITS>::~DisassemblerElfIntel() = default;
-
-template <class TRAITS>
-std::vector<ReferenceGroup> DisassemblerElfIntel<TRAITS>::MakeReferenceGroups()
-    const {
-  return {
-      {ReferenceTypeTraits{sizeof(TRAITS::Elf_Rel::r_offset), TypeTag(kReloc),
-                           PoolTag(kReloc)},
-       &DisassemblerElfIntel<TRAITS>::MakeReadRelocs,
-       &DisassemblerElfIntel<TRAITS>::MakeWriteRelocs},
-      {ReferenceTypeTraits{Traits::kVAWidth, TypeTag(kAbs32), PoolTag(kAbs32)},
-       &DisassemblerElfIntel<TRAITS>::MakeReadAbs32,
-       &DisassemblerElfIntel<TRAITS>::MakeWriteAbs32},
-      // N.B.: Rel32 |width| is 4 bytes, even for x64.
-      {ReferenceTypeTraits{4, TypeTag(kRel32), PoolTag(kRel32)},
-       &DisassemblerElfIntel<TRAITS>::MakeReadRel32,
-       &DisassemblerElfIntel<TRAITS>::MakeWriteRel32}};
-}
-
-template <class TRAITS>
-void DisassemblerElfIntel<TRAITS>::ParseExecSection(
-    const typename TRAITS::Elf_Shdr& section) {
-  constexpr int kAbs32Width = Traits::kVAWidth;
-
-  // |this->| is needed to access protected members of templated base class. To
-  // reduce noise, use local references for these.
-  ConstBufferView& image_ = this->image_;
-  const AddressTranslator& translator_ = this->translator_;
-  auto& abs32_locations_ = this->abs32_locations_;
-
-  // Range of values was ensured in ParseHeader().
-  rva_t start_rva = base::checked_cast<rva_t>(section.sh_addr);
-  rva_t end_rva = base::checked_cast<rva_t>(start_rva + section.sh_size);
-
-  AddressTranslator::RvaToOffsetCache target_rva_checker(translator_);
-
-  ConstBufferView region(image_.begin() + section.sh_offset, section.sh_size);
-  Abs32GapFinder gap_finder(image_, region, abs32_locations_, kAbs32Width);
-  typename TRAITS::Rel32FinderUse rel_finder(image_, translator_);
-  // Iterate over gaps between abs32 references, to avoid collision.
-  while (gap_finder.FindNext()) {
-    rel_finder.SetRegion(gap_finder.GetGap());
-    while (rel_finder.FindNext()) {
-      auto rel32 = rel_finder.GetRel32();
-      if (target_rva_checker.IsValid(rel32.target_rva) &&
-          (rel32.can_point_outside_section ||
-           (start_rva <= rel32.target_rva && rel32.target_rva < end_rva))) {
-        rel_finder.Accept();
-        rel32_locations_.push_back(rel32.location);
-      }
-    }
-  }
-}
-
-template <class TRAITS>
-void DisassemblerElfIntel<TRAITS>::PostProcessRel32() {
-  rel32_locations_.shrink_to_fit();
-  std::sort(rel32_locations_.begin(), rel32_locations_.end());
-}
-
-template <class TRAITS>
-std::unique_ptr<ReferenceReader> DisassemblerElfIntel<TRAITS>::MakeReadAbs32(
-    offset_t lo,
-    offset_t hi) {
-  // TODO(huangs): Don't use Abs32RvaExtractorWin32 here; use new class that
-  // caters to different ELF architectures.
-  Abs32RvaExtractorWin32 abs_rva_extractor(
-      this->image_, AbsoluteAddress(TRAITS::kBitness, kElfImageBase),
-      this->abs32_locations_, lo, hi);
-  return std::make_unique<Abs32ReaderWin32>(std::move(abs_rva_extractor),
-                                            this->translator_);
-}
-
-template <class TRAITS>
-std::unique_ptr<ReferenceWriter> DisassemblerElfIntel<TRAITS>::MakeWriteAbs32(
-    MutableBufferView image) {
-  return std::make_unique<Abs32WriterWin32>(
-      image, AbsoluteAddress(TRAITS::kBitness, kElfImageBase),
-      this->translator_);
-}
-
-template <class TRAITS>
-std::unique_ptr<ReferenceReader> DisassemblerElfIntel<TRAITS>::MakeReadRel32(
-    offset_t lo,
-    offset_t hi) {
-  return std::make_unique<Rel32ReaderX86>(this->image_, lo, hi,
-                                          &rel32_locations_, this->translator_);
-}
-
-template <class TRAITS>
-std::unique_ptr<ReferenceWriter> DisassemblerElfIntel<TRAITS>::MakeWriteRel32(
-    MutableBufferView image) {
-  return std::make_unique<Rel32WriterX86>(image, this->translator_);
-}
-
-// Explicit instantiation for supported classes.
-template class DisassemblerElfIntel<Elf32IntelTraits>;
-template class DisassemblerElfIntel<Elf64IntelTraits>;
-template bool DisassemblerElf<Elf32IntelTraits>::QuickDetect(
-    ConstBufferView image);
-template bool DisassemblerElf<Elf64IntelTraits>::QuickDetect(
-    ConstBufferView image);
-
-/******** DisassemblerElfArm ********/
-
-template <class Traits>
-DisassemblerElfArm<Traits>::DisassemblerElfArm() = default;
-
-template <class Traits>
-DisassemblerElfArm<Traits>::~DisassemblerElfArm() = default;
-
-template <class Traits>
-bool DisassemblerElfArm<Traits>::IsTargetOffsetInExecSection(
-    offset_t offset) const {
-  // Executable sections can appear in large numbers in .o files and in
-  // pathological cases. Since this function may be called for each reference
-  // candidate, linear search may be too slow (so use binary search).
-  return IsTargetOffsetInElfSectionList(this->exec_headers_, offset);
-}
-
-template <class Traits>
-void DisassemblerElfArm<Traits>::ParseExecSection(
-    const typename Traits::Elf_Shdr& section) {
-  ConstBufferView& image_ = this->image_;
-  const AddressTranslator& translator_ = this->translator_;
-  auto& abs32_locations_ = this->abs32_locations_;
-
-  ConstBufferView region(image_.begin() + section.sh_offset, section.sh_size);
-  Abs32GapFinder gap_finder(image_, region, abs32_locations_, Traits::kVAWidth);
-  std::unique_ptr<typename Traits::Rel32FinderUse> rel_finder =
-      MakeRel32Finder(section);
-  AddressTranslator::RvaToOffsetCache rva_to_offset(translator_);
-  while (gap_finder.FindNext()) {
-    rel_finder->SetRegion(gap_finder.GetGap());
-    while (rel_finder->FindNext()) {
-      auto rel32 = rel_finder->GetRel32();
-      offset_t target_offset = rva_to_offset.Convert(rel32.target_rva);
-      if (target_offset != kInvalidOffset) {
-        // For robustness, reject illegal offsets, which can arise from, e.g.,
-        // misidentify ARM vs. THUMB2 mode, or even misidentifying data as code!
-        if (IsTargetOffsetInExecSection(target_offset)) {
-          rel_finder->Accept();
-          rel32_locations_table_[rel32.type].push_back(rel32.location);
-        }
-      }
-    }
-  }
-}
-
-template <class Traits>
-void DisassemblerElfArm<Traits>::PostProcessRel32() {
-  for (int type = 0; type < AArch32Rel32Translator::NUM_ADDR_TYPE; ++type) {
-    std::sort(rel32_locations_table_[type].begin(),
-              rel32_locations_table_[type].end());
-    rel32_locations_table_[type].shrink_to_fit();
-  }
-}
-
-template <class Traits>
-std::unique_ptr<ReferenceReader> DisassemblerElfArm<Traits>::MakeReadAbs32(
-    offset_t lo,
-    offset_t hi) {
-  // TODO(huangs): Reconcile the use of Win32-specific classes in ARM code!
-  Abs32RvaExtractorWin32 abs_rva_extractor(this->image_,
-                                           AbsoluteAddress(Traits::kBitness, 0),
-                                           this->abs32_locations_, lo, hi);
-  return std::make_unique<Abs32ReaderWin32>(std::move(abs_rva_extractor),
-                                            this->translator_);
-}
-
-template <class Traits>
-std::unique_ptr<ReferenceWriter> DisassemblerElfArm<Traits>::MakeWriteAbs32(
-    MutableBufferView image) {
-  return std::make_unique<Abs32WriterWin32>(
-      image, AbsoluteAddress(Traits::kBitness, 0), this->translator_);
-}
-
-template <class TRAITS>
-template <class ADDR_TRAITS>
-std::unique_ptr<ReferenceReader> DisassemblerElfArm<TRAITS>::MakeReadRel32(
-    offset_t lower,
-    offset_t upper) {
-  return std::make_unique<Rel32ReaderArm<ADDR_TRAITS>>(
-      this->translator_, this->image_,
-      this->rel32_locations_table_[ADDR_TRAITS::addr_type], lower, upper);
-}
-
-template <class TRAITS>
-template <class ADDR_TRAITS>
-std::unique_ptr<ReferenceWriter> DisassemblerElfArm<TRAITS>::MakeWriteRel32(
-    MutableBufferView image) {
-  return std::make_unique<Rel32WriterArm<ADDR_TRAITS>>(this->translator_,
-                                                       image);
-}
-
-/******** DisassemblerElfAArch32 ********/
-
-DisassemblerElfAArch32::DisassemblerElfAArch32() = default;
-DisassemblerElfAArch32::~DisassemblerElfAArch32() = default;
-
-std::vector<ReferenceGroup> DisassemblerElfAArch32::MakeReferenceGroups()
-    const {
-  return {
-      {ReferenceTypeTraits{sizeof(Traits::Elf_Rel::r_offset),
-                           TypeTag(AArch32ReferenceType::kReloc),
-                           PoolTag(ArmReferencePool::kPoolReloc)},
-       &DisassemblerElfAArch32::MakeReadRelocs,
-       &DisassemblerElfAArch32::MakeWriteRelocs},
-      {ReferenceTypeTraits{Traits::kVAWidth,
-                           TypeTag(AArch32ReferenceType::kAbs32),
-                           PoolTag(ArmReferencePool::kPoolAbs32)},
-       &DisassemblerElfAArch32::MakeReadAbs32,
-       &DisassemblerElfAArch32::MakeWriteAbs32},
-      {ReferenceTypeTraits{4, TypeTag(AArch32ReferenceType::kRel32_A24),
-                           PoolTag(ArmReferencePool::kPoolRel32)},
-       &DisassemblerElfAArch32::MakeReadRel32<
-           AArch32Rel32Translator::AddrTraits_A24>,
-       &DisassemblerElfAArch32::MakeWriteRel32<
-           AArch32Rel32Translator::AddrTraits_A24>},
-      {ReferenceTypeTraits{2, TypeTag(AArch32ReferenceType::kRel32_T8),
-                           PoolTag(ArmReferencePool::kPoolRel32)},
-       &DisassemblerElfAArch32::MakeReadRel32<
-           AArch32Rel32Translator::AddrTraits_T8>,
-       &DisassemblerElfAArch32::MakeWriteRel32<
-           AArch32Rel32Translator::AddrTraits_T8>},
-      {ReferenceTypeTraits{2, TypeTag(AArch32ReferenceType::kRel32_T11),
-                           PoolTag(ArmReferencePool::kPoolRel32)},
-       &DisassemblerElfAArch32::MakeReadRel32<
-           AArch32Rel32Translator::AddrTraits_T11>,
-       &DisassemblerElfAArch32::MakeWriteRel32<
-           AArch32Rel32Translator::AddrTraits_T11>},
-      {ReferenceTypeTraits{4, TypeTag(AArch32ReferenceType::kRel32_T20),
-                           PoolTag(ArmReferencePool::kPoolRel32)},
-       &DisassemblerElfAArch32::MakeReadRel32<
-           AArch32Rel32Translator::AddrTraits_T20>,
-       &DisassemblerElfAArch32::MakeWriteRel32<
-           AArch32Rel32Translator::AddrTraits_T20>},
-      {ReferenceTypeTraits{4, TypeTag(AArch32ReferenceType::kRel32_T24),
-                           PoolTag(ArmReferencePool::kPoolRel32)},
-       &DisassemblerElfAArch32::MakeReadRel32<
-           AArch32Rel32Translator::AddrTraits_T24>,
-       &DisassemblerElfAArch32::MakeWriteRel32<
-           AArch32Rel32Translator::AddrTraits_T24>},
-  };
-}
-
-std::unique_ptr<DisassemblerElfAArch32::Traits::Rel32FinderUse>
-DisassemblerElfAArch32::MakeRel32Finder(
-    const typename Traits::Elf_Shdr& section) {
-  return std::make_unique<Rel32FinderAArch32>(image_, translator_,
-                                              IsExecSectionThumb2(section));
-}
-
-bool DisassemblerElfAArch32::IsExecSectionThumb2(
-    const typename Traits::Elf_Shdr& section) const {
-  // ARM mode requires 4-byte alignment.
-  if (section.sh_addr % 4 != 0 || section.sh_size % 4 != 0)
-    return true;
-  const uint8_t* first = image_.begin() + section.sh_offset;
-  const uint8_t* end = first + section.sh_size;
-  // Each instruction in 32-bit ARM (little-endian) looks like
-  //   ?? ?? ?? X?,
-  // where X specifies conditional execution. X = 0xE represents AL = "ALways
-  // execute", and tends to appear very often. We use this as our main indicator
-  // to discern 32-bit ARM mode from THUMB2 mode.
-  size_t num = 0;
-  size_t den = 0;
-  for (const uint8_t* cur = first; cur < end; cur += 4) {
-    // |cur[3]| is within bounds because |end - cur| is a multiple of 4.
-    uint8_t maybe_cond = cur[3] & 0xF0;
-    if (maybe_cond == 0xE0)
-      ++num;
-    ++den;
-  }
-
-  if (den > 0) {
-    LOG(INFO) << "Section scan: " << num << " / " << den << " => "
-              << base::StringPrintf("%.2f", num * 100.0 / den) << "%";
-  }
-  return num < den * kAArch32BitCondAlwaysDensityThreshold;
-}
-
-/******** DisassemblerElfAArch64 ********/
-
-DisassemblerElfAArch64::DisassemblerElfAArch64() = default;
-
-DisassemblerElfAArch64::~DisassemblerElfAArch64() = default;
-
-std::vector<ReferenceGroup> DisassemblerElfAArch64::MakeReferenceGroups()
-    const {
-  return {
-      {ReferenceTypeTraits{sizeof(Traits::Elf_Rel::r_offset),
-                           TypeTag(AArch64ReferenceType::kReloc),
-                           PoolTag(ArmReferencePool::kPoolReloc)},
-       &DisassemblerElfAArch64::MakeReadRelocs,
-       &DisassemblerElfAArch64::MakeWriteRelocs},
-      {ReferenceTypeTraits{Traits::kVAWidth,
-                           TypeTag(AArch64ReferenceType::kAbs32),
-                           PoolTag(ArmReferencePool::kPoolAbs32)},
-       &DisassemblerElfAArch64::MakeReadAbs32,
-       &DisassemblerElfAArch64::MakeWriteAbs32},
-      {ReferenceTypeTraits{4, TypeTag(AArch64ReferenceType::kRel32_Immd14),
-                           PoolTag(ArmReferencePool::kPoolRel32)},
-       &DisassemblerElfAArch64::MakeReadRel32<
-           AArch64Rel32Translator::AddrTraits_Immd14>,
-       &DisassemblerElfAArch64::MakeWriteRel32<
-           AArch64Rel32Translator::AddrTraits_Immd14>},
-      {ReferenceTypeTraits{4, TypeTag(AArch64ReferenceType::kRel32_Immd19),
-                           PoolTag(ArmReferencePool::kPoolRel32)},
-       &DisassemblerElfAArch64::MakeReadRel32<
-           AArch64Rel32Translator::AddrTraits_Immd19>,
-       &DisassemblerElfAArch64::MakeWriteRel32<
-           AArch64Rel32Translator::AddrTraits_Immd19>},
-      {ReferenceTypeTraits{4, TypeTag(AArch64ReferenceType::kRel32_Immd26),
-                           PoolTag(ArmReferencePool::kPoolRel32)},
-       &DisassemblerElfAArch64::MakeReadRel32<
-           AArch64Rel32Translator::AddrTraits_Immd26>,
-       &DisassemblerElfAArch64::MakeWriteRel32<
-           AArch64Rel32Translator::AddrTraits_Immd26>},
-  };
-}
-
-std::unique_ptr<DisassemblerElfAArch64::Traits::Rel32FinderUse>
-DisassemblerElfAArch64::MakeRel32Finder(
-    const typename Traits::Elf_Shdr& section) {
-  return std::make_unique<Rel32FinderAArch64>(image_, translator_);
-}
-
-// Explicit instantiation for supported classes.
-template class DisassemblerElfArm<ElfAArch32Traits>;
-template class DisassemblerElfArm<ElfAArch64Traits>;
-template bool DisassemblerElf<ElfAArch32Traits>::QuickDetect(
-    ConstBufferView image);
-template bool DisassemblerElf<ElfAArch64Traits>::QuickDetect(
-    ConstBufferView image);
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/disassembler_no_op.cc b/native/zucchini/vendor/zucchini/disassembler_no_op.cc
deleted file mode 100644
index b17979c..0000000
--- a/native/zucchini/vendor/zucchini/disassembler_no_op.cc
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/disassembler_no_op.h"
-
-namespace zucchini {
-
-// |num_equivalence_iterations_| = 1 since no pointers are present.
-DisassemblerNoOp::DisassemblerNoOp() : Disassembler(1) {}
-
-DisassemblerNoOp::~DisassemblerNoOp() = default;
-
-ExecutableType DisassemblerNoOp::GetExeType() const {
-  return kExeTypeNoOp;
-}
-
-std::string DisassemblerNoOp::GetExeTypeString() const {
-  return "(Unknown)";
-}
-
-std::vector<ReferenceGroup> DisassemblerNoOp::MakeReferenceGroups() const {
-  return std::vector<ReferenceGroup>();
-}
-
-bool DisassemblerNoOp::Parse(ConstBufferView image) {
-  image_ = image;
-  return true;
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/element_detection.cc b/native/zucchini/vendor/zucchini/element_detection.cc
deleted file mode 100644
index 4d4a1c6..0000000
--- a/native/zucchini/vendor/zucchini/element_detection.cc
+++ /dev/null
@@ -1,200 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/element_detection.h"
-
-#include <utility>
-
-#include "components/zucchini/buildflags.h"
-#include "components/zucchini/disassembler.h"
-#include "components/zucchini/disassembler_no_op.h"
-#include "components/zucchini/version_info.h"
-
-#if BUILDFLAG(ENABLE_DEX)
-#include "components/zucchini/disassembler_dex.h"
-#endif  // BUILDFLAG(ENABLE_DEX)
-
-#if BUILDFLAG(ENABLE_ELF)
-#include "components/zucchini/disassembler_elf.h"
-#endif  // BUILDFLAG(ENABLE_ELF)
-
-#if BUILDFLAG(ENABLE_WIN)
-#include "components/zucchini/disassembler_win32.h"
-#endif  // BUILDFLAG(ENABLE_WIN)
-
-#if BUILDFLAG(ENABLE_ZTF)
-#include "components/zucchini/disassembler_ztf.h"
-#endif  // BUILDFLAG(ENABLE_ZTF)
-
-namespace zucchini {
-
-namespace {
-
-// Impose a minimal program size to eliminate pathological cases.
-enum : size_t { kMinProgramSize = 16 };
-
-}  // namespace
-
-/******** Utility Functions ********/
-
-std::unique_ptr<Disassembler> MakeDisassemblerWithoutFallback(
-    ConstBufferView image) {
-#if BUILDFLAG(ENABLE_WIN)
-  if (DisassemblerWin32X86::QuickDetect(image)) {
-    auto disasm = Disassembler::Make<DisassemblerWin32X86>(image);
-    if (disasm && disasm->size() >= kMinProgramSize)
-      return disasm;
-  }
-
-  if (DisassemblerWin32X64::QuickDetect(image)) {
-    auto disasm = Disassembler::Make<DisassemblerWin32X64>(image);
-    if (disasm && disasm->size() >= kMinProgramSize)
-      return disasm;
-  }
-#endif  // BUILDFLAG(ENABLE_WIN)
-
-#if BUILDFLAG(ENABLE_ELF)
-  if (DisassemblerElfX86::QuickDetect(image)) {
-    auto disasm = Disassembler::Make<DisassemblerElfX86>(image);
-    if (disasm && disasm->size() >= kMinProgramSize)
-      return disasm;
-  }
-
-  if (DisassemblerElfX64::QuickDetect(image)) {
-    auto disasm = Disassembler::Make<DisassemblerElfX64>(image);
-    if (disasm && disasm->size() >= kMinProgramSize)
-      return disasm;
-  }
-
-  if (DisassemblerElfAArch32::QuickDetect(image)) {
-    auto disasm = Disassembler::Make<DisassemblerElfAArch32>(image);
-    if (disasm && disasm->size() >= kMinProgramSize)
-      return disasm;
-  }
-
-  if (DisassemblerElfAArch64::QuickDetect(image)) {
-    auto disasm = Disassembler::Make<DisassemblerElfAArch64>(image);
-    if (disasm && disasm->size() >= kMinProgramSize)
-      return disasm;
-  }
-#endif  // BUILDFLAG(ENABLE_ELF)
-
-#if BUILDFLAG(ENABLE_DEX)
-  if (DisassemblerDex::QuickDetect(image)) {
-    auto disasm = Disassembler::Make<DisassemblerDex>(image);
-    if (disasm && disasm->size() >= kMinProgramSize)
-      return disasm;
-  }
-#endif  // BUILDFLAG(ENABLE_DEX)
-
-#if BUILDFLAG(ENABLE_ZTF)
-  if (DisassemblerZtf::QuickDetect(image)) {
-    // This disallows very short examples like "ZTxtxtZ\n" in ensemble patching.
-    auto disasm = Disassembler::Make<DisassemblerZtf>(image);
-    if (disasm && disasm->size() >= kMinProgramSize)
-      return disasm;
-  }
-#endif  // BUILDFLAG(ENABLE_ZTF)
-
-  return nullptr;
-}
-
-std::unique_ptr<Disassembler> MakeDisassemblerOfType(ConstBufferView image,
-                                                     ExecutableType exe_type) {
-  switch (exe_type) {
-#if BUILDFLAG(ENABLE_WIN)
-    case kExeTypeWin32X86:
-      return Disassembler::Make<DisassemblerWin32X86>(image);
-    case kExeTypeWin32X64:
-      return Disassembler::Make<DisassemblerWin32X64>(image);
-#endif  // BUILDFLAG(ENABLE_WIN)
-#if BUILDFLAG(ENABLE_ELF)
-    case kExeTypeElfX86:
-      return Disassembler::Make<DisassemblerElfX86>(image);
-    case kExeTypeElfX64:
-      return Disassembler::Make<DisassemblerElfX64>(image);
-    case kExeTypeElfAArch32:
-      return Disassembler::Make<DisassemblerElfAArch32>(image);
-    case kExeTypeElfAArch64:
-      return Disassembler::Make<DisassemblerElfAArch64>(image);
-#endif  // BUILDFLAG(ENABLE_ELF)
-#if BUILDFLAG(ENABLE_DEX)
-    case kExeTypeDex:
-      return Disassembler::Make<DisassemblerDex>(image);
-#endif  // BUILDFLAG(ENABLE_DEX)
-#if BUILDFLAG(ENABLE_ZTF)
-    case kExeTypeZtf:
-      return Disassembler::Make<DisassemblerZtf>(image);
-#endif  // BUILDFLAG(ENABLE_ZTF)
-    case kExeTypeNoOp:
-      return Disassembler::Make<DisassemblerNoOp>(image);
-    default:
-      // If an architecture is disabled then null is handled gracefully.
-      return nullptr;
-  }
-}
-
-uint16_t DisassemblerVersionOfType(ExecutableType exe_type) {
-  switch (exe_type) {
-#if BUILDFLAG(ENABLE_WIN)
-    case kExeTypeWin32X86:
-      return DisassemblerWin32X86::kVersion;
-    case kExeTypeWin32X64:
-      return DisassemblerWin32X64::kVersion;
-#endif  // BUILDFLAG(ENABLE_WIN)
-#if BUILDFLAG(ENABLE_ELF)
-    case kExeTypeElfX86:
-      return DisassemblerElfX86::kVersion;
-    case kExeTypeElfX64:
-      return DisassemblerElfX64::kVersion;
-    case kExeTypeElfAArch32:
-      return DisassemblerElfAArch32::kVersion;
-    case kExeTypeElfAArch64:
-      return DisassemblerElfAArch64::kVersion;
-#endif  // BUILDFLAG(ENABLE_ELF)
-#if BUILDFLAG(ENABLE_DEX)
-    case kExeTypeDex:
-      return DisassemblerDex::kVersion;
-#endif  // BUILDFLAG(ENABLE_DEX)
-#if BUILDFLAG(ENABLE_ZTF)
-    case kExeTypeZtf:
-      return DisassemblerZtf::kVersion;
-#endif  // BUILDFLAG(ENABLE_ZTF)
-    case kExeTypeNoOp:
-      return DisassemblerNoOp::kVersion;
-    default:
-      // If an architecture is disabled then null is handled gracefully.
-      return kInvalidVersion;
-  }
-}
-
-std::optional<Element> DetectElementFromDisassembler(ConstBufferView image) {
-  std::unique_ptr<Disassembler> disasm = MakeDisassemblerWithoutFallback(image);
-  if (disasm)
-    return Element({0, disasm->size()}, disasm->GetExeType());
-  return std::nullopt;
-}
-
-/******** ProgramScanner ********/
-
-ElementFinder::ElementFinder(ConstBufferView image, ElementDetector&& detector)
-    : image_(image), detector_(std::move(detector)) {}
-
-ElementFinder::~ElementFinder() = default;
-
-std::optional<Element> ElementFinder::GetNext() {
-  for (; pos_ < image_.size(); ++pos_) {
-    ConstBufferView test_image =
-        ConstBufferView::FromRange(image_.begin() + pos_, image_.end());
-    std::optional<Element> element = detector_.Run(test_image);
-    if (element) {
-      element->offset += pos_;
-      pos_ = element->EndOffset();
-      return element;
-    }
-  }
-  return std::nullopt;
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/equivalence_map.cc b/native/zucchini/vendor/zucchini/equivalence_map.cc
deleted file mode 100644
index b4d5e27..0000000
--- a/native/zucchini/vendor/zucchini/equivalence_map.cc
+++ /dev/null
@@ -1,549 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/equivalence_map.h"
-
-#include <algorithm>
-#include <utility>
-
-#include "base/containers/cxx20_erase.h"
-#include "base/logging.h"
-#include "base/numerics/safe_conversions.h"
-#include "components/zucchini/encoded_view.h"
-#include "components/zucchini/patch_reader.h"
-#include "components/zucchini/suffix_array.h"
-
-namespace zucchini {
-
-namespace {
-
-// TODO(haungs): Tune these numbers to improve pathological case results.
-
-// In pathological cases Zucchini can exhibit O(n^2) behavior if the seed
-// selection process runs to completion. To prevent this we impose a quota for
-// the total length of equivalences the seed selection process can perform
-// trials on. For regular use cases it is unlikely this quota will be exceeded,
-// and if it is the effects on patch size are expected to be small.
-constexpr uint64_t kSeedSelectionTotalVisitLengthQuota = 1 << 18;  // 256 KiB
-
-// The aforementioned quota alone is insufficient, as exploring backwards will
-// still be very successful resulting in O(n) behavior in the case of a limited
-// seed selection trials. This results in O(n^2) behavior returning. To mitigate
-// this we also impose a cap on the ExtendEquivalenceBackward() exploration.
-constexpr offset_t kBackwardsExtendLimit = 1 << 16;  // 64 KiB
-
-}  // namespace
-
-/******** Utility Functions ********/
-
-double GetTokenSimilarity(
-    const ImageIndex& old_image_index,
-    const ImageIndex& new_image_index,
-    const std::vector<TargetsAffinity>& targets_affinities,
-    offset_t src,
-    offset_t dst) {
-  DCHECK(old_image_index.IsToken(src));
-  DCHECK(new_image_index.IsToken(dst));
-
-  TypeTag old_type = old_image_index.LookupType(src);
-  TypeTag new_type = new_image_index.LookupType(dst);
-  if (old_type != new_type)
-    return kMismatchFatal;
-
-  // Raw comparison.
-  if (!old_image_index.IsReference(src) && !new_image_index.IsReference(dst)) {
-    return old_image_index.GetRawValue(src) == new_image_index.GetRawValue(dst)
-               ? 1.0
-               : -1.5;
-  }
-
-  const ReferenceSet& old_ref_set = old_image_index.refs(old_type);
-  const ReferenceSet& new_ref_set = new_image_index.refs(new_type);
-  Reference old_reference = old_ref_set.at(src);
-  Reference new_reference = new_ref_set.at(dst);
-  PoolTag pool_tag = old_ref_set.pool_tag();
-
-  double affinity = targets_affinities[pool_tag.value()].AffinityBetween(
-      old_ref_set.target_pool().KeyForOffset(old_reference.target),
-      new_ref_set.target_pool().KeyForOffset(new_reference.target));
-
-  // Both targets are not associated, which implies a weak match.
-  if (affinity == 0.0)
-    return 0.5 * old_ref_set.width();
-
-  // At least one target is associated, so values are compared.
-  return affinity > 0.0 ? old_ref_set.width() : -2.0;
-}
-
-double GetEquivalenceSimilarity(
-    const ImageIndex& old_image_index,
-    const ImageIndex& new_image_index,
-    const std::vector<TargetsAffinity>& targets_affinities,
-    const Equivalence& equivalence) {
-  double similarity = 0.0;
-  for (offset_t k = 0; k < equivalence.length; ++k) {
-    // Non-tokens are joined with the nearest previous token: skip until we
-    // cover the unit.
-    if (!new_image_index.IsToken(equivalence.dst_offset + k))
-      continue;
-
-    similarity += GetTokenSimilarity(
-        old_image_index, new_image_index, targets_affinities,
-        equivalence.src_offset + k, equivalence.dst_offset + k);
-    if (similarity == kMismatchFatal)
-      return kMismatchFatal;
-  }
-  return similarity;
-}
-
-EquivalenceCandidate ExtendEquivalenceForward(
-    const ImageIndex& old_image_index,
-    const ImageIndex& new_image_index,
-    const std::vector<TargetsAffinity>& targets_affinities,
-    const EquivalenceCandidate& candidate,
-    double min_similarity) {
-  Equivalence equivalence = candidate.eq;
-  offset_t best_k = equivalence.length;
-  double current_similarity = candidate.similarity;
-  double best_similarity = current_similarity;
-  double current_penalty = min_similarity;
-  for (offset_t k = best_k;
-       equivalence.src_offset + k < old_image_index.size() &&
-       equivalence.dst_offset + k < new_image_index.size();
-       ++k) {
-    // Mismatch in type, |candidate| cannot be extended further.
-    if (old_image_index.LookupType(equivalence.src_offset + k) !=
-        new_image_index.LookupType(equivalence.dst_offset + k)) {
-      break;
-    }
-
-    if (!new_image_index.IsToken(equivalence.dst_offset + k)) {
-      // Non-tokens are joined with the nearest previous token: skip until we
-      // cover the unit, and extend |best_k| if applicable.
-      if (best_k == k)
-        best_k = k + 1;
-      continue;
-    }
-
-    double similarity = GetTokenSimilarity(
-        old_image_index, new_image_index, targets_affinities,
-        equivalence.src_offset + k, equivalence.dst_offset + k);
-    current_similarity += similarity;
-    current_penalty = std::max(0.0, current_penalty) - similarity;
-
-    if (current_similarity < 0.0 || current_penalty >= min_similarity)
-      break;
-    if (current_similarity >= best_similarity) {
-      best_similarity = current_similarity;
-      best_k = k + 1;
-    }
-  }
-  equivalence.length = best_k;
-  return {equivalence, best_similarity};
-}
-
-EquivalenceCandidate ExtendEquivalenceBackward(
-    const ImageIndex& old_image_index,
-    const ImageIndex& new_image_index,
-    const std::vector<TargetsAffinity>& targets_affinities,
-    const EquivalenceCandidate& candidate,
-    double min_similarity) {
-  Equivalence equivalence = candidate.eq;
-  offset_t best_k = 0;
-  double current_similarity = candidate.similarity;
-  double best_similarity = current_similarity;
-  double current_penalty = 0.0;
-  offset_t k_min = std::min(
-      {equivalence.dst_offset, equivalence.src_offset, kBackwardsExtendLimit});
-  for (offset_t k = 1; k <= k_min; ++k) {
-    // Mismatch in type, |candidate| cannot be extended further.
-    if (old_image_index.LookupType(equivalence.src_offset - k) !=
-        new_image_index.LookupType(equivalence.dst_offset - k)) {
-      break;
-    }
-
-    // Non-tokens are joined with the nearest previous token: skip until we
-    // reach the next token.
-    if (!new_image_index.IsToken(equivalence.dst_offset - k))
-      continue;
-
-    DCHECK_EQ(old_image_index.LookupType(equivalence.src_offset - k),
-              new_image_index.LookupType(equivalence.dst_offset -
-                                         k));  // Sanity check.
-    double similarity = GetTokenSimilarity(
-        old_image_index, new_image_index, targets_affinities,
-        equivalence.src_offset - k, equivalence.dst_offset - k);
-
-    current_similarity += similarity;
-    current_penalty = std::max(0.0, current_penalty) - similarity;
-
-    if (current_similarity < 0.0 || current_penalty >= min_similarity)
-      break;
-    if (current_similarity >= best_similarity) {
-      best_similarity = current_similarity;
-      best_k = k;
-    }
-  }
-
-  equivalence.dst_offset -= best_k;
-  equivalence.src_offset -= best_k;
-  equivalence.length += best_k;
-  return {equivalence, best_similarity};
-}
-
-EquivalenceCandidate VisitEquivalenceSeed(
-    const ImageIndex& old_image_index,
-    const ImageIndex& new_image_index,
-    const std::vector<TargetsAffinity>& targets_affinities,
-    offset_t src,
-    offset_t dst,
-    double min_similarity) {
-  EquivalenceCandidate candidate{{src, dst, 0}, 0.0};  // Empty.
-  if (!old_image_index.IsToken(src))
-    return candidate;
-  candidate =
-      ExtendEquivalenceForward(old_image_index, new_image_index,
-                               targets_affinities, candidate, min_similarity);
-  if (candidate.similarity < min_similarity)
-    return candidate;  // Not worth exploring any more.
-  return ExtendEquivalenceBackward(old_image_index, new_image_index,
-                                   targets_affinities, candidate,
-                                   min_similarity);
-}
-
-/******** OffsetMapper ********/
-
-OffsetMapper::OffsetMapper(std::deque<Equivalence>&& equivalences,
-                           offset_t old_image_size,
-                           offset_t new_image_size)
-    : equivalences_(std::move(equivalences)),
-      old_image_size_(old_image_size),
-      new_image_size_(new_image_size) {
-  DCHECK_GT(new_image_size_, 0U);
-  DCHECK(std::is_sorted(equivalences_.begin(), equivalences_.end(),
-                        [](const Equivalence& a, const Equivalence& b) {
-                          return a.src_offset < b.src_offset;
-                        }));
-  // This is for testing. Assume pruned.
-}
-
-OffsetMapper::OffsetMapper(EquivalenceSource&& equivalence_source,
-                           offset_t old_image_size,
-                           offset_t new_image_size)
-    : old_image_size_(old_image_size), new_image_size_(new_image_size) {
-  DCHECK_GT(new_image_size_, 0U);
-  for (auto e = equivalence_source.GetNext(); e.has_value();
-       e = equivalence_source.GetNext()) {
-    equivalences_.push_back(*e);
-  }
-  PruneEquivalencesAndSortBySource(&equivalences_);
-}
-
-OffsetMapper::OffsetMapper(const EquivalenceMap& equivalence_map,
-                           offset_t old_image_size,
-                           offset_t new_image_size)
-    : equivalences_(equivalence_map.size()),
-      old_image_size_(old_image_size),
-      new_image_size_(new_image_size) {
-  DCHECK_GT(new_image_size_, 0U);
-  std::transform(equivalence_map.begin(), equivalence_map.end(),
-                 equivalences_.begin(),
-                 [](const EquivalenceCandidate& c) { return c.eq; });
-  PruneEquivalencesAndSortBySource(&equivalences_);
-}
-
-OffsetMapper::~OffsetMapper() = default;
-
-// Safely evaluates |offset - unit.src_offset + unit.dst_offset| with signed
-// arithmetic, then clips the result to |[0, new_image_size_)|.
-offset_t OffsetMapper::NaiveExtendedForwardProject(const Equivalence& unit,
-                                                   offset_t offset) const {
-  int64_t old_offset64 = offset;
-  int64_t src_offset64 = unit.src_offset;
-  int64_t dst_offset64 = unit.dst_offset;
-  uint64_t new_offset64 = std::min<uint64_t>(
-      std::max<int64_t>(0LL, old_offset64 - src_offset64 + dst_offset64),
-      new_image_size_ - 1);
-  return base::checked_cast<offset_t>(new_offset64);
-}
-
-offset_t OffsetMapper::ExtendedForwardProject(offset_t offset) const {
-  DCHECK(!equivalences_.empty());
-  if (offset < old_image_size_) {
-    // Finds the equivalence unit whose "old" block is nearest to |offset|,
-    // favoring the block with lower offset in case of a tie.
-    auto pos = std::upper_bound(
-        equivalences_.begin(), equivalences_.end(), offset,
-        [](offset_t a, const Equivalence& b) { return a < b.src_offset; });
-    // For tiebreaking: |offset - pos[-1].src_end()| is actually 1 less than
-    // |offset|'s distance to "old" block of |pos[-1]|. Therefore "<" is used.
-    if (pos != equivalences_.begin() &&
-        (pos == equivalences_.end() || offset < pos[-1].src_end() ||
-         offset - pos[-1].src_end() < pos->src_offset - offset)) {
-      --pos;
-    }
-    return NaiveExtendedForwardProject(*pos, offset);
-  }
-  // Fake offsets.
-  offset_t delta = offset - old_image_size_;
-  return delta < kOffsetBound - new_image_size_ ? new_image_size_ + delta
-                                                : kOffsetBound - 1;
-}
-
-void OffsetMapper::ForwardProjectAll(std::deque<offset_t>* offsets) const {
-  DCHECK(std::is_sorted(offsets->begin(), offsets->end()));
-  auto current = equivalences_.begin();
-  for (auto& src : *offsets) {
-    while (current != end() && current->src_end() <= src) {
-      ++current;
-    }
-
-    if (current != end() && current->src_offset <= src) {
-      src = src - current->src_offset + current->dst_offset;
-    } else {
-      src = kInvalidOffset;
-    }
-  }
-  base::Erase(*offsets, kInvalidOffset);
-  offsets->shrink_to_fit();
-}
-
-void OffsetMapper::PruneEquivalencesAndSortBySource(
-    std::deque<Equivalence>* equivalences) {
-  std::sort(equivalences->begin(), equivalences->end(),
-            [](const Equivalence& a, const Equivalence& b) {
-              return a.src_offset < b.src_offset;
-            });
-
-  for (auto current = equivalences->begin(); current != equivalences->end();
-       ++current) {
-    // A "reaper" is an equivalence after |current| that overlaps with it, but
-    // is longer, and so truncates |current|.  For example:
-    //  ******  <=  |current|
-    //    **
-    //    ****
-    //      ****
-    //      **********  <= |next| as reaper.
-    // If a reaper is found (as |next|), every equivalence strictly between
-    // |current| and |next| would be truncated to 0 and discarded. Handling this
-    // case is important to avoid O(n^2) behavior.
-    bool next_is_reaper = false;
-
-    // Look ahead to resolve overlaps, until a better candidate is found.
-    auto next = current + 1;
-    for (; next != equivalences->end(); ++next) {
-      DCHECK_GE(next->src_offset, current->src_offset);
-      if (next->src_offset >= current->src_end())
-        break;  // No more overlap.
-
-      if (current->length < next->length) {
-        // |next| is better: So it is a reaper that shrinks |current|.
-        offset_t delta = current->src_end() - next->src_offset;
-        current->length -= delta;
-        next_is_reaper = true;
-        break;
-      }
-    }
-
-    if (next_is_reaper) {
-      // Discard all equivalences strictly between |cur| and |next|.
-      for (auto reduced = current + 1; reduced != next; ++reduced)
-        reduced->length = 0;
-      current = next - 1;
-    } else {
-      // Shrink all equivalences that overlap with |current|. These are all
-      // worse than |current| since no reaper is found.
-      for (auto reduced = current + 1; reduced != next; ++reduced) {
-        offset_t delta = current->src_end() - reduced->src_offset;
-        reduced->length -= std::min(reduced->length, delta);
-        reduced->src_offset += delta;
-        reduced->dst_offset += delta;
-        DCHECK_EQ(reduced->src_offset, current->src_end());
-      }
-    }
-  }
-
-  // Discard all equivalences with length == 0.
-  base::EraseIf(*equivalences, [](const Equivalence& equivalence) {
-    return equivalence.length == 0;
-  });
-  equivalences->shrink_to_fit();
-}
-
-/******** EquivalenceMap ********/
-
-EquivalenceMap::EquivalenceMap() = default;
-
-EquivalenceMap::EquivalenceMap(std::vector<EquivalenceCandidate>&& equivalences)
-    : candidates_(std::move(equivalences)) {
-  SortByDestination();
-}
-
-EquivalenceMap::EquivalenceMap(EquivalenceMap&&) = default;
-
-EquivalenceMap::~EquivalenceMap() = default;
-
-void EquivalenceMap::Build(
-    const std::vector<offset_t>& old_sa,
-    const EncodedView& old_view,
-    const EncodedView& new_view,
-    const std::vector<TargetsAffinity>& targets_affinities,
-    double min_similarity) {
-  DCHECK_EQ(old_sa.size(), old_view.size());
-
-  CreateCandidates(old_sa, old_view, new_view, targets_affinities,
-                   min_similarity);
-  SortByDestination();
-  Prune(old_view, new_view, targets_affinities, min_similarity);
-
-  offset_t coverage = 0;
-  offset_t current_offset = 0;
-  for (auto candidate : candidates_) {
-    DCHECK_GE(candidate.eq.dst_offset, current_offset);
-    coverage += candidate.eq.length;
-    current_offset = candidate.eq.dst_end();
-  }
-  LOG(INFO) << "Equivalence Count: " << size();
-  LOG(INFO) << "Coverage / Extra / Total: " << coverage << " / "
-            << new_view.size() - coverage << " / " << new_view.size();
-}
-
-void EquivalenceMap::CreateCandidates(
-    const std::vector<offset_t>& old_sa,
-    const EncodedView& old_view,
-    const EncodedView& new_view,
-    const std::vector<TargetsAffinity>& targets_affinities,
-    double min_similarity) {
-  candidates_.clear();
-
-  // This is an heuristic to find 'good' equivalences on encoded views.
-  // Equivalences are found in ascending order of |new_image|.
-  offset_t dst_offset = 0;
-
-  while (dst_offset < new_view.size()) {
-    if (!new_view.IsToken(dst_offset)) {
-      ++dst_offset;
-      continue;
-    }
-    auto match =
-        SuffixLowerBound(old_sa, old_view.begin(),
-                         new_view.begin() + dst_offset, new_view.end());
-
-    offset_t next_dst_offset = dst_offset + 1;
-    // TODO(huangs): Clean up.
-    double best_similarity = min_similarity;
-    uint64_t total_visit_length = 0;
-    EquivalenceCandidate best_candidate = {{0, 0, 0}, 0.0};
-    for (auto it = match; it != old_sa.end(); ++it) {
-      EquivalenceCandidate candidate = VisitEquivalenceSeed(
-          old_view.image_index(), new_view.image_index(), targets_affinities,
-          static_cast<offset_t>(*it), dst_offset, min_similarity);
-      if (candidate.similarity > best_similarity) {
-        best_candidate = candidate;
-        best_similarity = candidate.similarity;
-        next_dst_offset = candidate.eq.dst_end();
-        total_visit_length += candidate.eq.length;
-        if (total_visit_length > kSeedSelectionTotalVisitLengthQuota) {
-          break;
-        }
-      } else {
-        break;
-      }
-    }
-    total_visit_length = 0;
-    for (auto it = match; it != old_sa.begin(); --it) {
-      EquivalenceCandidate candidate = VisitEquivalenceSeed(
-          old_view.image_index(), new_view.image_index(), targets_affinities,
-          static_cast<offset_t>(it[-1]), dst_offset, min_similarity);
-      if (candidate.similarity > best_similarity) {
-        best_candidate = candidate;
-        best_similarity = candidate.similarity;
-        next_dst_offset = candidate.eq.dst_end();
-        total_visit_length += candidate.eq.length;
-        if (total_visit_length > kSeedSelectionTotalVisitLengthQuota) {
-          break;
-        }
-      } else {
-        break;
-      }
-    }
-    if (best_candidate.similarity >= min_similarity) {
-      candidates_.push_back(best_candidate);
-    }
-
-    dst_offset = next_dst_offset;
-  }
-}
-
-void EquivalenceMap::SortByDestination() {
-  std::sort(candidates_.begin(), candidates_.end(),
-            [](const EquivalenceCandidate& a, const EquivalenceCandidate& b) {
-              return a.eq.dst_offset < b.eq.dst_offset;
-            });
-}
-
-void EquivalenceMap::Prune(
-    const EncodedView& old_view,
-    const EncodedView& new_view,
-    const std::vector<TargetsAffinity>& target_affinities,
-    double min_similarity) {
-  // TODO(etiennep): unify with
-  // OffsetMapper::PruneEquivalencesAndSortBySource().
-  for (auto current = candidates_.begin(); current != candidates_.end();
-       ++current) {
-    if (current->similarity < min_similarity)
-      continue;  // This candidate will be discarded anyways.
-
-    bool next_is_reaper = false;
-
-    // Look ahead to resolve overlaps, until a better candidate is found.
-    auto next = current + 1;
-    for (; next != candidates_.end(); ++next) {
-      DCHECK_GE(next->eq.dst_offset, current->eq.dst_offset);
-      if (next->eq.dst_offset >= current->eq.dst_offset + current->eq.length)
-        break;  // No more overlap.
-
-      if (current->similarity < next->similarity) {
-        // |next| is better: So it is a reaper that shrinks |current|.
-        offset_t delta = current->eq.dst_end() - next->eq.dst_offset;
-        current->eq.length -= delta;
-        current->similarity = GetEquivalenceSimilarity(
-            old_view.image_index(), new_view.image_index(), target_affinities,
-            current->eq);
-
-        next_is_reaper = true;
-        break;
-      }
-    }
-
-    if (next_is_reaper) {
-      // Discard all equivalences strictly between |cur| and |next|.
-      for (auto reduced = current + 1; reduced != next; ++reduced) {
-        reduced->eq.length = 0;
-        reduced->similarity = 0;
-      }
-      current = next - 1;
-    } else {
-      // Shrinks all overlapping candidates following and worse than |current|.
-      for (auto reduced = current + 1; reduced != next; ++reduced) {
-        offset_t delta = current->eq.dst_end() - reduced->eq.dst_offset;
-        reduced->eq.length -= std::min(reduced->eq.length, delta);
-        reduced->eq.src_offset += delta;
-        reduced->eq.dst_offset += delta;
-        reduced->similarity = GetEquivalenceSimilarity(
-            old_view.image_index(), new_view.image_index(), target_affinities,
-            reduced->eq);
-        DCHECK_EQ(reduced->eq.dst_offset, current->eq.dst_end());
-      }
-    }
-  }
-
-  // Discard all candidates with similarity smaller than |min_similarity|.
-  base::EraseIf(candidates_,
-                [min_similarity](const EquivalenceCandidate& candidate) {
-                  return candidate.similarity < min_similarity;
-                });
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/patch_reader.cc b/native/zucchini/vendor/zucchini/patch_reader.cc
deleted file mode 100644
index 168389f..0000000
--- a/native/zucchini/vendor/zucchini/patch_reader.cc
+++ /dev/null
@@ -1,401 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/patch_reader.h"
-
-#include <type_traits>
-#include <utility>
-
-#include "base/numerics/safe_conversions.h"
-#include "components/zucchini/algorithm.h"
-#include "components/zucchini/crc32.h"
-#include "components/zucchini/element_detection.h"
-#include "components/zucchini/version_info.h"
-
-namespace zucchini {
-
-namespace patch {
-
-bool ParseElementMatch(BufferSource* source, ElementMatch* element_match) {
-  PatchElementHeader unsafe_element_header;
-  if (!source->GetValue(&unsafe_element_header)) {
-    LOG(ERROR) << "Impossible to read ElementMatch from source.";
-    return false;
-  }
-  ExecutableType exe_type =
-      CastToExecutableType(unsafe_element_header.exe_type);
-  if (exe_type == kExeTypeUnknown) {
-    LOG(ERROR) << "Invalid ExecutableType found.";
-    return false;
-  }
-  uint16_t element_version = DisassemblerVersionOfType(exe_type);
-  if (element_version != unsafe_element_header.version) {
-    LOG(ERROR) << "Element version doesn't match. Expected: " << element_version
-               << ", Actual:" << unsafe_element_header.version;
-    return false;
-  }
-  if (!unsafe_element_header.old_length || !unsafe_element_header.new_length) {
-    LOG(ERROR) << "Empty patch element found.";
-    return false;
-  }
-  // |unsafe_element_header| is now considered to be safe as it has a valid
-  // |exe_type| and the length fields are of sufficient size.
-  const auto& element_header = unsafe_element_header;
-
-  // Caveat: Element offsets and lengths can still be invalid (e.g., exceeding
-  // archive bounds), but this will be checked later.
-  element_match->old_element.offset = element_header.old_offset;
-  element_match->old_element.size = element_header.old_length;
-  element_match->new_element.offset = element_header.new_offset;
-  element_match->new_element.size = element_header.new_length;
-  element_match->old_element.exe_type = exe_type;
-  element_match->new_element.exe_type = exe_type;
-  return true;
-}
-
-bool ParseBuffer(BufferSource* source, BufferSource* buffer) {
-  uint32_t unsafe_size = 0;  // Bytes.
-  static_assert(sizeof(size_t) >= sizeof(unsafe_size),
-                "size_t is expected to be larger than uint32_t.");
-  if (!source->GetValue(&unsafe_size)) {
-    LOG(ERROR) << "Impossible to read buffer size from source.";
-    return false;
-  }
-  if (!source->GetRegion(static_cast<size_t>(unsafe_size), buffer)) {
-    LOG(ERROR) << "Impossible to read buffer content from source.";
-    return false;
-  }
-  // Caveat: |buffer| is considered to be safe as it was possible to extract it
-  // from the patch. However, this does not mean its contents are safe and when
-  // parsed must be validated if possible.
-  return true;
-}
-
-}  // namespace patch
-
-/******** EquivalenceSource ********/
-
-EquivalenceSource::EquivalenceSource() = default;
-EquivalenceSource::EquivalenceSource(const EquivalenceSource&) = default;
-EquivalenceSource::~EquivalenceSource() = default;
-
-bool EquivalenceSource::Initialize(BufferSource* source) {
-  return patch::ParseBuffer(source, &src_skip_) &&
-         patch::ParseBuffer(source, &dst_skip_) &&
-         patch::ParseBuffer(source, &copy_count_);
-}
-
-std::optional<Equivalence> EquivalenceSource::GetNext() {
-  if (src_skip_.empty() || dst_skip_.empty() || copy_count_.empty())
-    return std::nullopt;
-
-  Equivalence equivalence = {};
-
-  uint32_t length = 0;
-  if (!patch::ParseVarUInt<uint32_t>(&copy_count_, &length))
-    return std::nullopt;
-  equivalence.length = base::strict_cast<offset_t>(length);
-
-  int32_t src_offset_diff = 0;  // Intentionally signed.
-  if (!patch::ParseVarInt<int32_t>(&src_skip_, &src_offset_diff))
-    return std::nullopt;
-  base::CheckedNumeric<offset_t> src_offset =
-      previous_src_offset_ + src_offset_diff;
-  if (!src_offset.IsValid())
-    return std::nullopt;
-
-  equivalence.src_offset = src_offset.ValueOrDie();
-  previous_src_offset_ = src_offset + equivalence.length;
-  if (!previous_src_offset_.IsValid())
-    return std::nullopt;
-
-  uint32_t dst_offset_diff = 0;  // Intentionally unsigned.
-  if (!patch::ParseVarUInt<uint32_t>(&dst_skip_, &dst_offset_diff))
-    return std::nullopt;
-  base::CheckedNumeric<offset_t> dst_offset =
-      previous_dst_offset_ + dst_offset_diff;
-  if (!dst_offset.IsValid())
-    return std::nullopt;
-
-  equivalence.dst_offset = dst_offset.ValueOrDie();
-  previous_dst_offset_ = equivalence.dst_offset + equivalence.length;
-  if (!previous_dst_offset_.IsValid())
-    return std::nullopt;
-
-  // Caveat: |equivalence| is assumed to be safe only once the
-  // ValidateEquivalencesAndExtraData() method has returned true. Prior to this
-  // any equivalence returned is assumed to be unsafe.
-  return equivalence;
-}
-
-/******** ExtraDataSource ********/
-
-ExtraDataSource::ExtraDataSource() = default;
-ExtraDataSource::ExtraDataSource(const ExtraDataSource&) = default;
-ExtraDataSource::~ExtraDataSource() = default;
-
-bool ExtraDataSource::Initialize(BufferSource* source) {
-  return patch::ParseBuffer(source, &extra_data_);
-}
-
-std::optional<ConstBufferView> ExtraDataSource::GetNext(offset_t size) {
-  ConstBufferView buffer;
-  if (!extra_data_.GetRegion(size, &buffer))
-    return std::nullopt;
-  // |buffer| is assumed to always be safe/valid.
-  return buffer;
-}
-
-/******** RawDeltaSource ********/
-
-RawDeltaSource::RawDeltaSource() = default;
-RawDeltaSource::RawDeltaSource(const RawDeltaSource&) = default;
-RawDeltaSource::~RawDeltaSource() = default;
-
-bool RawDeltaSource::Initialize(BufferSource* source) {
-  return patch::ParseBuffer(source, &raw_delta_skip_) &&
-         patch::ParseBuffer(source, &raw_delta_diff_);
-}
-
-std::optional<RawDeltaUnit> RawDeltaSource::GetNext() {
-  if (raw_delta_skip_.empty() || raw_delta_diff_.empty())
-    return std::nullopt;
-
-  RawDeltaUnit raw_delta = {};
-  uint32_t copy_offset_diff = 0;
-  if (!patch::ParseVarUInt<uint32_t>(&raw_delta_skip_, &copy_offset_diff))
-    return std::nullopt;
-  base::CheckedNumeric<offset_t> copy_offset =
-      copy_offset_diff + copy_offset_compensation_;
-  if (!copy_offset.IsValid())
-    return std::nullopt;
-  raw_delta.copy_offset = copy_offset.ValueOrDie();
-
-  if (!raw_delta_diff_.GetValue<int8_t>(&raw_delta.diff))
-    return std::nullopt;
-
-  // A 0 value for a delta.diff is considered invalid since it has no meaning.
-  if (!raw_delta.diff)
-    return std::nullopt;
-
-  // We keep track of the compensation needed for next offset, taking into
-  // account delta encoding and bias of -1.
-  copy_offset_compensation_ = copy_offset + 1;
-  if (!copy_offset_compensation_.IsValid())
-    return std::nullopt;
-  // |raw_delta| is assumed to always be safe/valid.
-  return raw_delta;
-}
-
-/******** ReferenceDeltaSource ********/
-
-ReferenceDeltaSource::ReferenceDeltaSource() = default;
-ReferenceDeltaSource::ReferenceDeltaSource(const ReferenceDeltaSource&) =
-    default;
-ReferenceDeltaSource::~ReferenceDeltaSource() = default;
-
-bool ReferenceDeltaSource::Initialize(BufferSource* source) {
-  return patch::ParseBuffer(source, &source_);
-}
-
-std::optional<int32_t> ReferenceDeltaSource::GetNext() {
-  if (source_.empty())
-    return std::nullopt;
-  int32_t ref_delta = 0;
-  if (!patch::ParseVarInt<int32_t>(&source_, &ref_delta))
-    return std::nullopt;
-  // |ref_delta| is assumed to always be safe/valid.
-  return ref_delta;
-}
-
-/******** TargetSource ********/
-
-TargetSource::TargetSource() = default;
-TargetSource::TargetSource(const TargetSource&) = default;
-TargetSource::~TargetSource() = default;
-
-bool TargetSource::Initialize(BufferSource* source) {
-  return patch::ParseBuffer(source, &extra_targets_);
-}
-
-std::optional<offset_t> TargetSource::GetNext() {
-  if (extra_targets_.empty())
-    return std::nullopt;
-
-  uint32_t target_diff = 0;
-  if (!patch::ParseVarUInt<uint32_t>(&extra_targets_, &target_diff))
-    return std::nullopt;
-  base::CheckedNumeric<offset_t> target = target_diff + target_compensation_;
-  if (!target.IsValid())
-    return std::nullopt;
-
-  // We keep track of the compensation needed for next target, taking into
-  // account delta encoding and bias of -1.
-  target_compensation_ = target + 1;
-  if (!target_compensation_.IsValid())
-    return std::nullopt;
-  // Caveat: |target| will be a valid offset_t, but it's up to the caller to
-  // check whether it's a valid offset for an image.
-  return offset_t(target.ValueOrDie());
-}
-
-/******** PatchElementReader ********/
-
-PatchElementReader::PatchElementReader() = default;
-PatchElementReader::PatchElementReader(PatchElementReader&&) = default;
-PatchElementReader::~PatchElementReader() = default;
-
-bool PatchElementReader::Initialize(BufferSource* source) {
-  bool ok =
-      patch::ParseElementMatch(source, &element_match_) &&
-      equivalences_.Initialize(source) && extra_data_.Initialize(source) &&
-      ValidateEquivalencesAndExtraData() && raw_delta_.Initialize(source) &&
-      reference_delta_.Initialize(source);
-  if (!ok)
-    return false;
-  uint32_t pool_count = 0;
-  if (!source->GetValue(&pool_count)) {
-    LOG(ERROR) << "Impossible to read pool_count from source.";
-    return false;
-  }
-  for (uint32_t i = 0; i < pool_count; ++i) {
-    uint8_t pool_tag_value = 0;
-    if (!source->GetValue(&pool_tag_value)) {
-      LOG(ERROR) << "Impossible to read pool_tag from source.";
-      return false;
-    }
-    PoolTag pool_tag(pool_tag_value);
-    if (pool_tag == kNoPoolTag) {
-      LOG(ERROR) << "Invalid pool_tag encountered in ExtraTargetList.";
-      return false;
-    }
-    auto insert_result = extra_targets_.insert({pool_tag, {}});
-    if (!insert_result.second) {  // Element already present.
-      LOG(ERROR) << "Multiple ExtraTargetList found for the same pool_tag.";
-      return false;
-    }
-    if (!insert_result.first->second.Initialize(source))
-      return false;
-  }
-  return true;
-}
-
-bool PatchElementReader::ValidateEquivalencesAndExtraData() {
-  EquivalenceSource equivalences_copy = equivalences_;
-
-  const size_t old_region_size = element_match_.old_element.size;
-  const size_t new_region_size = element_match_.new_element.size;
-
-  base::CheckedNumeric<uint32_t> total_length = 0;
-  // Validate that each |equivalence| falls within the bounds of the
-  // |element_match_| and are in order.
-  offset_t prev_dst_end = 0;
-  for (auto equivalence = equivalences_copy.GetNext(); equivalence.has_value();
-       equivalence = equivalences_copy.GetNext()) {
-    if (!RangeIsBounded(equivalence->src_offset, equivalence->length,
-                        old_region_size) ||
-        !RangeIsBounded(equivalence->dst_offset, equivalence->length,
-                        new_region_size)) {
-      LOG(ERROR) << "Out of bounds equivalence detected.";
-      return false;
-    }
-    if (prev_dst_end > equivalence->dst_end()) {
-      LOG(ERROR) << "Out of order equivalence detected.";
-      return false;
-    }
-    prev_dst_end = equivalence->dst_end();
-    total_length += equivalence->length;
-  }
-  if (!total_length.IsValid() ||
-      element_match_.new_element.region().size < total_length.ValueOrDie() ||
-      extra_data_.extra_data().size() !=
-          element_match_.new_element.region().size -
-              static_cast<size_t>(total_length.ValueOrDie())) {
-    LOG(ERROR) << "Incorrect amount of extra_data.";
-    return false;
-  }
-  return true;
-}
-
-/******** EnsemblePatchReader ********/
-
-std::optional<EnsemblePatchReader> EnsemblePatchReader::Create(
-    ConstBufferView buffer) {
-  BufferSource source(buffer);
-  EnsemblePatchReader patch;
-  if (!patch.Initialize(&source))
-    return std::nullopt;
-  return patch;
-}
-
-EnsemblePatchReader::EnsemblePatchReader() = default;
-EnsemblePatchReader::EnsemblePatchReader(EnsemblePatchReader&&) = default;
-EnsemblePatchReader::~EnsemblePatchReader() = default;
-
-bool EnsemblePatchReader::Initialize(BufferSource* source) {
-  if (!source->GetValue(&header_)) {
-    LOG(ERROR) << "Impossible to read header from source.";
-    return false;
-  }
-  if (header_.magic != PatchHeader::kMagic) {
-    LOG(ERROR) << "Patch contains invalid magic.";
-    return false;
-  }
-  if (header_.major_version != kMajorVersion) {
-    LOG(ERROR) << "Patch major version doesn't match. Expected: "
-               << kMajorVersion << ", Actual:" << header_.major_version;
-    return false;
-  }
-  // |header_| is assumed to be safe from this point forward.
-
-  uint32_t element_count = 0;
-  if (!source->GetValue(&element_count)) {
-    LOG(ERROR) << "Impossible to read element_count from source.";
-    return false;
-  }
-
-  offset_t current_dst_offset = 0;
-  for (uint32_t i = 0; i < element_count; ++i) {
-    PatchElementReader element_patch;
-    if (!element_patch.Initialize(source))
-      return false;
-
-    if (!element_patch.old_element().FitsIn(header_.old_size) ||
-        !element_patch.new_element().FitsIn(header_.new_size)) {
-      LOG(ERROR) << "Invalid element encountered.";
-      return false;
-    }
-
-    if (element_patch.new_element().offset != current_dst_offset) {
-      LOG(ERROR) << "Invalid element encountered.";
-      return false;
-    }
-    current_dst_offset = element_patch.new_element().EndOffset();
-
-    elements_.push_back(std::move(element_patch));
-  }
-  if (current_dst_offset != header_.new_size) {
-    LOG(ERROR) << "Patch elements don't fully cover new image file.";
-    return false;
-  }
-
-  if (!source->empty()) {
-    LOG(ERROR) << "Patch was not fully consumed.";
-    return false;
-  }
-
-  return true;
-}
-
-bool EnsemblePatchReader::CheckOldFile(ConstBufferView old_image) const {
-  return old_image.size() == header_.old_size &&
-         CalculateCrc32(old_image.begin(), old_image.end()) == header_.old_crc;
-}
-
-bool EnsemblePatchReader::CheckNewFile(ConstBufferView new_image) const {
-  return new_image.size() == header_.new_size &&
-         CalculateCrc32(new_image.begin(), new_image.end()) == header_.new_crc;
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/rel32_finder.cc b/native/zucchini/vendor/zucchini/rel32_finder.cc
deleted file mode 100644
index 1ad8910..0000000
--- a/native/zucchini/vendor/zucchini/rel32_finder.cc
+++ /dev/null
@@ -1,294 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/rel32_finder.h"
-
-#include <algorithm>
-
-#include "base/numerics/safe_conversions.h"
-
-namespace zucchini {
-
-/******** Abs32GapFinder ********/
-
-Abs32GapFinder::Abs32GapFinder(ConstBufferView image,
-                               ConstBufferView region,
-                               const std::vector<offset_t>& abs32_locations,
-                               size_t abs32_width)
-    : base_(image.begin()),
-      region_end_(region.end()),
-      abs32_end_(abs32_locations.end()),
-      abs32_width_(abs32_width) {
-  DCHECK_GT(abs32_width, size_t(0));
-  DCHECK_GE(region.begin(), image.begin());
-  DCHECK_LE(region.end(), image.end());
-
-  const offset_t begin_offset =
-      base::checked_cast<offset_t>(region.begin() - image.begin());
-  // Find the first |abs32_cur_| with |*abs32_cur_ >= begin_offset|.
-  abs32_cur_ = std::lower_bound(abs32_locations.begin(), abs32_locations.end(),
-                                begin_offset);
-
-  // Find lower boundary, accounting for the possibility that |abs32_cur_[-1]|
-  // may straddle across |region.begin()|.
-  cur_lo_ = region.begin();
-  if (abs32_cur_ > abs32_locations.begin())
-    cur_lo_ = std::max(cur_lo_, image.begin() + abs32_cur_[-1] + abs32_width_);
-}
-
-Abs32GapFinder::~Abs32GapFinder() = default;
-
-bool Abs32GapFinder::FindNext() {
-  // Iterate over |[abs32_cur_, abs32_end_)| and emit segments.
-  while (abs32_cur_ != abs32_end_ && base_ + *abs32_cur_ < region_end_) {
-    ConstBufferView::const_iterator hi = base_ + *abs32_cur_;
-    gap_ = ConstBufferView::FromRange(cur_lo_, hi);
-    cur_lo_ = hi + abs32_width_;
-    ++abs32_cur_;
-    if (!gap_.empty())
-      return true;
-  }
-  // Emit final segment.
-  if (cur_lo_ < region_end_) {
-    gap_ = ConstBufferView::FromRange(cur_lo_, region_end_);
-    cur_lo_ = region_end_;
-    return true;
-  }
-  return false;
-}
-
-/******** Rel32Finder ********/
-
-Rel32Finder::Rel32Finder(ConstBufferView image,
-                         const AddressTranslator& translator)
-    : image_(image), offset_to_rva_(translator) {}
-
-Rel32Finder::~Rel32Finder() = default;
-
-void Rel32Finder::SetRegion(ConstBufferView region) {
-  region_ = region;
-  accept_it_ = region.begin();
-}
-
-bool Rel32Finder::FindNext() {
-  NextIterators next_iters = Scan(region_);
-  if (next_iters.reject == nullptr) {
-    region_.seek(region_.end());
-    return false;
-  }
-  region_.seek(next_iters.reject);
-  accept_it_ = next_iters.accept;
-  DCHECK_GE(accept_it_, region_.begin());
-  DCHECK_LE(accept_it_, region_.end());
-  return true;
-}
-
-void Rel32Finder::Accept() {
-  region_.seek(accept_it_);
-}
-
-/******** Rel32FinderIntel ********/
-
-Rel32Finder::NextIterators Rel32FinderIntel::SetResult(
-    ConstBufferView::const_iterator cursor,
-    uint32_t opcode_size,
-    bool can_point_outside_section) {
-  offset_t location =
-      base::checked_cast<offset_t>((cursor + opcode_size) - image_.begin());
-  rva_t location_rva = offset_to_rva_.Convert(location);
-  DCHECK_NE(location_rva, kInvalidRva);
-  rva_t target_rva = location_rva + 4 + image_.read<uint32_t>(location);
-  rel32_ = {location, target_rva, can_point_outside_section};
-  return {cursor + 1, cursor + (opcode_size + 4)};
-}
-
-/******** Rel32FinderX86 ********/
-
-Rel32Finder::NextIterators Rel32FinderX86::Scan(ConstBufferView region) {
-  ConstBufferView::const_iterator cursor = region.begin();
-  while (cursor < region.end()) {
-    // Heuristic rel32 detection by looking for opcodes that use them.
-    if (cursor + 5 <= region.end()) {
-      if (cursor[0] == 0xE8 || cursor[0] == 0xE9)  // JMP rel32; CALL rel32
-        return SetResult(cursor, 1, false);
-    }
-    if (cursor + 6 <= region.end()) {
-      if (cursor[0] == 0x0F && (cursor[1] & 0xF0) == 0x80)  // Jcc long form
-        return SetResult(cursor, 2, false);
-    }
-    ++cursor;
-  }
-  return {nullptr, nullptr};
-}
-
-/******** Rel32FinderX64 ********/
-
-Rel32Finder::NextIterators Rel32FinderX64::Scan(ConstBufferView region) {
-  ConstBufferView::const_iterator cursor = region.begin();
-  while (cursor < region.end()) {
-    // Heuristic rel32 detection by looking for opcodes that use them.
-    if (cursor + 5 <= region.end()) {
-      if (cursor[0] == 0xE8 || cursor[0] == 0xE9)  // JMP rel32; CALL rel32
-        return SetResult(cursor, 1, false);
-    }
-    if (cursor + 6 <= region.end()) {
-      if (cursor[0] == 0x0F && (cursor[1] & 0xF0) == 0x80) {  // Jcc long form
-        return SetResult(cursor, 2, false);
-      } else if ((cursor[0] == 0xFF &&
-                  (cursor[1] == 0x15 || cursor[1] == 0x25)) ||
-                 ((cursor[0] == 0x89 || cursor[0] == 0x8B ||
-                   cursor[0] == 0x8D) &&
-                  (cursor[1] & 0xC7) == 0x05)) {
-        // 6-byte instructions:
-        // [2-byte opcode] [disp32]:
-        //  Opcode
-        //   FF 15: CALL QWORD PTR [rip+disp32]
-        //   FF 25: JMP  QWORD PTR [rip+disp32]
-        //
-        // [1-byte opcode] [ModR/M] [disp32]:
-        //  Opcode
-        //   89: MOV DWORD PTR [rip+disp32],reg
-        //   8B: MOV reg,DWORD PTR [rip+disp32]
-        //   8D: LEA reg,[rip+disp32]
-        //  ModR/M : MMRRRMMM
-        //   MM = 00 & MMM = 101 => rip+disp32
-        //   RRR: selects reg operand from [eax|ecx|...|edi]
-        return SetResult(cursor, 2, true);
-      }
-    }
-    ++cursor;
-  }
-  return {nullptr, nullptr};
-}
-
-/******** Rel32FinderArm ********/
-
-template <typename ADDR_TYPE>
-Rel32FinderArm<ADDR_TYPE>::Rel32FinderArm(ConstBufferView image,
-                                          const AddressTranslator& translator)
-    : Rel32Finder(image, translator) {}
-
-template <typename ADDR_TYPE>
-Rel32FinderArm<ADDR_TYPE>::~Rel32FinderArm() = default;
-
-template <typename ADDR_TYPE>
-Rel32Finder::NextIterators Rel32FinderArm<ADDR_TYPE>::SetResult(
-    Result&& result,
-    ConstBufferView::const_iterator cursor,
-    int instr_size) {
-  rel32_ = result;
-  return {cursor + instr_size, cursor + instr_size};
-}
-
-// SetResult() for end of scan.
-template <typename ADDR_TYPE>
-Rel32Finder::NextIterators Rel32FinderArm<ADDR_TYPE>::SetEmptyResult() {
-  rel32_ = {kInvalidOffset, kInvalidOffset, ADDR_TYPE::ADDR_NONE};
-  return {nullptr, nullptr};
-}
-
-/******** Rel32FinderAArch32 ********/
-
-Rel32FinderAArch32::Rel32FinderAArch32(ConstBufferView image,
-                                       const AddressTranslator& translator,
-                                       bool is_thumb2)
-    : Rel32FinderArm(image, translator), is_thumb2_(is_thumb2) {}
-
-Rel32FinderAArch32::~Rel32FinderAArch32() = default;
-
-Rel32Finder::NextIterators Rel32FinderAArch32::ScanA32(ConstBufferView region) {
-  // Guard against alignment potentially causing |cursor > region.end()|.
-  if (region.size() < 4)
-    return SetEmptyResult();
-  ConstBufferView::const_iterator cursor = region.begin();
-  cursor += IncrementForAlignCeil4(cursor - image_.begin());
-  for (; region.end() - cursor >= 4; cursor += 4) {
-    offset_t offset = base::checked_cast<offset_t>(cursor - image_.begin());
-    AArch32Rel32Translator translator;
-    rva_t instr_rva = offset_to_rva_.Convert(offset);
-    uint32_t code32 = translator.FetchArmCode32(image_, offset);
-    rva_t target_rva = kInvalidRva;
-    if (translator.ReadA24(instr_rva, code32, &target_rva)) {
-      return SetResult({offset, target_rva, AArch32Rel32Translator::ADDR_A24},
-                       cursor, 4);
-    }
-  }
-  return SetEmptyResult();
-}
-
-Rel32Finder::NextIterators Rel32FinderAArch32::ScanT32(ConstBufferView region) {
-  // Guard against alignment potentially causing |cursor > region.end()|.
-  if (region.size() < 2)
-    return SetEmptyResult();
-  ConstBufferView::const_iterator cursor = region.begin();
-  cursor += IncrementForAlignCeil2(cursor - image_.begin());
-  while (region.end() - cursor >= 2) {
-    offset_t offset = base::checked_cast<offset_t>(cursor - image_.begin());
-    AArch32Rel32Translator translator;
-    AArch32Rel32Translator::AddrType type = AArch32Rel32Translator::ADDR_NONE;
-    rva_t instr_rva = offset_to_rva_.Convert(offset);
-    uint16_t code16 = translator.FetchThumb2Code16(image_, offset);
-    int instr_size = GetThumb2InstructionSize(code16);
-    rva_t target_rva = kInvalidRva;
-    if (instr_size == 2) {  // 16-bit THUMB2 instruction.
-      if (translator.ReadT8(instr_rva, code16, &target_rva))
-        type = AArch32Rel32Translator::ADDR_T8;
-      else if (translator.ReadT11(instr_rva, code16, &target_rva))
-        type = AArch32Rel32Translator::ADDR_T11;
-    } else {  // |instr_size == 4|: 32-bit THUMB2 instruction.
-      if (region.end() - cursor >= 4) {
-        uint32_t code32 = translator.FetchThumb2Code32(image_, offset);
-        if (translator.ReadT20(instr_rva, code32, &target_rva))
-          type = AArch32Rel32Translator::ADDR_T20;
-        else if (translator.ReadT24(instr_rva, code32, &target_rva))
-          type = AArch32Rel32Translator::ADDR_T24;
-      }
-    }
-    if (type != AArch32Rel32Translator::ADDR_NONE)
-      return SetResult({offset, target_rva, type}, cursor, instr_size);
-    cursor += instr_size;
-  }
-  return SetEmptyResult();
-}
-
-Rel32Finder::NextIterators Rel32FinderAArch32::Scan(ConstBufferView region) {
-  return is_thumb2_ ? ScanT32(region) : ScanA32(region);
-}
-
-/******** Rel32FinderAArch64 ********/
-
-Rel32FinderAArch64::Rel32FinderAArch64(ConstBufferView image,
-                                       const AddressTranslator& translator)
-    : Rel32FinderArm(image, translator) {}
-
-Rel32FinderAArch64::~Rel32FinderAArch64() = default;
-
-Rel32Finder::NextIterators Rel32FinderAArch64::Scan(ConstBufferView region) {
-  // Guard against alignment potentially causing |cursor > region.end()|.
-  if (region.size() < 4)
-    return SetEmptyResult();
-  ConstBufferView::const_iterator cursor = region.begin();
-  cursor += IncrementForAlignCeil4(cursor - image_.begin());
-  for (; region.end() - cursor >= 4; cursor += 4) {
-    offset_t offset = base::checked_cast<offset_t>(cursor - image_.begin());
-    // For simplicity we assume RVA fits within 32-bits.
-    AArch64Rel32Translator translator;
-    AArch64Rel32Translator::AddrType type = AArch64Rel32Translator::ADDR_NONE;
-    rva_t instr_rva = offset_to_rva_.Convert(offset);
-    uint32_t code32 = translator.FetchCode32(image_, offset);
-    rva_t target_rva = kInvalidRva;
-    if (translator.ReadImmd14(instr_rva, code32, &target_rva)) {
-      type = AArch64Rel32Translator::ADDR_IMMD14;
-    } else if (translator.ReadImmd19(instr_rva, code32, &target_rva)) {
-      type = AArch64Rel32Translator::ADDR_IMMD19;
-    } else if (translator.ReadImmd26(instr_rva, code32, &target_rva)) {
-      type = AArch64Rel32Translator::ADDR_IMMD26;
-    }
-    if (type != AArch64Rel32Translator::ADDR_NONE)
-      return SetResult({offset, target_rva, type}, cursor, 4);
-  }
-  return SetEmptyResult();
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/rel32_utils.cc b/native/zucchini/vendor/zucchini/rel32_utils.cc
deleted file mode 100644
index 3790ed0..0000000
--- a/native/zucchini/vendor/zucchini/rel32_utils.cc
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/rel32_utils.h"
-
-#include <algorithm>
-
-#include "base/check_op.h"
-#include "components/zucchini/io_utils.h"
-
-namespace zucchini {
-
-/******** Rel32ReaderX86 ********/
-
-Rel32ReaderX86::Rel32ReaderX86(ConstBufferView image,
-                               offset_t lo,
-                               offset_t hi,
-                               const std::deque<offset_t>* locations,
-                               const AddressTranslator& translator)
-    : image_(image),
-      target_rva_to_offset_(translator),
-      location_offset_to_rva_(translator),
-      hi_(hi),
-      last_(locations->end()) {
-  DCHECK_LE(lo, image.size());
-  DCHECK_LE(hi, image.size());
-  current_ = std::lower_bound(locations->begin(), locations->end(), lo);
-}
-
-Rel32ReaderX86::~Rel32ReaderX86() = default;
-
-std::optional<Reference> Rel32ReaderX86::GetNext() {
-  while (current_ < last_ && *current_ < hi_) {
-    offset_t loc_offset = *(current_++);
-    DCHECK_LE(loc_offset + 4, image_.size());  // Sanity check.
-    rva_t loc_rva = location_offset_to_rva_.Convert(loc_offset);
-    rva_t target_rva = loc_rva + 4 + image_.read<int32_t>(loc_offset);
-    offset_t target_offset = target_rva_to_offset_.Convert(target_rva);
-    // |locations| is valid by assumption (see class description).
-    DCHECK_NE(kInvalidOffset, target_offset);
-    return Reference{loc_offset, target_offset};
-  }
-  return std::nullopt;
-}
-
-/******** Rel32ReceptorX86 ********/
-
-Rel32WriterX86::Rel32WriterX86(MutableBufferView image,
-                               const AddressTranslator& translator)
-    : image_(image),
-      target_offset_to_rva_(translator),
-      location_offset_to_rva_(translator) {}
-
-Rel32WriterX86::~Rel32WriterX86() = default;
-
-void Rel32WriterX86::PutNext(Reference ref) {
-  rva_t target_rva = target_offset_to_rva_.Convert(ref.target);
-  rva_t loc_rva = location_offset_to_rva_.Convert(ref.location);
-
-  // Subtraction underflow is okay
-  uint32_t code =
-      static_cast<uint32_t>(target_rva) - (static_cast<uint32_t>(loc_rva) + 4);
-  image_.write<uint32_t>(ref.location, code);
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/reloc_elf.cc b/native/zucchini/vendor/zucchini/reloc_elf.cc
deleted file mode 100644
index 9deaade..0000000
--- a/native/zucchini/vendor/zucchini/reloc_elf.cc
+++ /dev/null
@@ -1,163 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/reloc_elf.h"
-
-#include <algorithm>
-
-#include "base/logging.h"
-#include "components/zucchini/algorithm.h"
-
-namespace zucchini {
-
-/******** RelocReaderElf ********/
-
-RelocReaderElf::RelocReaderElf(
-    ConstBufferView image,
-    Bitness bitness,
-    const std::vector<SectionDimensionsElf>& reloc_section_dims,
-    uint32_t rel_type,
-    offset_t lo,
-    offset_t hi,
-    const AddressTranslator& translator)
-    : image_(image),
-      bitness_(bitness),
-      rel_type_(rel_type),
-      reloc_section_dimensions_(reloc_section_dims),
-      hi_(hi),
-      target_rva_to_offset_(translator) {
-  DCHECK(bitness_ == kBit32 || bitness_ == kBit64);
-
-  // Find the relocation section at or right before |lo|.
-  cur_section_dimensions_ = std::upper_bound(
-      reloc_section_dimensions_.begin(), reloc_section_dimensions_.end(), lo);
-  if (cur_section_dimensions_ != reloc_section_dimensions_.begin())
-    --cur_section_dimensions_;
-
-  // |lo| and |hi_| do not cut across a reloc reference (e.g.,
-  // Elf_Rel::r_offset), but may cut across a reloc struct (e.g. Elf_Rel)!
-  // GetNext() emits all reloc references in |[lo, hi_)|, but needs to examine
-  // the entire reloc struct for context. Knowing that |r_offset| is the first
-  // entry in a reloc struct, |cursor_| and |hi_| are adjusted by the following:
-  // - If |lo| is in a reloc section, then |cursor_| is chosen, as |lo| aligned
-  //   up to the next reloc struct, to exclude reloc struct that |lo| may cut
-  //   across.
-  // - If |hi_| is in a reloc section, then align it up, to include reloc struct
-  //   that |hi_| may cut across.
-  cursor_ =
-      base::checked_cast<offset_t>(cur_section_dimensions_->region.offset);
-  if (cursor_ < lo)
-    cursor_ +=
-        AlignCeil<offset_t>(lo - cursor_, cur_section_dimensions_->entry_size);
-
-  auto end_section = std::upper_bound(reloc_section_dimensions_.begin(),
-                                      reloc_section_dimensions_.end(), hi_);
-  if (end_section != reloc_section_dimensions_.begin()) {
-    --end_section;
-    if (hi_ - end_section->region.offset < end_section->region.size) {
-      offset_t end_region_offset =
-          base::checked_cast<offset_t>(end_section->region.offset);
-      hi_ = end_region_offset + AlignCeil<offset_t>(hi_ - end_region_offset,
-                                                    end_section->entry_size);
-    }
-  }
-}
-
-RelocReaderElf::~RelocReaderElf() = default;
-
-rva_t RelocReaderElf::GetRelocationTarget(elf::Elf32_Rel rel) const {
-  // The least significant byte of |rel.r_info| is the type. The other 3 bytes
-  // store the symbol, which we ignore.
-  uint32_t type = static_cast<uint32_t>(rel.r_info & 0xFF);
-  if (type == rel_type_)
-    return rel.r_offset;
-  return kInvalidRva;
-}
-
-rva_t RelocReaderElf::GetRelocationTarget(elf::Elf64_Rel rel) const {
-  // The least significant 4 bytes of |rel.r_info| is the type. The other 4
-  // bytes store the symbol, which we ignore.
-  uint32_t type = static_cast<uint32_t>(rel.r_info & 0xFFFFFFFF);
-  if (type == rel_type_) {
-    // Assume |rel.r_offset| fits within 32-bit integer.
-    if ((rel.r_offset & 0xFFFFFFFF) == rel.r_offset)
-      return static_cast<rva_t>(rel.r_offset);
-    // Otherwise output warning.
-    LOG(WARNING) << "Warning: Skipping r_offset whose value exceeds 32-bits.";
-  }
-  return kInvalidRva;
-}
-
-std::optional<Reference> RelocReaderElf::GetNext() {
-  offset_t cur_entry_size = cur_section_dimensions_->entry_size;
-  offset_t cur_section_dimensions_end =
-      base::checked_cast<offset_t>(cur_section_dimensions_->region.hi());
-
-  for (; cursor_ + cur_entry_size <= hi_; cursor_ += cur_entry_size) {
-    while (cursor_ >= cur_section_dimensions_end) {
-      ++cur_section_dimensions_;
-      if (cur_section_dimensions_ == reloc_section_dimensions_.end())
-        return std::nullopt;
-      cur_entry_size = cur_section_dimensions_->entry_size;
-      cursor_ =
-          base::checked_cast<offset_t>(cur_section_dimensions_->region.offset);
-      if (cursor_ + cur_entry_size > hi_)
-        return std::nullopt;
-      cur_section_dimensions_end =
-          base::checked_cast<offset_t>(cur_section_dimensions_->region.hi());
-    }
-    rva_t target_rva = kInvalidRva;
-    // TODO(huangs): Fix RELA sections: Need to process |r_addend|.
-    switch (bitness_) {
-      case kBit32:
-        target_rva = GetRelocationTarget(image_.read<elf::Elf32_Rel>(cursor_));
-        break;
-      case kBit64:
-        target_rva = GetRelocationTarget(image_.read<elf::Elf64_Rel>(cursor_));
-        break;
-    }
-    if (target_rva == kInvalidRva)
-      continue;
-    // TODO(huangs): Make the check more strict: The reference body should not
-    // straddle section boundary.
-    offset_t target = target_rva_to_offset_.Convert(target_rva);
-    if (target == kInvalidOffset)
-      continue;
-    // |target| will be used to obtain abs32 references, so we must ensure that
-    // it lies inside |image_|.
-    if (!image_.covers({target, WidthOf(bitness_)}))
-      continue;
-    offset_t location = cursor_;
-    cursor_ += cur_entry_size;
-    return Reference{location, target};
-  }
-  return std::nullopt;
-}
-
-/******** RelocWriterElf ********/
-
-RelocWriterElf::RelocWriterElf(MutableBufferView image,
-                               Bitness bitness,
-                               const AddressTranslator& translator)
-    : image_(image), bitness_(bitness), target_offset_to_rva_(translator) {
-  DCHECK(bitness_ == kBit32 || bitness_ == kBit64);
-}
-
-RelocWriterElf::~RelocWriterElf() = default;
-
-void RelocWriterElf::PutNext(Reference ref) {
-  switch (bitness_) {
-    case kBit32:
-      image_.modify<elf::Elf32_Rel>(ref.location).r_offset =
-          target_offset_to_rva_.Convert(ref.target);
-      break;
-    case kBit64:
-      image_.modify<elf::Elf64_Rel>(ref.location).r_offset =
-          target_offset_to_rva_.Convert(ref.target);
-      break;
-  }
-  // Leave |reloc.r_info| alone.
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/target_pool.cc b/native/zucchini/vendor/zucchini/target_pool.cc
deleted file mode 100644
index e15d0b9..0000000
--- a/native/zucchini/vendor/zucchini/target_pool.cc
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/target_pool.h"
-
-#include <algorithm>
-#include <iterator>
-#include <utility>
-
-#include "base/check.h"
-#include "components/zucchini/algorithm.h"
-#include "components/zucchini/equivalence_map.h"
-
-namespace zucchini {
-
-TargetPool::TargetPool() = default;
-
-TargetPool::TargetPool(std::deque<offset_t>&& targets) {
-  DCHECK(targets_.empty());
-  DCHECK(std::is_sorted(targets.begin(), targets.end()));
-  targets_ = std::move(targets);
-}
-
-TargetPool::TargetPool(TargetPool&&) = default;
-TargetPool::TargetPool(const TargetPool&) = default;
-TargetPool::~TargetPool() = default;
-
-void TargetPool::InsertTargets(const std::vector<offset_t>& targets) {
-  std::copy(targets.begin(), targets.end(), std::back_inserter(targets_));
-  SortAndUniquify(&targets_);
-}
-
-void TargetPool::InsertTargets(TargetSource* targets) {
-  for (auto target = targets->GetNext(); target.has_value();
-       target = targets->GetNext()) {
-    targets_.push_back(*target);
-  }
-  // InsertTargets() can be called many times (number of reference types for the
-  // pool) in succession. Calling SortAndUniquify() every time enables deduping
-  // to occur more often. This prioritizes peak memory reduction over running
-  // time.
-  SortAndUniquify(&targets_);
-}
-
-void TargetPool::InsertTargets(const std::vector<Reference>& references) {
-  // This can be called many times, so it's better to let std::back_inserter()
-  // manage |targets_| resize, instead of manually reserving space.
-  std::transform(references.begin(), references.end(),
-                 std::back_inserter(targets_),
-                 [](const Reference& ref) { return ref.target; });
-  SortAndUniquify(&targets_);
-}
-
-void TargetPool::InsertTargets(ReferenceReader&& references) {
-  for (auto ref = references.GetNext(); ref.has_value();
-       ref = references.GetNext()) {
-    targets_.push_back(ref->target);
-  }
-  SortAndUniquify(&targets_);
-}
-
-key_t TargetPool::KeyForOffset(offset_t offset) const {
-  auto pos = std::lower_bound(targets_.begin(), targets_.end(), offset);
-  DCHECK(pos != targets_.end() && *pos == offset);
-  return static_cast<offset_t>(pos - targets_.begin());
-}
-
-key_t TargetPool::KeyForNearestOffset(offset_t offset) const {
-  auto pos = std::lower_bound(targets_.begin(), targets_.end(), offset);
-  if (pos != targets_.begin()) {
-    // If distances are equal, prefer lower key.
-    if (pos == targets_.end() || *pos - offset >= offset - pos[-1])
-      --pos;
-  }
-  return static_cast<offset_t>(pos - targets_.begin());
-}
-
-void TargetPool::FilterAndProject(const OffsetMapper& offset_mapper) {
-  offset_mapper.ForwardProjectAll(&targets_);
-  std::sort(targets_.begin(), targets_.end());
-}
-
-}  // namespace zucchini
diff --git a/native/zucchini/vendor/zucchini/zucchini_apply.cc b/native/zucchini/vendor/zucchini/zucchini_apply.cc
deleted file mode 100644
index 76142e0..0000000
--- a/native/zucchini/vendor/zucchini/zucchini_apply.cc
+++ /dev/null
@@ -1,217 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/zucchini/zucchini_apply.h"
-
-#include <algorithm>
-#include <map>
-#include <memory>
-#include <utility>
-
-#include "base/logging.h"
-#include "base/numerics/safe_conversions.h"
-#include "components/zucchini/disassembler.h"
-#include "components/zucchini/element_detection.h"
-#include "components/zucchini/equivalence_map.h"
-#include "components/zucchini/image_index.h"
-
-namespace zucchini {
-
-bool ApplyEquivalenceAndExtraData(ConstBufferView old_image,
-                                  const PatchElementReader& patch_reader,
-                                  MutableBufferView new_image) {
-  EquivalenceSource equiv_source = patch_reader.GetEquivalenceSource();
-  ExtraDataSource extra_data_source = patch_reader.GetExtraDataSource();
-  MutableBufferView::iterator dst_it = new_image.begin();
-
-  for (auto equivalence = equiv_source.GetNext(); equivalence.has_value();
-       equivalence = equiv_source.GetNext()) {
-    MutableBufferView::iterator next_dst_it =
-        new_image.begin() + equivalence->dst_offset;
-    CHECK(next_dst_it >= dst_it);
-
-    offset_t gap = static_cast<offset_t>(next_dst_it - dst_it);
-    std::optional<ConstBufferView> extra_data = extra_data_source.GetNext(gap);
-    if (!extra_data) {
-      LOG(ERROR) << "Error reading extra_data";
-      return false;
-    }
-    // |extra_data| length is based on what was parsed from the patch so this
-    // copy should be valid.
-    dst_it = std::copy(extra_data->begin(), extra_data->end(), dst_it);
-    CHECK_EQ(dst_it, next_dst_it);
-    dst_it = std::copy_n(old_image.begin() + equivalence->src_offset,
-                         equivalence->length, dst_it);
-    CHECK_EQ(dst_it, next_dst_it + equivalence->length);
-  }
-  offset_t gap = static_cast<offset_t>(new_image.end() - dst_it);
-  std::optional<ConstBufferView> extra_data = extra_data_source.GetNext(gap);
-  if (!extra_data) {
-    LOG(ERROR) << "Error reading extra_data";
-    return false;
-  }
-  std::copy(extra_data->begin(), extra_data->end(), dst_it);
-  if (!equiv_source.Done() || !extra_data_source.Done()) {
-    LOG(ERROR) << "Found trailing equivalence and extra_data";
-    return false;
-  }
-  return true;
-}
-
-bool ApplyRawDelta(const PatchElementReader& patch_reader,
-                   MutableBufferView new_image) {
-  EquivalenceSource equiv_source = patch_reader.GetEquivalenceSource();
-  RawDeltaSource raw_delta_source = patch_reader.GetRawDeltaSource();
-  // Traverse |equiv_source| and |raw_delta_source| in lockstep.
-  auto equivalence = equiv_source.GetNext();
-  offset_t base_copy_offset = 0;
-  for (auto delta = raw_delta_source.GetNext(); delta.has_value();
-       delta = raw_delta_source.GetNext()) {
-    while (equivalence.has_value() &&
-           base_copy_offset + equivalence->length <= delta->copy_offset) {
-      base_copy_offset += equivalence->length;
-      equivalence = equiv_source.GetNext();
-    }
-    if (!equivalence.has_value()) {
-      LOG(ERROR) << "Error reading equivalences";
-      return false;
-    }
-    CHECK_GE(delta->copy_offset, base_copy_offset);
-    CHECK_LT(delta->copy_offset, base_copy_offset + equivalence->length);
-
-    // Invert byte diff.
-    new_image[equivalence->dst_offset - base_copy_offset +
-              delta->copy_offset] += delta->diff;
-  }
-  if (!raw_delta_source.Done()) {
-    LOG(ERROR) << "Found trailing raw_delta";
-    return false;
-  }
-  return true;
-}
-
-bool ApplyReferencesCorrection(ExecutableType exe_type,
-                               ConstBufferView old_image,
-                               const PatchElementReader& patch,
-                               MutableBufferView new_image) {
-  auto old_disasm = MakeDisassemblerOfType(old_image, exe_type);
-  auto new_disasm =
-      MakeDisassemblerOfType(ConstBufferView(new_image), exe_type);
-  if (!old_disasm || !new_disasm) {
-    LOG(ERROR) << "Failed to create Disassembler";
-    return false;
-  }
-  if (old_disasm->size() != old_image.size() ||
-      new_disasm->size() != new_image.size()) {
-    LOG(ERROR) << "Disassembler and element size mismatch";
-    return false;
-  }
-
-  ReferenceDeltaSource ref_delta_source = patch.GetReferenceDeltaSource();
-  std::map<PoolTag, std::vector<ReferenceGroup>> pool_groups;
-  for (const auto& ref_group : old_disasm->MakeReferenceGroups())
-    pool_groups[ref_group.pool_tag()].push_back(ref_group);
-
-  OffsetMapper offset_mapper(patch.GetEquivalenceSource(),
-                             base::checked_cast<offset_t>(old_image.size()),
-                             base::checked_cast<offset_t>(new_image.size()));
-
-  std::vector<ReferenceGroup> new_groups = new_disasm->MakeReferenceGroups();
-  for (const auto& pool_and_sub_groups : pool_groups) {
-    PoolTag pool_tag = pool_and_sub_groups.first;
-    const std::vector<ReferenceGroup>& sub_groups = pool_and_sub_groups.second;
-
-    TargetPool targets;
-    // Load "old" targets, then filter and map them to "new" targets.
-    for (ReferenceGroup group : sub_groups)
-      targets.InsertTargets(std::move(*group.GetReader(old_disasm.get())));
-    targets.FilterAndProject(offset_mapper);
-
-    // Load extra targets from patch.
-    TargetSource target_source = patch.GetExtraTargetSource(pool_tag);
-    targets.InsertTargets(&target_source);
-    if (!target_source.Done()) {
-      LOG(ERROR) << "Found trailing extra_targets";
-      return false;
-    }
-
-    // Correct all new references, and write results to |new_disasm|.
-    for (ReferenceGroup group : sub_groups) {
-      std::unique_ptr<ReferenceWriter> ref_writer =
-          new_groups[group.type_tag().value()].GetWriter(new_image,
-                                                         new_disasm.get());
-
-      EquivalenceSource equiv_source = patch.GetEquivalenceSource();
-      for (auto equivalence = equiv_source.GetNext(); equivalence.has_value();
-           equivalence = equiv_source.GetNext()) {
-        std::unique_ptr<ReferenceReader> ref_gen = group.GetReader(
-            equivalence->src_offset, equivalence->src_end(), old_disasm.get());
-        for (auto ref = ref_gen->GetNext(); ref.has_value();
-             ref = ref_gen->GetNext()) {
-          DCHECK_GE(ref->location, equivalence->src_offset);
-          DCHECK_LT(ref->location, equivalence->src_end());
-
-          offset_t projected_target =
-              offset_mapper.ExtendedForwardProject(ref->target);
-          offset_t expected_key = targets.KeyForNearestOffset(projected_target);
-          auto delta = ref_delta_source.GetNext();
-          if (!delta.has_value()) {
-            LOG(ERROR) << "Error reading reference_delta";
-            return false;
-          }
-          const key_t key = expected_key + delta.value();
-          if (!targets.KeyIsValid(key)) {
-            LOG(ERROR) << "Invalid reference_delta";
-            return false;
-          }
-          ref->target = targets.OffsetForKey(expected_key + delta.value());
-          ref->location =
-              ref->location - equivalence->src_offset + equivalence->dst_offset;
-          ref_writer->PutNext(*ref);
-        }
-      }
-    }
-  }
-  if (!ref_delta_source.Done()) {
-    LOG(ERROR) << "Found trailing ref_delta_source";
-    return false;
-  }
-  return true;
-}
-
-bool ApplyElement(ExecutableType exe_type,
-                  ConstBufferView old_image,
-                  const PatchElementReader& patch_reader,
-                  MutableBufferView new_image) {
-  return ApplyEquivalenceAndExtraData(old_image, patch_reader, new_image) &&
-         ApplyRawDelta(patch_reader, new_image) &&
-         ApplyReferencesCorrection(exe_type, old_image, patch_reader,
-                                   new_image);
-}
-
-/******** Exported Functions ********/
-
-status::Code ApplyBuffer(ConstBufferView old_image,
-                         const EnsemblePatchReader& patch_reader,
-                         MutableBufferView new_image) {
-  if (!patch_reader.CheckOldFile(old_image)) {
-    LOG(ERROR) << "Invalid old_image.";
-    return status::kStatusInvalidOldImage;
-  }
-
-  for (const auto& element_patch : patch_reader.elements()) {
-    ElementMatch match = element_patch.element_match();
-    if (!ApplyElement(match.exe_type(), old_image[match.old_element.region()],
-                      element_patch, new_image[match.new_element.region()]))
-      return status::kStatusFatal;
-  }
-
-  if (!patch_reader.CheckNewFile(ConstBufferView(new_image))) {
-    LOG(ERROR) << "Invalid new_image.";
-    return status::kStatusInvalidNewImage;
-  }
-  return status::kStatusSuccess;
-}
-
-}  // namespace zucchini
diff --git a/pyproject.toml b/pyproject.toml
index 14b315f..16a8a17 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -13,11 +13,6 @@ license-files = [
     "LICENSE",
     "src/puffin/LICENSE",
     "native/lz4/LICENSE",
-    "native/zucchini/vendor/zucchini/LICENSE",
-    "native/zucchini/vendor/libchrome/NOTICE",
-    "native/zucchini/vendor/libchrome/base/third_party/icu/LICENSE",
-    "native/zucchini/vendor/libchrome/base/third_party/nspr/LICENSE",
-    "native/zucchini/vendor/libchrome/base/third_party/nspr/MPL-1.1.txt",
 ]
 authors = [
     { name = "Kartik Sharma", email = "kartik.sharma522@gmail.com" },
diff --git a/src/bsdiff.rs b/src/bsdiff.rs
index 39bb0c7..ecdd85a 100644
--- a/src/bsdiff.rs
+++ b/src/bsdiff.rs
@@ -20,6 +20,8 @@ enum Algorithm {
     Brotli,
 }
 
+type ParsedPatch = (i64, Vec<u8>, Vec<u8>, Vec<u8>);
+
 fn algorithm_from_byte(value: u8) -> Result<Algorithm> {
     match value {
         0 => Ok(Algorithm::None),
@@ -34,11 +36,7 @@ fn algorithm_from_byte(value: u8) -> Result<Algorithm> {
 #[inline]
 fn offtin(buf: [u8; 8]) -> i64 {
     let value = i64::from_le_bytes(buf);
-    if value & (1 << 63) == 0 {
-        value
-    } else {
-        -(value & !(1 << 63))
-    }
+    if value & (1 << 63) == 0 { value } else { -(value & !(1 << 63)) }
 }
 
 fn decompress_bz2(data: &[u8]) -> Result<Vec<u8>> {
@@ -65,7 +63,7 @@ fn decompress(algorithm: Algorithm, data: &[u8]) -> Result<Vec<u8>> {
 
 /// Parses a BSDIFF40/BSDF2 patch header and returns the decompressed
 /// `(new_size, control, diff, extra)` streams.
-pub fn parse_header(patch: &[u8]) -> Result<(i64, Vec<u8>, Vec<u8>, Vec<u8>)> {
+pub fn parse_header(patch: &[u8]) -> Result<ParsedPatch> {
     ensure!(patch.len() >= 32, "Patch data too short");
 
     let magic = &patch[0..8];
@@ -88,8 +86,7 @@ pub fn parse_header(patch: &[u8]) -> Result<(i64, Vec<u8>, Vec<u8>, Vec<u8>)> {
         control_length >= 0 && diff_length >= 0 && new_size >= 0,
         "Negative length in patch header"
     );
-    let (control_length, diff_length) =
-        (control_length as usize, diff_length as usize);
+    let (control_length, diff_length) = (control_length as usize, diff_length as usize);
 
     let control_end = 32usize
         .checked_add(control_length)
@@ -101,10 +98,7 @@ pub fn parse_header(patch: &[u8]) -> Result<(i64, Vec<u8>, Vec<u8>, Vec<u8>)> {
     ensure!(diff_end <= patch.len(), "Diff stream exceeds patch bounds");
 
     let control = decompress(control_algorithm, &patch[32..control_end])?;
-    ensure!(
-        control.len() % 24 == 0,
-        "Invalid control data length (not multiple of 24)"
-    );
+    ensure!(control.len() % 24 == 0, "Invalid control data length (not multiple of 24)");
     let diff = decompress(diff_algorithm, &patch[control_end..diff_end])?;
     let extra = decompress(extra_algorithm, &patch[diff_end..])?;
     Ok((new_size, control, diff, extra))
diff --git a/src/lib.rs b/src/lib.rs
index 7e9c47e..29b66b1 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -990,12 +990,9 @@ impl Task<'_> {
         self.cancellation_token.check()?;
         let patch = decode_zucchini_patch(compressed_patch, self.cancellation_token)?;
         self.cancellation_token.check()?;
-        let output = zucchini::apply_with_cancel(
-            &source,
-            &patch,
-            expected_output_len,
-            || self.cancellation_token.is_cancelled(),
-        )
+        let output = zucchini::apply_with_cancel(&source, &patch, expected_output_len, || {
+            self.cancellation_token.is_cancelled()
+        })
         .map_err(|error| {
             // Preserve cooperative cancellation as a typed error so the
             // extraction layer can unwind cleanly; anything else is a patch
diff --git a/src/zucchini.rs b/src/zucchini.rs
index 4a28b58..59fac48 100644
--- a/src/zucchini.rs
+++ b/src/zucchini.rs
@@ -1,70 +1,16 @@
-use std::error;
-use std::fmt;
-
 use crate::zucchini_pure;
 
+pub use crate::zucchini_pure::{Error, Result, Status};
+
 /// Exclusive upper bound for buffers represented by Zucchini offsets.
 pub const OFFSET_BOUND: usize = zucchini_pure::OFFSET_BOUND;
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum Status {
-    InvalidArgument,
-    InvalidPatch,
-    UnsupportedElement,
-    WrongOutputSize,
-    ApplyError,
-    AllocationFailure,
-    UnsupportedTarget,
-    Cancelled,
-    Unknown(i32),
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct Error {
-    status: Status,
-    message: String,
-}
-
-impl Error {
-    pub fn status(&self) -> Status {
-        self.status
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        formatter.write_str(&self.message)
-    }
-}
-
-impl error::Error for Error {}
-
-pub type Result<T> = std::result::Result<T, Error>;
-
-fn map_status(status: zucchini_pure::Status) -> Status {
-    match status {
-        zucchini_pure::Status::InvalidArgument => Status::InvalidArgument,
-        zucchini_pure::Status::InvalidPatch => Status::InvalidPatch,
-        zucchini_pure::Status::UnsupportedElement => Status::UnsupportedElement,
-        zucchini_pure::Status::WrongOutputSize => Status::WrongOutputSize,
-        zucchini_pure::Status::ApplyError => Status::ApplyError,
-        zucchini_pure::Status::AllocationFailure => Status::AllocationFailure,
-        zucchini_pure::Status::UnsupportedTarget => Status::UnsupportedTarget,
-        zucchini_pure::Status::Cancelled => Status::Cancelled,
-        zucchini_pure::Status::Unknown(code) => Status::Unknown(code),
-    }
-}
-
-fn map_error(error: zucchini_pure::Error) -> Error {
-    Error { status: map_status(error.status()), message: error.to_string() }
-}
-
 /// Applies a Zucchini patch into a newly allocated, exact-size output buffer.
 ///
 /// This is now backed entirely by the pure-Rust implementation in
 /// `zucchini_pure`; the vendored C++ Zucchini is no longer required.
 pub fn apply(old: &[u8], patch: &[u8], output_size: usize) -> Result<Vec<u8>> {
-    zucchini_pure::apply(old, patch, output_size).map_err(map_error)
+    zucchini_pure::apply(old, patch, output_size)
 }
 
 /// Same as [`apply`], but cooperatively stops when `cancelled` returns true.
@@ -74,87 +20,7 @@ pub fn apply_with_cancel<F: Fn() -> bool>(
     output_size: usize,
     cancelled: F,
 ) -> Result<Vec<u8>> {
-    zucchini_pure::apply_with_cancel(old, patch, output_size, cancelled).map_err(map_error)
-}
-
-/// The vendored C++ implementation, retained only for differential testing when
-/// `OTADUMP_NATIVE_ZUCCHINI=1` selects it at build time.
-#[cfg(otadump_native_zucchini)]
-pub fn apply_native(old: &[u8], patch: &[u8], output_size: usize) -> Result<Vec<u8>> {
-    use std::ffi::{CStr, c_char};
-
-    #[repr(C)]
-    struct NativeResult {
-        status: i32,
-        error: *const c_char,
-    }
-
-    unsafe extern "C" {
-        fn otadump_zucchini_apply(
-            old_data: *const u8,
-            old_size: usize,
-            patch_data: *const u8,
-            patch_size: usize,
-            new_data: *mut u8,
-            new_size: usize,
-        ) -> NativeResult;
-    }
-
-    if old.len() >= OFFSET_BOUND || output_size >= OFFSET_BOUND {
-        return Err(Error {
-            status: Status::InvalidArgument,
-            message: "image exceeds Zucchini offset bound".into(),
-        });
-    }
-    if patch.len() >= OFFSET_BOUND {
-        return Err(Error {
-            status: Status::InvalidArgument,
-            message: "patch exceeds Zucchini offset bound".into(),
-        });
-    }
-
-    let mut output = Vec::new();
-    output.try_reserve_exact(output_size).map_err(|error| Error {
-        status: Status::AllocationFailure,
-        message: format!("unable to allocate Zucchini output: {error}"),
-    })?;
-    output.resize(output_size, 0);
-
-    // SAFETY: The slices remain alive for the call. `output` is a separate
-    // owned allocation and cannot overlap either borrowed input.
-    let result = unsafe {
-        otadump_zucchini_apply(
-            old.as_ptr(),
-            old.len(),
-            patch.as_ptr(),
-            patch.len(),
-            output.as_mut_ptr(),
-            output.len(),
-        )
-    };
-    if result.status == 0 {
-        return Ok(output);
-    }
-
-    let message = if result.error.is_null() {
-        format!("Zucchini failed with status {}", result.status)
-    } else {
-        // SAFETY: Native errors point to static NUL-terminated strings.
-        unsafe { CStr::from_ptr(result.error) }.to_string_lossy().into_owned()
-    };
-    Err(Error { status: native_status(result.status), message })
-}
-
-#[cfg(otadump_native_zucchini)]
-fn native_status(status: i32) -> Status {
-    match status {
-        1 => Status::InvalidArgument,
-        2 => Status::InvalidPatch,
-        3 => Status::UnsupportedElement,
-        4 => Status::WrongOutputSize,
-        5 => Status::ApplyError,
-        status => Status::Unknown(status),
-    }
+    zucchini_pure::apply_with_cancel(old, patch, output_size, cancelled)
 }
 
 #[cfg(test)]
diff --git a/src/zucchini_pure/arm.rs b/src/zucchini_pure/arm.rs
index 52b8c54..b2b6c70 100644
--- a/src/zucchini_pure/arm.rs
+++ b/src/zucchini_pure/arm.rs
@@ -66,11 +66,7 @@ pub fn store_thumb2_code32(image: &mut [u8], offset: u32, code: u32) {
 }
 
 pub fn get_thumb2_instruction_size(code16: u16) -> u32 {
-    if (code16 & 0xF000) == 0xF000 || (code16 & 0xF800) == 0xE800 {
-        4
-    } else {
-        2
-    }
+    if (code16 & 0xF000) == 0xF000 || (code16 & 0xF800) == 0xE800 { 4 } else { 2 }
 }
 
 /// Mirrors `AArch32Rel32Translator::DecodeA24`.
@@ -329,11 +325,7 @@ pub fn encode_t24(disp: i32, code32: &mut u32) -> bool {
         let i1 = bit(disp as u32, 23);
         let s = bit(disp as u32, 24);
         t &= 0xF800_D000;
-        t |= (s << 26)
-            | (imm10 << 16)
-            | ((i1 ^ s ^ 1) << 13)
-            | ((i2 ^ s ^ 1) << 11)
-            | imm11;
+        t |= (s << 26) | (imm10 << 16) | ((i1 ^ s ^ 1) << 13) | ((i2 ^ s ^ 1) << 11) | imm11;
         *code32 = t;
         return true;
     }
diff --git a/src/zucchini_pure/crc32.rs b/src/zucchini_pure/crc32.rs
index 5197852..859f6fa 100644
--- a/src/zucchini_pure/crc32.rs
+++ b/src/zucchini_pure/crc32.rs
@@ -27,24 +27,15 @@ pub const CRC_POLL_CHUNK: usize = 1 << 20;
 
 /// Same as [`calculate_crc32`], but polls `cancelled` between chunks and
 /// returns `Status::Cancelled` instead of running to completion.
-pub fn calculate_crc32_cancel(
-    data: &[u8],
-    cancelled: &dyn Fn() -> bool,
-) -> super::Result<u32> {
+pub fn calculate_crc32_cancel(data: &[u8], cancelled: &dyn Fn() -> bool) -> super::Result<u32> {
     if cancelled() {
-        return Err(super::Error::new(
-            super::Status::Cancelled,
-            "Zucchini apply cancelled",
-        ));
+        return Err(super::Error::new(super::Status::Cancelled, "Zucchini apply cancelled"));
     }
     let table = make_crc32_table();
     let mut ret = 0xFFFF_FFFFu32;
     for chunk in data.chunks(CRC_POLL_CHUNK) {
         if cancelled() {
-            return Err(super::Error::new(
-                super::Status::Cancelled,
-                "Zucchini apply cancelled",
-            ));
+            return Err(super::Error::new(super::Status::Cancelled, "Zucchini apply cancelled"));
         }
         for &byte in chunk {
             ret = table[((ret ^ byte as u32) & 0xFF) as usize] ^ (ret >> 8);
diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
index 140b133..27bdc2f 100644
--- a/src/zucchini_pure/dex.rs
+++ b/src/zucchini_pure/dex.rs
@@ -2,8 +2,10 @@
 
 use std::collections::BTreeMap;
 
-use super::bytes::{align_ceil, read_i16, read_i32, read_i8, read_u16, read_u32, write_u16, write_u32};
-use super::{Disassembler, GroupTraits, Reference, Result, K_INVALID_OFFSET, OFFSET_BOUND};
+use super::bytes::{
+    align_ceil, read_i8, read_i16, read_i32, read_u16, read_u32, write_u16, write_u32,
+};
+use super::{Disassembler, GroupTraits, K_INVALID_OFFSET, OFFSET_BOUND, Reference, Result};
 
 const HEADER_SIZE: usize = 112;
 const CODE_ITEM_HEADER: usize = 16;
@@ -133,7 +135,11 @@ fn find_instruction(opcode: u8) -> Option<Bytecode> {
         .find(|(start, _, _, variant)| {
             opcode >= u16::from(*start) && opcode < u16::from(*start) + u16::from(*variant)
         })
-        .map(|(start, layout, format, _)| Bytecode { opcode: *start, layout: *layout, format: *format })
+        .map(|(start, layout, format, _)| Bytecode {
+            opcode: *start,
+            layout: *layout,
+            format: *format,
+        })
 }
 
 #[derive(Clone, Debug)]
@@ -226,8 +232,7 @@ impl DexDisassembler {
         let code_map = get(T_CODE_ITEM);
 
         let type_list_offsets = parse_item_offsets(image, type_list_map, 2)?;
-        let annotation_set_ref_list_offsets =
-            parse_item_offsets(image, annotation_set_ref_map, 4)?;
+        let annotation_set_ref_list_offsets = parse_item_offsets(image, annotation_set_ref_map, 4)?;
         let annotation_set_offsets = parse_item_offsets(image, annotation_set_map, 4)?;
         let (
             annotations_directory_item_offsets,
@@ -299,7 +304,9 @@ fn read_dex_header(image: &[u8]) -> Option<(u32, u32)> {
     }
     let file_size = read_u32(image, 32)?;
     let map_off = read_u32(image, 52)?;
-    if file_size > image.len() as u32 || file_size < HEADER_SIZE as u32 || map_off < HEADER_SIZE as u32
+    if file_size > image.len() as u32
+        || file_size < HEADER_SIZE as u32
+        || map_off < HEADER_SIZE as u32
     {
         return None;
     }
@@ -332,14 +339,8 @@ pub(crate) fn read_map_item(image: &[u8], desired: u16) -> Option<MapItem> {
 /// Mirrors the FFI's `ValidateDexWriterWidths`: the narrow fixed-size lists must
 /// fit a 16-bit writer.
 pub(crate) fn narrow_writer_widths_ok(image: &[u8]) -> bool {
-    const NARROW_TYPES: [u16; 6] = [
-        T_TYPE_ID,
-        T_PROTO_ID,
-        T_FIELD_ID,
-        T_METHOD_ID,
-        T_CALL_SITE_ID,
-        T_METHOD_HANDLE,
-    ];
+    const NARROW_TYPES: [u16; 6] =
+        [T_TYPE_ID, T_PROTO_ID, T_FIELD_ID, T_METHOD_ID, T_CALL_SITE_ID, T_METHOD_HANDLE];
     for kind in NARROW_TYPES {
         if let Some(item) = read_map_item(image, kind) {
             if item.size > u32::from(u16::MAX) + 1 {
@@ -355,11 +356,7 @@ pub(crate) fn string_ids(image: &[u8]) -> Option<MapItem> {
     read_map_item(image, T_STRING_ID)
 }
 
-fn parse_item_offsets(
-    image: &[u8],
-    map_item: MapItem,
-    item_width: usize,
-) -> Option<Vec<u32>> {
+fn parse_item_offsets(image: &[u8], map_item: MapItem, item_width: usize) -> Option<Vec<u32>> {
     if !covers_array(image, map_item.offset as usize, map_item.size as usize, 4) {
         return None;
     }
@@ -401,17 +398,18 @@ fn parse_annotations_directory_items(
     directory_offsets.try_reserve(map_item.size as usize).ok()?;
     let mut pos = map_item.offset as usize;
 
-    let parse_list = |pos: &mut usize, count: u32, width: usize, out: &mut Vec<u32>| -> Option<()> {
-        if (image.len() - *pos) / width < count as usize {
-            return None;
-        }
-        out.try_reserve(count as usize).ok()?;
-        for _ in 0..count {
-            out.push(*pos as u32);
-            *pos += width;
-        }
-        Some(())
-    };
+    let parse_list =
+        |pos: &mut usize, count: u32, width: usize, out: &mut Vec<u32>| -> Option<()> {
+            if (image.len() - *pos) / width < count as usize {
+                return None;
+            }
+            out.try_reserve(count as usize).ok()?;
+            for _ in 0..count {
+                out.push(*pos as u32);
+                *pos += width;
+            }
+            Some(())
+        };
 
     for _ in 0..map_item.size {
         let aligned = align_ceil(pos as u64, 4) as usize;
@@ -565,12 +563,12 @@ fn skip_leb128(image: &[u8], pos: &mut usize) -> bool {
 
 fn build_groups() -> Vec<GroupTraits> {
     const WIDTHS: [u32; 42] = [
-        4, 4, 4, 4, 4, 2, 4, 4, 2, 2, 2, 4, 4, 2, 2, 2, 2, 2, 2, 4, 2, 2, 4, 4, 2, 2, 4, 4, 4,
-        4, 4, 4, 4, 4, 1, 2, 4, 4, 4, 4, 4, 4,
+        4, 4, 4, 4, 4, 2, 4, 4, 2, 2, 2, 4, 4, 2, 2, 2, 2, 2, 2, 4, 2, 2, 4, 4, 2, 2, 4, 4, 4, 4,
+        4, 4, 4, 4, 1, 2, 4, 4, 4, 4, 4, 4,
     ];
     const POOLS: [u8; 42] = [
-        0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 6, 7, 7, 8,
-        9, 9, 9, 9, 10, 11, 11, 11, 12, 13, 14, 15, 16,
+        0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 6, 7, 7, 8, 9,
+        9, 9, 9, 10, 11, 11, 11, 12, 13, 14, 15, 16,
     ];
     (0..42)
         .map(|index| GroupTraits {
@@ -619,13 +617,7 @@ enum CodeFilter {
     Rel32,
 }
 
-fn read_target_index(
-    image: &[u8],
-    map: MapItem,
-    item_size: u32,
-    location: u32,
-    width: u8,
-) -> u32 {
+fn read_target_index(image: &[u8], map: MapItem, item_size: u32, location: u32, width: u8) -> u32 {
     let unsafe_idx = if width == 2 {
         u32::from(read_u16(image, location as usize).unwrap_or(0))
     } else {
@@ -825,8 +817,7 @@ fn parse_instructions(image: &[u8], base_offset: u32) -> Result<Vec<InstructionV
             // The native bound is relative to the remaining instruction bytes
             // from the current instruction, not the whole code item.
             let remaining_units = (insns_end - pos) as u32 / 2;
-            if payload_rel < i32::from(instruction.layout)
-                || payload_rel as u32 >= remaining_units
+            if payload_rel < i32::from(instruction.layout) || payload_rel as u32 >= remaining_units
             {
                 break;
             }
@@ -865,9 +856,7 @@ fn filter_location(filter: CodeFilter, value: InstructionValue) -> Option<u32> {
         CodeFilter::Field if format_c && matches!(value.opcode, 0x52 | 0x60) => {
             value.instr_offset + 2
         }
-        CodeFilter::Method
-            if format_c && matches!(value.opcode, 0x6E | 0x74 | 0xFA | 0xFB) =>
-        {
+        CodeFilter::Method if format_c && matches!(value.opcode, 0x6E | 0x74 | 0xFA | 0xFB) => {
             value.instr_offset + 2
         }
         CodeFilter::Rel8 if format_t && value.opcode == 0x28 => value.instr_offset + 1,
@@ -898,7 +887,8 @@ fn run_instr_mapper(mapper: InstrMapper, image: &[u8], location: u32) -> u32 {
         InstrMapper::RelCode32 => {
             let delta = read_i32(image, location as usize).unwrap_or(0);
             let target = i64::from(location) + i64::from(delta - 1) * 2;
-            if !(0..=u32::MAX as i64).contains(&target) || target >= i64::from(OFFSET_BOUND as u32) {
+            if !(0..=u32::MAX as i64).contains(&target) || target >= i64::from(OFFSET_BOUND as u32)
+            {
                 K_INVALID_OFFSET
             } else {
                 target as u32
@@ -1025,16 +1015,10 @@ impl Disassembler for DexDisassembler {
         // every index-based mapper (e.g. annotations-directory ids are 32-bit),
         // so derive it instead of hardcoding per group.
         let width = self.groups[group].width as u8;
-        let string_index = |width: u8| ItemMapper::TargetIndex {
-            map: self.string_map,
-            item_size: 4,
-            width,
-        };
-        let type_index = |width: u8| ItemMapper::TargetIndex {
-            map: self.type_map,
-            item_size: 4,
-            width,
-        };
+        let string_index =
+            |width: u8| ItemMapper::TargetIndex { map: self.string_map, item_size: 4, width };
+        let type_index =
+            |width: u8| ItemMapper::TargetIndex { map: self.type_map, item_size: 4, width };
         let proto_index = ItemMapper::TargetIndex { map: self.proto_map, item_size: 12, width };
         match group {
             0 => item_reader(image, lo, hi, self.type_map, 4, 0, string_index(width), false),
@@ -1191,7 +1175,9 @@ impl Disassembler for DexDisassembler {
                 CodeFilter::MethodHandle,
                 InstrMapper::TargetIndex { map: self.method_handle_map, item_size: 8, width },
             ),
-            26 => item_reader(image, lo, hi, self.proto_map, 12, 8, ItemMapper::TargetOffset32, false),
+            26 => {
+                item_reader(image, lo, hi, self.proto_map, 12, 8, ItemMapper::TargetOffset32, false)
+            }
             27 => item_reader(
                 image,
                 lo,
@@ -1282,7 +1268,9 @@ impl Disassembler for DexDisassembler {
                 CodeFilter::Rel32,
                 InstrMapper::RelCode32,
             ),
-            37 => item_reader(image, lo, hi, self.string_map, 4, 0, ItemMapper::TargetOffset32, false),
+            37 => {
+                item_reader(image, lo, hi, self.string_map, 4, 0, ItemMapper::TargetOffset32, false)
+            }
             38 => cached_item_list_reader(
                 image,
                 lo,
diff --git a/src/zucchini_pure/elf.rs b/src/zucchini_pure/elf.rs
index 5f9ee61..ba0c9fa 100644
--- a/src/zucchini_pure/elf.rs
+++ b/src/zucchini_pure/elf.rs
@@ -7,7 +7,7 @@ use super::bytes::{
     range_is_bounded, read_i32, read_u16, read_u32, read_u64, write_u16, write_u32, write_u64,
 };
 use super::{
-    Disassembler, GroupTraits, Reference, Result, K_INVALID_OFFSET, K_INVALID_RVA, OFFSET_BOUND,
+    Disassembler, GroupTraits, K_INVALID_OFFSET, K_INVALID_RVA, OFFSET_BOUND, Reference, Result,
 };
 
 const K_RVA_BOUND: u32 = 0x7FFF_FFFF;
@@ -247,11 +247,8 @@ impl AddressTranslator {
             offset_bound = offset_bound.max(unit.offset_end());
             rva_bound = rva_bound.max(unit.rva_end());
         }
-        if !range_is_bounded(
-            u64::from(offset_bound),
-            u64::from(rva_bound),
-            u64::from(K_RVA_BOUND),
-        ) {
+        if !range_is_bounded(u64::from(offset_bound), u64::from(rva_bound), u64::from(K_RVA_BOUND))
+        {
             return false;
         }
 
@@ -576,17 +573,13 @@ impl ElfDisassembler {
         let width = self.kind.va_width();
         let mut gaps = Vec::new();
         gaps.try_reserve(self.abs32_locations.len().saturating_add(1)).ok()?;
-        let mut current = self
-            .abs32_locations
-            .partition_point(|location| *location < region_start);
+        let mut current = self.abs32_locations.partition_point(|location| *location < region_start);
         let mut cur_lo = region_start;
         if current > 0 {
             let previous = self.abs32_locations[current - 1];
             cur_lo = cur_lo.max(previous.saturating_add(width));
         }
-        while current < self.abs32_locations.len()
-            && self.abs32_locations[current] < region_end
-        {
+        while current < self.abs32_locations.len() && self.abs32_locations[current] < region_end {
             let hi = self.abs32_locations[current];
             if hi > cur_lo {
                 gaps.push((cur_lo as usize, hi as usize));
@@ -613,15 +606,16 @@ impl ElfDisassembler {
         let bitness = self.kind.bitness();
         let rel_type = self.kind.rel_type();
 
-        let mut current = self
-            .reloc_sections
-            .partition_point(|section| section.offset <= lo);
+        let mut current = self.reloc_sections.partition_point(|section| section.offset <= lo);
         if current > 0 {
             current -= 1;
         }
         let mut cursor = self.reloc_sections[current].offset;
         if cursor < lo {
-            cursor += align_ceil(u64::from(lo - cursor), u64::from(self.reloc_sections[current].entry_size)) as u32;
+            cursor += align_ceil(
+                u64::from(lo - cursor),
+                u64::from(self.reloc_sections[current].entry_size),
+            ) as u32;
         }
 
         let mut hi = hi;
@@ -667,11 +661,8 @@ impl ElfDisassembler {
                     read_u64(image, cursor as usize + 8).unwrap_or(0),
                 )
             };
-            let rel_type_value = if bitness == 4 {
-                (r_info & 0xFF) as u32
-            } else {
-                (r_info & 0xFFFF_FFFF) as u32
-            };
+            let rel_type_value =
+                if bitness == 4 { (r_info & 0xFF) as u32 } else { (r_info & 0xFFFF_FFFF) as u32 };
             if rel_type_value == rel_type {
                 let valid_r_offset =
                     bitness == 4 || (r_offset as u64 & 0xFFFF_FFFF) == r_offset as u64;
@@ -945,10 +936,7 @@ fn remove_overlapping(width: u32, locations: &mut Vec<u32>) {
 
 /// Parses the ELF header, section table, program table, and derives the
 /// `offset_bound` estimate. Mirrors `DisassemblerElf::ParseHeader`.
-fn parse_elf_header(
-    kind: ElfKind,
-    image: &[u8],
-) -> Option<(Vec<SectionHeader>, u32)> {
+fn parse_elf_header(kind: ElfKind, image: &[u8]) -> Option<(Vec<SectionHeader>, u32)> {
     if u64::from(kind.class()) != 0 {
         // QuickDetect checks.
         if image.len() < 16 || &image[..4] != b"\x7FELF" {
@@ -973,9 +961,23 @@ fn parse_elf_header(
     }
 
     let (e_shoff, e_phoff, e_shnum, e_phnum, e_shstrndx, e_phentsize) = if kind.class() == 2 {
-        (read_u64(image, 40)?, read_u64(image, 32)?, read_u16(image, 60)?, read_u16(image, 56)?, read_u16(image, 62)?, read_u16(image, 54)?)
+        (
+            read_u64(image, 40)?,
+            read_u64(image, 32)?,
+            read_u16(image, 60)?,
+            read_u16(image, 56)?,
+            read_u16(image, 62)?,
+            read_u16(image, 54)?,
+        )
     } else {
-        (u64::from(read_u32(image, 32)?), u64::from(read_u32(image, 28)?), read_u16(image, 48)?, read_u16(image, 44)?, read_u16(image, 50)?, read_u16(image, 42)?)
+        (
+            u64::from(read_u32(image, 32)?),
+            u64::from(read_u32(image, 28)?),
+            read_u16(image, 48)?,
+            read_u16(image, 44)?,
+            read_u16(image, 50)?,
+            read_u16(image, 42)?,
+        )
     };
     if e_phentsize != kind.phdr_size() {
         // Not part of QuickDetect, but the array read would fail anyway.
@@ -1215,13 +1217,7 @@ fn fetch_and_read_a64(
     }
 }
 
-fn write_arm32(
-    image: &mut [u8],
-    addr_type: usize,
-    location: u32,
-    instr_rva: u32,
-    target_rva: u32,
-) {
+fn write_arm32(image: &mut [u8], addr_type: usize, location: u32, instr_rva: u32, target_rva: u32) {
     match addr_type {
         0 => {
             let mut code = arm::fetch_arm_code32(image, location);
diff --git a/src/zucchini_pure/engine.rs b/src/zucchini_pure/engine.rs
index 0a0d957..3c4de71 100644
--- a/src/zucchini_pure/engine.rs
+++ b/src/zucchini_pure/engine.rs
@@ -3,15 +3,15 @@
 
 use std::collections::BTreeMap;
 
-use super::bytes::{range_is_bounded, range_covers};
+use super::bytes::{range_covers, range_is_bounded};
 use super::dex;
 use super::patch::{
-    Equivalence, PatchElement, EXE_TYPE_DEX, EXE_TYPE_ELF_AARCH32, EXE_TYPE_ELF_AARCH64,
-    EXE_TYPE_ELF_X64, EXE_TYPE_ELF_X86, EXE_TYPE_NOOP,
+    EXE_TYPE_DEX, EXE_TYPE_ELF_AARCH32, EXE_TYPE_ELF_AARCH64, EXE_TYPE_ELF_X64, EXE_TYPE_ELF_X86,
+    EXE_TYPE_NOOP, Equivalence, PatchElement,
 };
 use super::{
-    is_android_executable, make_disassembler, Disassembler, Error, GroupTraits, Result, Status,
-    K_INVALID_OFFSET, OFFSET_BOUND,
+    Disassembler, Error, GroupTraits, K_INVALID_OFFSET, OFFSET_BOUND, Result, Status,
+    is_android_executable, make_disassembler,
 };
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -249,9 +249,9 @@ fn validate_reference_boundaries(
                 {
                     return Ok(false);
                 }
-                let projected = equivalence.dst_offset.wrapping_add(
-                    reference.location.wrapping_sub(equivalence.src_offset),
-                );
+                let projected = equivalence
+                    .dst_offset
+                    .wrapping_add(reference.location.wrapping_sub(equivalence.src_offset));
                 if projected > new_size || writer_width > new_size - projected {
                     return Ok(false);
                 }
@@ -279,11 +279,8 @@ fn validate_dex_reference_targets(
     }
 
     let mut deltas = element.reference_deltas.iter();
-    let mapper = OffsetMapper::new(
-        &element.equivalences,
-        old_disasm.size(),
-        new_image.len() as u32,
-    )?;
+    let mapper =
+        OffsetMapper::new(&element.equivalences, old_disasm.size(), new_image.len() as u32)?;
 
     for (pool_tag, sub_groups) in &pools {
         check_not_cancelled(cancelled)?;
@@ -394,9 +391,7 @@ fn apply_equivalence_and_extra_data(
 }
 
 fn take_extra<'a>(extra: &'a [u8], cursor: &mut usize, size: usize) -> Result<&'a [u8]> {
-    let end = cursor
-        .checked_add(size)
-        .ok_or_else(|| apply_error("extra data length overflow"))?;
+    let end = cursor.checked_add(size).ok_or_else(|| apply_error("extra data length overflow"))?;
     let slice = extra.get(*cursor..end).ok_or_else(|| apply_error("extra data exhausted"))?;
     *cursor = end;
     Ok(slice)
@@ -473,11 +468,8 @@ fn apply_references_correction(
 
     let old_groups = old_disasm.groups();
     let new_groups = new_disasm.groups();
-    let mapper = OffsetMapper::new(
-        &element.equivalences,
-        old_image.len() as u32,
-        new_image.len() as u32,
-    )?;
+    let mapper =
+        OffsetMapper::new(&element.equivalences, old_image.len() as u32, new_image.len() as u32)?;
 
     let mut pools: BTreeMap<u8, Vec<usize>> = BTreeMap::new();
     for (index, group) in old_groups.iter().enumerate() {
@@ -567,9 +559,8 @@ impl OffsetMapper {
     fn extended_forward_project(&self, offset: u32) -> u32 {
         if offset < self.old_image_size {
             // First equivalence with `src_offset > offset`.
-            let pos = self
-                .equivalences
-                .partition_point(|equivalence| equivalence.src_offset <= offset);
+            let pos =
+                self.equivalences.partition_point(|equivalence| equivalence.src_offset <= offset);
             let mut chosen = pos;
             if pos != 0 {
                 let back = self.equivalences[pos - 1];
@@ -598,8 +589,7 @@ impl OffsetMapper {
             {
                 current += 1;
             }
-            if current < self.equivalences.len()
-                && self.equivalences[current].src_offset <= *source
+            if current < self.equivalences.len() && self.equivalences[current].src_offset <= *source
             {
                 *source = *source - self.equivalences[current].src_offset
                     + self.equivalences[current].dst_offset;
@@ -823,8 +813,7 @@ impl PruneEquivalencesAndSortBySource {
                     break;
                 }
                 if equivalences[current].length < equivalences[next].length {
-                    let delta =
-                        equivalences[current].src_end() - equivalences[next].src_offset;
+                    let delta = equivalences[current].src_end() - equivalences[next].src_offset;
                     equivalences[current].length -= delta;
                     next_is_reaper = true;
                     break;
@@ -839,8 +828,7 @@ impl PruneEquivalencesAndSortBySource {
                 current = next;
             } else {
                 for reduced in (current + 1)..next {
-                    let delta =
-                        equivalences[current].src_end() - equivalences[reduced].src_offset;
+                    let delta = equivalences[current].src_end() - equivalences[reduced].src_offset;
                     let shrink = equivalences[reduced].length.min(delta);
                     equivalences[reduced].length -= shrink;
                     equivalences[reduced].src_offset += delta;
@@ -940,8 +928,7 @@ mod tests {
             let disasm = make_disassembler(exe_type, &image).unwrap();
             let cache = GroupRefCache::build(&*disasm, &image).unwrap();
             let size = disasm.size();
-            let ranges =
-                [(0, size), (0, size / 3), (size / 3, size * 2 / 3), (size * 2 / 3, size)];
+            let ranges = [(0, size), (0, size / 3), (size / 3, size * 2 / 3), (size * 2 / 3, size)];
             for group in 0..disasm.groups().len() {
                 for &(lo, hi) in &ranges {
                     if lo > hi || hi > size {
@@ -970,22 +957,113 @@ mod native_sort_tests {
     /// libstdc++ on this 48-element tie-heavy input.
     #[test]
     fn sort_reproduces_native_tie_order() {
-        let input: [(u32, u32, u32); 48] = [(0, 1000, 1), (5, 1001, 2), (10, 1002, 3), (15, 1003, 4), (6, 1004, 5), (11, 1005, 1), (16, 1006, 2), (4, 1007, 3), (12, 1008, 4), (0, 1009, 5), (5, 1010, 1), (10, 1011, 2), (1, 1012, 3), (6, 1013, 4), (11, 1014, 5), (16, 1015, 1), (7, 1016, 2), (12, 1017, 3), (0, 1018, 4), (5, 1019, 5), (13, 1020, 1), (1, 1021, 2), (6, 1022, 3), (11, 1023, 4), (2, 1024, 5), (7, 1025, 1), (12, 1026, 2), (0, 1027, 3), (8, 1028, 4), (13, 1029, 5), (1, 1030, 1), (6, 1031, 2), (14, 1032, 3), (2, 1033, 4), (7, 1034, 5), (12, 1035, 1), (3, 1036, 2), (8, 1037, 3), (13, 1038, 4), (1, 1039, 5), (9, 1040, 1), (14, 1041, 2), (2, 1042, 3), (7, 1043, 4), (15, 1044, 5), (3, 1045, 1), (8, 1046, 2), (13, 1047, 3)];
-        let expected: [(u32, u32, u32); 48] = [(0, 1000, 1), (0, 1009, 5), (0, 1027, 3), (0, 1018, 4), (1, 1039, 5), (1, 1030, 1), (1, 1012, 3), (1, 1021, 2), (2, 1042, 3), (2, 1033, 4), (2, 1024, 5), (3, 1045, 1), (3, 1036, 2), (4, 1007, 3), (5, 1001, 2), (5, 1019, 5), (5, 1010, 1), (6, 1004, 5), (6, 1031, 2), (6, 1022, 3), (6, 1013, 4), (7, 1025, 1), (7, 1016, 2), (7, 1043, 4), (7, 1034, 5), (8, 1037, 3), (8, 1028, 4), (8, 1046, 2), (9, 1040, 1), (10, 1011, 2), (10, 1002, 3), (11, 1014, 5), (11, 1023, 4), (11, 1005, 1), (12, 1008, 4), (12, 1035, 1), (12, 1017, 3), (12, 1026, 2), (13, 1047, 3), (13, 1038, 4), (13, 1029, 5), (13, 1020, 1), (14, 1041, 2), (14, 1032, 3), (15, 1003, 4), (15, 1044, 5), (16, 1006, 2), (16, 1015, 1)];
+        let input: [(u32, u32, u32); 48] = [
+            (0, 1000, 1),
+            (5, 1001, 2),
+            (10, 1002, 3),
+            (15, 1003, 4),
+            (6, 1004, 5),
+            (11, 1005, 1),
+            (16, 1006, 2),
+            (4, 1007, 3),
+            (12, 1008, 4),
+            (0, 1009, 5),
+            (5, 1010, 1),
+            (10, 1011, 2),
+            (1, 1012, 3),
+            (6, 1013, 4),
+            (11, 1014, 5),
+            (16, 1015, 1),
+            (7, 1016, 2),
+            (12, 1017, 3),
+            (0, 1018, 4),
+            (5, 1019, 5),
+            (13, 1020, 1),
+            (1, 1021, 2),
+            (6, 1022, 3),
+            (11, 1023, 4),
+            (2, 1024, 5),
+            (7, 1025, 1),
+            (12, 1026, 2),
+            (0, 1027, 3),
+            (8, 1028, 4),
+            (13, 1029, 5),
+            (1, 1030, 1),
+            (6, 1031, 2),
+            (14, 1032, 3),
+            (2, 1033, 4),
+            (7, 1034, 5),
+            (12, 1035, 1),
+            (3, 1036, 2),
+            (8, 1037, 3),
+            (13, 1038, 4),
+            (1, 1039, 5),
+            (9, 1040, 1),
+            (14, 1041, 2),
+            (2, 1042, 3),
+            (7, 1043, 4),
+            (15, 1044, 5),
+            (3, 1045, 1),
+            (8, 1046, 2),
+            (13, 1047, 3),
+        ];
+        let expected: [(u32, u32, u32); 48] = [
+            (0, 1000, 1),
+            (0, 1009, 5),
+            (0, 1027, 3),
+            (0, 1018, 4),
+            (1, 1039, 5),
+            (1, 1030, 1),
+            (1, 1012, 3),
+            (1, 1021, 2),
+            (2, 1042, 3),
+            (2, 1033, 4),
+            (2, 1024, 5),
+            (3, 1045, 1),
+            (3, 1036, 2),
+            (4, 1007, 3),
+            (5, 1001, 2),
+            (5, 1019, 5),
+            (5, 1010, 1),
+            (6, 1004, 5),
+            (6, 1031, 2),
+            (6, 1022, 3),
+            (6, 1013, 4),
+            (7, 1025, 1),
+            (7, 1016, 2),
+            (7, 1043, 4),
+            (7, 1034, 5),
+            (8, 1037, 3),
+            (8, 1028, 4),
+            (8, 1046, 2),
+            (9, 1040, 1),
+            (10, 1011, 2),
+            (10, 1002, 3),
+            (11, 1014, 5),
+            (11, 1023, 4),
+            (11, 1005, 1),
+            (12, 1008, 4),
+            (12, 1035, 1),
+            (12, 1017, 3),
+            (12, 1026, 2),
+            (13, 1047, 3),
+            (13, 1038, 4),
+            (13, 1029, 5),
+            (13, 1020, 1),
+            (14, 1041, 2),
+            (14, 1032, 3),
+            (15, 1003, 4),
+            (15, 1044, 5),
+            (16, 1006, 2),
+            (16, 1015, 1),
+        ];
         let mut values: Vec<Equivalence> = input
             .iter()
-            .map(|&(src_offset, dst_offset, length)| Equivalence {
-                src_offset,
-                dst_offset,
-                length,
-            })
+            .map(|&(src_offset, dst_offset, length)| Equivalence { src_offset, dst_offset, length })
             .collect();
         stdcpp::sort_by_src(&mut values);
-        let got: Vec<(u32, u32, u32)> = values
-            .iter()
-            .map(|e| (e.src_offset, e.dst_offset, e.length))
-            .collect();
+        let got: Vec<(u32, u32, u32)> =
+            values.iter().map(|e| (e.src_offset, e.dst_offset, e.length)).collect();
         assert_eq!(got, expected);
     }
 }
-
diff --git a/src/zucchini_pure/mod.rs b/src/zucchini_pure/mod.rs
index 20103b2..c255cd8 100644
--- a/src/zucchini_pure/mod.rs
+++ b/src/zucchini_pure/mod.rs
@@ -32,8 +32,8 @@ mod elf;
 mod engine;
 pub mod patch;
 
-pub use engine::Reference;
 pub use elf::ElfDisassembler;
+pub use engine::Reference;
 
 /// Exclusive upper bound for buffers represented by Zucchini offsets.
 pub const OFFSET_BOUND: usize = (u32::MAX / 2) as usize;
@@ -172,7 +172,10 @@ fn apply_inner(
 
     let mut output = Vec::new();
     output.try_reserve_exact(output_size).map_err(|error| {
-        Error::new(Status::AllocationFailure, format!("unable to allocate Zucchini output: {error}"))
+        Error::new(
+            Status::AllocationFailure,
+            format!("unable to allocate Zucchini output: {error}"),
+        )
     })?;
     output.resize(output_size, 0);
 
@@ -191,12 +194,11 @@ fn apply_inner(
         // for every equivalence in both phases).
         let (old_element, new_element) = engine::element_regions(old, element, &mut output)?;
         let analysis = engine::analyze_element(exe_type, old_element)?;
-        engine::preflight_element(element, old_element, new_element, &analysis, cancelled).map_err(
-            |error| match error.status() {
+        engine::preflight_element(element, old_element, new_element, &analysis, cancelled)
+            .map_err(|error| match error.status() {
                 Status::Cancelled => error,
                 _ => Error::new(Status::ApplyError, "android executable preflight failed"),
-            },
-        )?;
+            })?;
         let (old_element, new_element) = engine::element_regions(old, element, &mut output)?;
         engine::apply_element(element, old_element, new_element, &analysis, cancelled)?;
     }
@@ -219,12 +221,11 @@ pub(crate) fn is_android_executable(exe_type: u32) -> bool {
 }
 
 /// Dispatches to the format disassembler for `exe_type`, parsing `image`.
-pub(crate) fn make_disassembler(
-    exe_type: u32,
-    image: &[u8],
-) -> Option<Box<dyn Disassembler>> {
+pub(crate) fn make_disassembler(exe_type: u32, image: &[u8]) -> Option<Box<dyn Disassembler>> {
     match exe_type {
-        patch::EXE_TYPE_NOOP => Some(Box::new(engine::NoOpDisassembler { size: image.len() as u32 })),
+        patch::EXE_TYPE_NOOP => {
+            Some(Box::new(engine::NoOpDisassembler { size: image.len() as u32 }))
+        }
         patch::EXE_TYPE_ELF_X86 => {
             elf::ElfDisassembler::parse(elf::ElfKind::X86, image).map(|d| Box::new(d) as _)
         }
@@ -237,9 +238,7 @@ pub(crate) fn make_disassembler(
         patch::EXE_TYPE_ELF_AARCH64 => {
             elf::ElfDisassembler::parse(elf::ElfKind::AArch64, image).map(|d| Box::new(d) as _)
         }
-        patch::EXE_TYPE_DEX => {
-            dex::DexDisassembler::parse(image).map(|d| Box::new(d) as _)
-        }
+        patch::EXE_TYPE_DEX => dex::DexDisassembler::parse(image).map(|d| Box::new(d) as _),
         _ => None,
     }
 }
diff --git a/src/zucchini_pure/patch.rs b/src/zucchini_pure/patch.rs
index 831c3c8..11213e1 100644
--- a/src/zucchini_pure/patch.rs
+++ b/src/zucchini_pure/patch.rs
@@ -158,11 +158,7 @@ impl<'a> Cursor<'a> {
     /// Decodes an `int32_t` zig-zag varint, mirroring `DecodeVarInt`.
     fn var_i32(&mut self) -> Option<i32> {
         let tmp = self.var_u32()?;
-        if tmp & 1 != 0 {
-            Some(!((tmp >> 1) as i32))
-        } else {
-            Some((tmp >> 1) as i32)
-        }
+        if tmp & 1 != 0 { Some(!((tmp >> 1) as i32)) } else { Some((tmp >> 1) as i32) }
     }
 
     /// Mirrors `patch::ParseBuffer`: a `uint32_t` size followed by that many bytes.
@@ -178,12 +174,8 @@ fn invalid_patch(message: &str) -> Error {
 
 fn executable_version(exe_type: u32) -> Option<u16> {
     match exe_type {
-        EXE_TYPE_NOOP
-        | EXE_TYPE_ELF_X86
-        | EXE_TYPE_ELF_X64
-        | EXE_TYPE_ELF_AARCH32
-        | EXE_TYPE_ELF_AARCH64
-        | EXE_TYPE_DEX => Some(1),
+        EXE_TYPE_NOOP | EXE_TYPE_ELF_X86 | EXE_TYPE_ELF_X64 | EXE_TYPE_ELF_AARCH32
+        | EXE_TYPE_ELF_AARCH64 | EXE_TYPE_DEX => Some(1),
         _ => None,
     }
 }
@@ -263,9 +255,7 @@ fn parse_raw_deltas(skip: &[u8], diffs: &[u8]) -> Result<(Vec<RawDeltaUnit>, boo
     let mut diffs = Cursor::new(diffs);
     let mut result = Vec::new();
     let upper = skip.data.len().min(diffs.data.len());
-    result
-        .try_reserve(upper)
-        .map_err(|_| super::allocation_error("Zucchini raw delta stream"))?;
+    result.try_reserve(upper).map_err(|_| super::allocation_error("Zucchini raw delta stream"))?;
     let mut compensation: u32 = 0;
     while !skip.empty() && !diffs.empty() {
         let diff = match skip.var_u32() {
@@ -339,20 +329,14 @@ impl PatchElement {
         let element_match =
             parse_element_match(cursor).ok_or_else(|| invalid_patch("invalid patch element"))?;
 
-        let src_skip = cursor
-            .buffer()
-            .ok_or_else(|| invalid_patch("invalid equivalence source"))?;
-        let dst_skip = cursor
-            .buffer()
-            .ok_or_else(|| invalid_patch("invalid equivalence source"))?;
-        let copy_count = cursor
-            .buffer()
-            .ok_or_else(|| invalid_patch("invalid equivalence source"))?;
-        let (equivalences, equivalences_done) =
-            parse_equivalences(src_skip, dst_skip, copy_count)?;
-        let extra_slice = cursor
-            .buffer()
-            .ok_or_else(|| invalid_patch("invalid extra data"))?;
+        let src_skip =
+            cursor.buffer().ok_or_else(|| invalid_patch("invalid equivalence source"))?;
+        let dst_skip =
+            cursor.buffer().ok_or_else(|| invalid_patch("invalid equivalence source"))?;
+        let copy_count =
+            cursor.buffer().ok_or_else(|| invalid_patch("invalid equivalence source"))?;
+        let (equivalences, equivalences_done) = parse_equivalences(src_skip, dst_skip, copy_count)?;
+        let extra_slice = cursor.buffer().ok_or_else(|| invalid_patch("invalid extra data"))?;
         let mut extra_data = Vec::new();
         extra_data
             .try_reserve_exact(extra_slice.len())
@@ -388,38 +372,27 @@ impl PatchElement {
             return Err(invalid_patch("incorrect amount of extra data"));
         }
 
-        let raw_skip = cursor
-            .buffer()
-            .ok_or_else(|| invalid_patch("invalid raw delta source"))?;
-        let raw_diff = cursor
-            .buffer()
-            .ok_or_else(|| invalid_patch("invalid raw delta source"))?;
+        let raw_skip = cursor.buffer().ok_or_else(|| invalid_patch("invalid raw delta source"))?;
+        let raw_diff = cursor.buffer().ok_or_else(|| invalid_patch("invalid raw delta source"))?;
         let (raw_deltas, raw_deltas_done) = parse_raw_deltas(raw_skip, raw_diff)?;
 
-        let reference_source = cursor
-            .buffer()
-            .ok_or_else(|| invalid_patch("invalid reference delta source"))?;
-        let (reference_deltas, reference_deltas_done) =
-            parse_reference_deltas(reference_source)?;
+        let reference_source =
+            cursor.buffer().ok_or_else(|| invalid_patch("invalid reference delta source"))?;
+        let (reference_deltas, reference_deltas_done) = parse_reference_deltas(reference_source)?;
 
-        let pool_count = cursor
-            .u32()
-            .ok_or_else(|| invalid_patch("invalid extra target list"))?;
+        let pool_count = cursor.u32().ok_or_else(|| invalid_patch("invalid extra target list"))?;
         // Each pool costs at least a tag byte plus a 4-byte length prefix.
         if pool_count as usize > cursor.remaining() / 5 {
             return Err(invalid_patch("invalid extra target list"));
         }
         let mut extra_targets = BTreeMap::new();
         for _ in 0..pool_count {
-            let pool_tag = cursor
-                .u8()
-                .ok_or_else(|| invalid_patch("invalid extra target list"))?;
+            let pool_tag = cursor.u8().ok_or_else(|| invalid_patch("invalid extra target list"))?;
             if pool_tag == 0xFF {
                 return Err(invalid_patch("invalid pool tag"));
             }
-            let source = cursor
-                .buffer()
-                .ok_or_else(|| invalid_patch("invalid extra target list"))?;
+            let source =
+                cursor.buffer().ok_or_else(|| invalid_patch("invalid extra target list"))?;
             if extra_targets.insert(pool_tag, parse_extra_targets(source)?).is_some() {
                 return Err(invalid_patch("duplicate pool tag"));
             }
@@ -454,9 +427,7 @@ impl Patch {
         if header.magic != PATCH_MAGIC || header.major_version != MAJOR_VERSION {
             return Err(invalid_patch("invalid ensemble patch"));
         }
-        let element_count = cursor
-            .u32()
-            .ok_or_else(|| invalid_patch("invalid ensemble patch"))?;
+        let element_count = cursor.u32().ok_or_else(|| invalid_patch("invalid ensemble patch"))?;
         let mut elements = Vec::new();
         // Each element header is 22 bytes, so this bounds the reservation even
         // if `element_count` is absurd.
@@ -467,13 +438,15 @@ impl Patch {
         let mut current_dst_offset: u32 = 0;
         for _ in 0..element_count {
             let element = PatchElement::parse(&mut cursor)?;
-            if !region_fits(element.element_match.old_offset, element.element_match.old_size, header.old_size)
-                || !region_fits(
-                    element.element_match.new_offset,
-                    element.element_match.new_size,
-                    header.new_size,
-                )
-            {
+            if !region_fits(
+                element.element_match.old_offset,
+                element.element_match.old_size,
+                header.old_size,
+            ) || !region_fits(
+                element.element_match.new_offset,
+                element.element_match.new_size,
+                header.new_size,
+            ) {
                 return Err(invalid_patch("invalid patch element"));
             }
             if element.element_match.new_offset != current_dst_offset {
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index 45e1166..3e1e857 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -409,14 +409,6 @@ fn with_puffin_patch_type(patch: &[u8], patch_type: u8) -> Vec<u8> {
     changed
 }
 
-fn with_puffin_inner_patch(patch: &[u8], inner_patch: &[u8]) -> Vec<u8> {
-    let header_len = u32::from_be_bytes(patch[4..8].try_into().unwrap()) as usize;
-    let mut changed = Vec::with_capacity(8 + header_len + inner_patch.len());
-    changed.extend_from_slice(&patch[..8 + header_len]);
-    changed.extend_from_slice(inner_patch);
-    changed
-}
-
 #[test]
 fn puffdiff_bsdiff_reconstructs_pinned_puffin_goldens() {
     let source = puffin_fixture("deflates-sample1.bin");
diff --git a/tests/zucchini_pure.rs b/tests/zucchini_pure.rs
index 513d93b..9f3e3d8 100644
--- a/tests/zucchini_pure.rs
+++ b/tests/zucchini_pure.rs
@@ -175,43 +175,6 @@ fn pure_rust_honors_cancellation() {
     assert_eq!(error.status(), Status::Cancelled);
 }
 
-/// Differential check against the vendored C++ implementation. Only compiled
-/// when `OTADUMP_NATIVE_ZUCCHINI=1` selected the native build.
-#[cfg(otadump_native_zucchini)]
-#[test]
-fn native_and_pure_agree_on_all_fixtures() {
-    let cases: &[(&str, &str, &str)] = &[
-        ("noop-old.bin", "noop.zuc", "noop-new.bin"),
-        ("elf-x86-old", "elf-x86.zuc", "elf-x86-new"),
-        ("elf-old", "elf.zuc", "elf-new"),
-        ("elf-arm32-old", "elf-arm32.zuc", "elf-arm32-new"),
-        ("elf-arm64-old", "elf-arm64.zuc", "elf-arm64-new"),
-        ("dex-old.dex", "dex.zuc", "dex-new.dex"),
-        ("dex-large-old.dex", "dex-large.zuc", "dex-large-new.dex"),
-        ("dex-large-old.dex", "dex-large-unsafe16.zuc", "dex-large-new.dex"),
-    ];
-    let fixtures = Path::new(FIXTURES);
-    for (old_name, patch_name, new_name) in cases {
-        let old = fs::read(fixtures.join(old_name)).unwrap();
-        let patch = fs::read(fixtures.join(patch_name)).unwrap();
-        let size = fs::metadata(fixtures.join(new_name)).unwrap().len() as usize;
-
-        let pure = zucchini_pure::apply(&old, &patch, size);
-        let native = otadump::zucchini::apply_native(&old, &patch, size);
-        match (pure, native) {
-            (Ok(a), Ok(b)) => assert_eq!(a, b, "output mismatch for {patch_name}"),
-            (Err(a), Err(b)) => assert_eq!(
-                format!("{:?}", a.status()),
-                format!("{:?}", b.status()),
-                "status mismatch for {patch_name}"
-            ),
-            (a, b) => panic!(
-                "pure {a:?} and native {b:?} disagree for {patch_name}"
-            ),
-        }
-    }
-}
-
 /// Cancellation occurring while the Android preflight is running must surface
 /// as `Status::Cancelled`, not be folded into the preflight `ApplyError`.
 #[test]

From 6b6fc74b05530e1a13bb43d3a568951fe499e3c2 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 21:11:54 +0530
Subject: [PATCH 35/42] lz4: replace vendored C sources with pinned lz4-sys
 crate

Remove the in-repo native/lz4 tree (AOSP-vendored liblz4 1.10.0 sources,
the custom otadump_lz4_* C shim, build.rs compilation, and the source
inventory) in favor of the pinned lz4-sys =1.11.1 crate (published as
1.11.1+lz4-1.10.0, enforced by the lockfile checksum). The crate bundles
liblz4 1.10.0 C sources that are byte-identical (SHA-256 verified) to
AOSP platform/external/lz4 @ 734e07032602, which Android lz4diff uses,
so compressed blocks stay byte-for-byte compatible with AOSP.

The crate's bindings omit the block-level destSize/partial APIs, so
src/lz4.rs declares LZ4_compress_destSize, LZ4_compress_HC_destSize,
LZ4_decompress_safe_partial, and the HC stream lifecycle directly;
signatures match lz4.h/lz4hc.h 1.10.0. Static linkage is unchanged:
lz4-sys compiles the archive with cc and final artifacts pull only
lz4.o/lz4hc.o (lz4frame.o/xxhash.o excluded), with no dynamic liblz4
dependency. LZ4DIFF now also works off Linux x86-64 GNU hosts.

The BSD-2-Clause liblz4 notice moves to licenses/LICENSE.lz4 and keeps
shipping in release archives and wheels.

Verification:
- cargo test / cargo test --release: 66 passed (11 lz4 unit tests
  byte-comparing frozen AOSP fixtures, 2 lz4diff integration tests)
- differential harness vs the base C-shim build: byte-identical output
  for fast mode, HC levels 2-12, zero-padding, and partial destSize
  across fixture and synthetic inputs
- cargo clippy --all-targets --locked -- -D warnings: clean
- ABI3 wheel builds, imports, and passes tests/python_smoke.py; the
  wheel ships licenses/LICENSE.lz4
- ldd/nm -D: no dynamic liblz4 in the CLI binary or the wheel .so
- release-cli binary: 2222512 -> 2223584 bytes (+1072)

Signed-off-by: Akhil Narang <me@akhilnarang.dev>
---
 .github/workflows/release.yaml             |    4 +-
 Cargo.lock                                 |   12 +-
 Cargo.toml                                 |    6 +-
 README.md                                  |    2 +-
 build.rs                                   |   58 -
 native/lz4/LICENSE => licenses/LICENSE.lz4 |    0
 licenses/README.md                         |   10 +
 native/lz4/README.md                       |   16 -
 native/lz4/SOURCE_INVENTORY.sha256         |    7 -
 native/lz4/src/lz4_ffi.c                   |   96 -
 native/lz4/src/lz4_ffi.h                   |   33 -
 native/lz4/vendor/lib/lz4.c                | 2829 --------------------
 native/lz4/vendor/lib/lz4.h                |  884 ------
 native/lz4/vendor/lib/lz4hc.c              | 2192 ---------------
 native/lz4/vendor/lib/lz4hc.h              |  414 ---
 pyproject.toml                             |    2 +-
 src/lz4.rs                                 |  222 +-
 17 files changed, 119 insertions(+), 6668 deletions(-)
 rename native/lz4/LICENSE => licenses/LICENSE.lz4 (100%)
 create mode 100644 licenses/README.md
 delete mode 100644 native/lz4/README.md
 delete mode 100644 native/lz4/SOURCE_INVENTORY.sha256
 delete mode 100644 native/lz4/src/lz4_ffi.c
 delete mode 100644 native/lz4/src/lz4_ffi.h
 delete mode 100644 native/lz4/vendor/lib/lz4.c
 delete mode 100644 native/lz4/vendor/lib/lz4.h
 delete mode 100644 native/lz4/vendor/lib/lz4hc.c
 delete mode 100644 native/lz4/vendor/lib/lz4hc.h

diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 454c7d5..44fa5bb 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -128,7 +128,7 @@ jobs:
         if: runner.os != 'Windows'
         run: >
           tar -cv
-          LICENSE README.md src/puffin/LICENSE native/lz4/LICENSE
+          LICENSE README.md src/puffin/LICENSE licenses/LICENSE.lz4 licenses/README.md
           -C target/${{ matrix.target }}/release-cli/ otadump
           | gzip --best
           > 'otadump-${{ steps.get_version.outputs.value }}-${{ matrix.target }}.tar.gz'
@@ -136,7 +136,7 @@ jobs:
         if: runner.os == 'Windows'
         run: >
           7z a 'otadump-${{ steps.get_version.outputs.value }}-${{ matrix.target }}.zip'
-          LICENSE README.md src/puffin/LICENSE native/lz4/LICENSE
+          LICENSE README.md src/puffin/LICENSE licenses/LICENSE.lz4 licenses/README.md
           ./target/${{ matrix.target }}/release-cli/otadump.exe
       - name: Upload artifact
         uses: actions/upload-artifact@v4.6.0
diff --git a/Cargo.lock b/Cargo.lock
index c782812..09d0807 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -502,6 +502,16 @@ version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
+[[package]]
+name = "lz4-sys"
+version = "1.11.1+lz4-1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bd8c0d6c6ed0cd30b3652886bb8711dc4bb01d637a68105a3d5158039b418e6"
+dependencies = [
+ "cc",
+ "libc",
+]
+
 [[package]]
 name = "memchr"
 version = "2.7.5"
@@ -613,13 +623,13 @@ dependencies = [
  "anyhow",
  "brotli",
  "bzip2",
- "cc",
  "clap",
  "color-print",
  "ctrlc",
  "hex",
  "indicatif",
  "liblzma",
+ "lz4-sys",
  "memmap2",
  "nom",
  "nom-derive",
diff --git a/Cargo.toml b/Cargo.toml
index 156271c..c2280f7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,7 +21,6 @@ crate-type = ["cdylib", "rlib"]
 python = ["dep:pyo3"]
 
 [build-dependencies]
-cc = "=1.2.27"
 prost-build = "0.14.1"
 protoc-bin-vendored = "3.2.0"
 
@@ -35,6 +34,11 @@ ctrlc = "3.5.0"
 hex = "0.4.3"
 indicatif = "0.17.3"
 liblzma = { version = "0.4.2", features = ["static"] }
+# Pinned exactly. The only published 1.11.1 is `1.11.1+lz4-1.10.0` (Cargo
+# ignores `+metadata` in requirements, so the lockfile checksum enforces it):
+# it bundles liblz4 1.10.0, byte-identical to the AOSP platform/external/lz4
+# sources that Android lz4diff uses.
+lz4-sys = "=1.11.1"
 memmap2 = "0.9.5"
 nom = "7.1.1"
 nom-derive = "0.10.1"
diff --git a/README.md b/README.md
index a8de477..b741767 100644
--- a/README.md
+++ b/README.md
@@ -84,7 +84,7 @@ otadump payload.bin
 # Apply a SOURCE_COPY, SOURCE_BSDIFF, BROTLI_BSDIFF, PUFFDIFF (inner BSDIFF or
 # ZUCCHINI), standalone ZUCCHINI, or LZ4DIFF (inner BSDIFF or PUFFDIFF) delta
 # payload with matching base images.
-# ZUCCHINI and LZ4DIFF require Linux x86-64 GNU.
+# ZUCCHINI requires Linux x86-64 GNU.
 otadump delta.zip --output-dir output --source-dir source-images
 ```
 
diff --git a/build.rs b/build.rs
index 9a88d57..153312d 100644
--- a/build.rs
+++ b/build.rs
@@ -1,22 +1,6 @@
-use std::fs;
-use std::path::{Path, PathBuf};
-
-// LZ4 block codec only. xxhash.c serves lz4frame.c (not built) and is
-// referenced by neither lz4.c nor lz4hc.c.
-const LZ4_SOURCES: &[&str] =
-    &["native/lz4/src/lz4_ffi.c", "native/lz4/vendor/lib/lz4.c", "native/lz4/vendor/lib/lz4hc.c"];
-
 fn main() {
-    println!("cargo:rustc-check-cfg=cfg(otadump_lz4)");
     println!("cargo:rustc-check-cfg=cfg(otadump_zucchini)");
     println!("cargo:rerun-if-changed=src/protos/chromeos_update_engine/update_metadata.proto");
-    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("linux")
-        && std::env::var("CARGO_CFG_TARGET_ARCH").as_deref() == Ok("x86_64")
-        && std::env::var("CARGO_CFG_TARGET_ENV").as_deref() == Ok("gnu")
-    {
-        build_lz4();
-        println!("cargo:rustc-cfg=otadump_lz4");
-    }
 
     let protoc = protoc_bin_vendored::protoc_bin_path().expect("unable to find vendored protoc");
     let mut config = prost_build::Config::new();
@@ -28,45 +12,3 @@ fn main() {
         )
         .expect("error compiling protobuf files");
 }
-
-fn build_lz4() {
-    let root = Path::new("native/lz4");
-    track_directory(root);
-
-    cc::Build::new()
-        .std("c99")
-        .opt_level(3)
-        .define("NDEBUG", None)
-        .warnings(true)
-        .warnings_into_errors(true)
-        .flag("-fvisibility=hidden")
-        // C code never throws: drop unwind tables.
-        .flag("-fno-asynchronous-unwind-tables")
-        .flag("-fno-unwind-tables")
-        .include(root.join("src"))
-        .include(root.join("vendor/lib"))
-        .files(LZ4_SOURCES)
-        .compile("otadump_lz4");
-}
-
-fn track_directory(root: &Path) {
-    let mut tracked = Vec::new();
-    collect_files(root, &mut tracked);
-    tracked.sort();
-    for path in tracked {
-        println!("cargo:rerun-if-changed={}", path.display());
-    }
-}
-
-fn collect_files(directory: &Path, files: &mut Vec<PathBuf>) {
-    let entries = fs::read_dir(directory)
-        .unwrap_or_else(|error| panic!("unable to read native source entry: {error}"));
-    for entry in entries {
-        let path = entry.expect("unable to read native source entry").path();
-        if path.is_dir() {
-            collect_files(&path, files);
-        } else {
-            files.push(path);
-        }
-    }
-}
diff --git a/native/lz4/LICENSE b/licenses/LICENSE.lz4
similarity index 100%
rename from native/lz4/LICENSE
rename to licenses/LICENSE.lz4
diff --git a/licenses/README.md b/licenses/README.md
new file mode 100644
index 0000000..7cc657a
--- /dev/null
+++ b/licenses/README.md
@@ -0,0 +1,10 @@
+# Third-party license notices
+
+`LICENSE.lz4` is the BSD-2-Clause license of upstream liblz4, statically linked
+into release binaries and wheels via the pinned
+[`lz4-sys`](https://crates.io/crates/lz4-sys) `=1.11.1+lz4-1.10.0` crate.
+
+That crate bundles the liblz4 1.10.0 C sources. The `lz4.c`, `lz4.h`,
+`lz4hc.c`, and `lz4hc.h` files it compiles are byte-identical (SHA-256
+verified) to the AOSP `platform/external/lz4` sources pinned at commit
+`734e07032602e9a72fcc9701028b0aee45147fcd`, which Android `lz4diff` uses.
diff --git a/native/lz4/README.md b/native/lz4/README.md
deleted file mode 100644
index e053d47..0000000
--- a/native/lz4/README.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# AOSP LZ4 boundary
-
-This directory vendors the LZ4 block operations used by Android `lz4diff`.
-The files under `vendor/lib` come from AOSP `platform/external/lz4` commit `734e07032602e9a72fcc9701028b0aee45147fcd`.
-They use the BSD-2-Clause license in `LICENSE`.
-
-`src/lz4_ffi.c` and `src/lz4_ffi.h` are project-owned BSD-2-Clause files.
-They provide a fixed C ABI for `LZ4_decompress_safe_partial`, `LZ4_compress_destSize`, and `LZ4_compress_HC_destSize`.
-The HC wrapper owns and frees its native stream state.
-No dictionary API is exposed.
-
-`build.rs` compiles only the three pinned library source units and the local wrapper on Linux x86_64 GNU.
-It uses C99, optimization level 3, `NDEBUG`, compiler warnings, and warnings as errors.
-The resulting archive links statically into `otadump`.
-
-Run `sha256sum -c SOURCE_INVENTORY.sha256` from this directory to verify the source inventory.
diff --git a/native/lz4/SOURCE_INVENTORY.sha256 b/native/lz4/SOURCE_INVENTORY.sha256
deleted file mode 100644
index 96e465a..0000000
--- a/native/lz4/SOURCE_INVENTORY.sha256
+++ /dev/null
@@ -1,7 +0,0 @@
-8b58c446121a109ccf32edc094bba3010a3d85e4ee3702950db55e4d3e87736c  LICENSE
-23242d5e48eb4d60ce0868d885dc6406b68a8590e5f191ca000cb8ba28367193  src/lz4_ffi.c
-65841c1381dc311dca4f8741684698c934ca6e465650ba25aa172d99844c1e26  src/lz4_ffi.h
-9396f7de527bc8435de9c7569fb7998e56545a84b4f3c2d808c0235c01774539  vendor/lib/lz4.c
-26b82efc53d1570f3b54eef02e9c4764c1ad374ff03cac04e2ced5ea4d4c552f  vendor/lib/lz4.h
-126cafafdb91767e6e55238298a910903851b35b2cee27ce80ae2280469ee232  vendor/lib/lz4hc.c
-e43824e8a9ba16f54100c4ccbccfa5782a858ca9ab83c48aac303fea3e76e21e  vendor/lib/lz4hc.h
diff --git a/native/lz4/src/lz4_ffi.c b/native/lz4/src/lz4_ffi.c
deleted file mode 100644
index 9b06636..0000000
--- a/native/lz4/src/lz4_ffi.c
+++ /dev/null
@@ -1,96 +0,0 @@
-/* SPDX-License-Identifier: BSD-2-Clause */
-#include "lz4_ffi.h"
-
-#include <stddef.h>
-
-#include "lz4.h"
-#include "lz4hc.h"
-
-enum {
-  OTADUMP_LZ4_OK = 0,
-  OTADUMP_LZ4_INVALID_ARGUMENT = 1,
-  OTADUMP_LZ4_COMPRESSION_FAILED = 2,
-  OTADUMP_LZ4_DECOMPRESSION_FAILED = 3,
-  OTADUMP_LZ4_ALLOCATION_FAILED = 4,
-};
-
-static otadump_lz4_result make_result(int32_t status, int32_t source_size,
-                                     int32_t output_size) {
-  otadump_lz4_result result = {status, source_size, output_size};
-  return result;
-}
-
-static int buffers_overlap(const uint8_t *source, int32_t source_size,
-                           const uint8_t *output, int32_t output_capacity) {
-  uintptr_t src_start = (uintptr_t)source;
-  uintptr_t src_end = src_start + (size_t)source_size;
-  uintptr_t dst_start = (uintptr_t)output;
-  uintptr_t dst_end = dst_start + (size_t)output_capacity;
-  return src_start < dst_end && dst_start < src_end;
-}
-
-static int valid_buffers(const uint8_t *source, int32_t source_size,
-                         uint8_t *output, int32_t output_capacity) {
-  return source != NULL && output != NULL && source_size > 0 &&
-         output_capacity > 0 && source_size <= LZ4_MAX_INPUT_SIZE &&
-         output_capacity <= LZ4_MAX_INPUT_SIZE &&
-         !buffers_overlap(source, source_size, output, output_capacity);
-}
-
-otadump_lz4_result otadump_lz4_decompress_safe_partial(
-    const uint8_t *source, int32_t source_size, uint8_t *output,
-    int32_t output_capacity, int32_t target_output_size) {
-  int written;
-  if (!valid_buffers(source, source_size, output, output_capacity) ||
-      target_output_size <= 0 || target_output_size > output_capacity) {
-    return make_result(OTADUMP_LZ4_INVALID_ARGUMENT, 0, 0);
-  }
-  written = LZ4_decompress_safe_partial(
-      (const char *)source, (char *)output, source_size, target_output_size,
-      output_capacity);
-  if (written < 0) {
-    return make_result(OTADUMP_LZ4_DECOMPRESSION_FAILED, 0, 0);
-  }
-  return make_result(OTADUMP_LZ4_OK, source_size, written);
-}
-
-otadump_lz4_result otadump_lz4_compress_dest_size(
-    const uint8_t *source, int32_t source_size, uint8_t *output,
-    int32_t output_capacity) {
-  int consumed = source_size;
-  int written;
-  if (!valid_buffers(source, source_size, output, output_capacity)) {
-    return make_result(OTADUMP_LZ4_INVALID_ARGUMENT, 0, 0);
-  }
-  written = LZ4_compress_destSize((const char *)source, (char *)output,
-                                  &consumed, output_capacity);
-  if (written <= 0) {
-    return make_result(OTADUMP_LZ4_COMPRESSION_FAILED, consumed, 0);
-  }
-  return make_result(OTADUMP_LZ4_OK, consumed, written);
-}
-
-otadump_lz4_result otadump_lz4_compress_hc_dest_size(
-    const uint8_t *source, int32_t source_size, uint8_t *output,
-    int32_t output_capacity, int32_t compression_level) {
-  LZ4_streamHC_t *stream;
-  int consumed = source_size;
-  int written;
-  if (!valid_buffers(source, source_size, output, output_capacity) ||
-      compression_level < LZ4HC_CLEVEL_MIN ||
-      compression_level > LZ4HC_CLEVEL_MAX) {
-    return make_result(OTADUMP_LZ4_INVALID_ARGUMENT, 0, 0);
-  }
-  stream = LZ4_createStreamHC();
-  if (stream == NULL) {
-    return make_result(OTADUMP_LZ4_ALLOCATION_FAILED, 0, 0);
-  }
-  written = LZ4_compress_HC_destSize(stream, (const char *)source,
-                                     (char *)output, &consumed,
-                                     output_capacity, compression_level);
-  LZ4_freeStreamHC(stream);
-  if (written <= 0) {
-    return make_result(OTADUMP_LZ4_COMPRESSION_FAILED, consumed, 0);
-  }
-  return make_result(OTADUMP_LZ4_OK, consumed, written);
-}
diff --git a/native/lz4/src/lz4_ffi.h b/native/lz4/src/lz4_ffi.h
deleted file mode 100644
index 2f08442..0000000
--- a/native/lz4/src/lz4_ffi.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/* SPDX-License-Identifier: BSD-2-Clause */
-#ifndef OTADUMP_LZ4_FFI_H
-#define OTADUMP_LZ4_FFI_H
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
-  int32_t status;
-  int32_t source_size;
-  int32_t output_size;
-} otadump_lz4_result;
-
-otadump_lz4_result otadump_lz4_decompress_safe_partial(
-    const uint8_t *source, int32_t source_size, uint8_t *output,
-    int32_t output_capacity, int32_t target_output_size);
-
-otadump_lz4_result otadump_lz4_compress_dest_size(
-    const uint8_t *source, int32_t source_size, uint8_t *output,
-    int32_t output_capacity);
-
-otadump_lz4_result otadump_lz4_compress_hc_dest_size(
-    const uint8_t *source, int32_t source_size, uint8_t *output,
-    int32_t output_capacity, int32_t compression_level);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/native/lz4/vendor/lib/lz4.c b/native/lz4/vendor/lib/lz4.c
deleted file mode 100644
index a2f7abe..0000000
--- a/native/lz4/vendor/lib/lz4.c
+++ /dev/null
@@ -1,2829 +0,0 @@
-/*
-   LZ4 - Fast LZ compression algorithm
-   Copyright (C) 2011-2023, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-    - LZ4 homepage : http://www.lz4.org
-    - LZ4 source repository : https://github.com/lz4/lz4
-*/
-
-/*-************************************
-*  Tuning parameters
-**************************************/
-/*
- * LZ4_HEAPMODE :
- * Select how stateless compression functions like `LZ4_compress_default()`
- * allocate memory for their hash table,
- * in memory stack (0:default, fastest), or in memory heap (1:requires malloc()).
- */
-#ifndef LZ4_HEAPMODE
-#  define LZ4_HEAPMODE 0
-#endif
-
-/*
- * LZ4_ACCELERATION_DEFAULT :
- * Select "acceleration" for LZ4_compress_fast() when parameter value <= 0
- */
-#define LZ4_ACCELERATION_DEFAULT 1
-/*
- * LZ4_ACCELERATION_MAX :
- * Any "acceleration" value higher than this threshold
- * get treated as LZ4_ACCELERATION_MAX instead (fix #876)
- */
-#define LZ4_ACCELERATION_MAX 65537
-
-
-/*-************************************
-*  CPU Feature Detection
-**************************************/
-/* LZ4_FORCE_MEMORY_ACCESS
- * By default, access to unaligned memory is controlled by `memcpy()`, which is safe and portable.
- * Unfortunately, on some target/compiler combinations, the generated assembly is sub-optimal.
- * The below switch allow to select different access method for improved performance.
- * Method 0 (default) : use `memcpy()`. Safe and portable.
- * Method 1 : `__packed` statement. It depends on compiler extension (ie, not portable).
- *            This method is safe if your compiler supports it, and *generally* as fast or faster than `memcpy`.
- * Method 2 : direct access. This method is portable but violate C standard.
- *            It can generate buggy code on targets which assembly generation depends on alignment.
- *            But in some circumstances, it's the only known way to get the most performance (ie GCC + ARMv6)
- * See https://fastcompression.blogspot.fr/2015/08/accessing-unaligned-memory.html for details.
- * Prefer these methods in priority order (0 > 1 > 2)
- */
-#ifndef LZ4_FORCE_MEMORY_ACCESS   /* can be defined externally */
-#  if defined(__GNUC__) && \
-  ( defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) \
-  || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6T2__) )
-#    define LZ4_FORCE_MEMORY_ACCESS 2
-#  elif (defined(__INTEL_COMPILER) && !defined(_WIN32)) || defined(__GNUC__) || defined(_MSC_VER)
-#    define LZ4_FORCE_MEMORY_ACCESS 1
-#  endif
-#endif
-
-/*
- * LZ4_FORCE_SW_BITCOUNT
- * Define this parameter if your target system or compiler does not support hardware bit count
- */
-#if defined(_MSC_VER) && defined(_WIN32_WCE)   /* Visual Studio for WinCE doesn't support Hardware bit count */
-#  undef  LZ4_FORCE_SW_BITCOUNT  /* avoid double def */
-#  define LZ4_FORCE_SW_BITCOUNT
-#endif
-
-
-
-/*-************************************
-*  Dependency
-**************************************/
-/*
- * LZ4_SRC_INCLUDED:
- * Amalgamation flag, whether lz4.c is included
- */
-#ifndef LZ4_SRC_INCLUDED
-#  define LZ4_SRC_INCLUDED 1
-#endif
-
-#ifndef LZ4_DISABLE_DEPRECATE_WARNINGS
-#  define LZ4_DISABLE_DEPRECATE_WARNINGS /* due to LZ4_decompress_safe_withPrefix64k */
-#endif
-
-#ifndef LZ4_STATIC_LINKING_ONLY
-#  define LZ4_STATIC_LINKING_ONLY
-#endif
-#include "lz4.h"
-/* see also "memory routines" below */
-
-
-/*-************************************
-*  Compiler Options
-**************************************/
-#if defined(_MSC_VER) && (_MSC_VER >= 1400)  /* Visual Studio 2005+ */
-#  include <intrin.h>               /* only present in VS2005+ */
-#  pragma warning(disable : 4127)   /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 6237)   /* disable: C6237: conditional expression is always 0 */
-#  pragma warning(disable : 6239)   /* disable: C6239: (<non-zero constant> && <expression>) always evaluates to the result of <expression> */
-#  pragma warning(disable : 6240)   /* disable: C6240: (<expression> && <non-zero constant>) always evaluates to the result of <expression> */
-#  pragma warning(disable : 6326)   /* disable: C6326: Potential comparison of a constant with another constant */
-#endif  /* _MSC_VER */
-
-#ifndef LZ4_FORCE_INLINE
-#  if defined (_MSC_VER) && !defined (__clang__)    /* MSVC */
-#    define LZ4_FORCE_INLINE static __forceinline
-#  else
-#    if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#      if defined (__GNUC__) || defined (__clang__)
-#        define LZ4_FORCE_INLINE static inline __attribute__((always_inline))
-#      else
-#        define LZ4_FORCE_INLINE static inline
-#      endif
-#    else
-#      define LZ4_FORCE_INLINE static
-#    endif /* __STDC_VERSION__ */
-#  endif  /* _MSC_VER */
-#endif /* LZ4_FORCE_INLINE */
-
-/* LZ4_FORCE_O2 and LZ4_FORCE_INLINE
- * gcc on ppc64le generates an unrolled SIMDized loop for LZ4_wildCopy8,
- * together with a simple 8-byte copy loop as a fall-back path.
- * However, this optimization hurts the decompression speed by >30%,
- * because the execution does not go to the optimized loop
- * for typical compressible data, and all of the preamble checks
- * before going to the fall-back path become useless overhead.
- * This optimization happens only with the -O3 flag, and -O2 generates
- * a simple 8-byte copy loop.
- * With gcc on ppc64le, all of the LZ4_decompress_* and LZ4_wildCopy8
- * functions are annotated with __attribute__((optimize("O2"))),
- * and also LZ4_wildCopy8 is forcibly inlined, so that the O2 attribute
- * of LZ4_wildCopy8 does not affect the compression speed.
- */
-#if defined(__PPC64__) && defined(__LITTLE_ENDIAN__) && defined(__GNUC__) && !defined(__clang__)
-#  define LZ4_FORCE_O2  __attribute__((optimize("O2")))
-#  undef LZ4_FORCE_INLINE
-#  define LZ4_FORCE_INLINE  static __inline __attribute__((optimize("O2"),always_inline))
-#else
-#  define LZ4_FORCE_O2
-#endif
-
-#if (defined(__GNUC__) && (__GNUC__ >= 3)) || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) || defined(__clang__)
-#  define expect(expr,value)    (__builtin_expect ((expr),(value)) )
-#else
-#  define expect(expr,value)    (expr)
-#endif
-
-#ifndef likely
-#define likely(expr)     expect((expr) != 0, 1)
-#endif
-#ifndef unlikely
-#define unlikely(expr)   expect((expr) != 0, 0)
-#endif
-
-/* Should the alignment test prove unreliable, for some reason,
- * it can be disabled by setting LZ4_ALIGN_TEST to 0 */
-#ifndef LZ4_ALIGN_TEST  /* can be externally provided */
-# define LZ4_ALIGN_TEST 1
-#endif
-
-
-/*-************************************
-*  Memory routines
-**************************************/
-
-/*! LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION :
- *  Disable relatively high-level LZ4/HC functions that use dynamic memory
- *  allocation functions (malloc(), calloc(), free()).
- *
- *  Note that this is a compile-time switch. And since it disables
- *  public/stable LZ4 v1 API functions, we don't recommend using this
- *  symbol to generate a library for distribution.
- *
- *  The following public functions are removed when this symbol is defined.
- *  - lz4   : LZ4_createStream, LZ4_freeStream,
- *            LZ4_createStreamDecode, LZ4_freeStreamDecode, LZ4_create (deprecated)
- *  - lz4hc : LZ4_createStreamHC, LZ4_freeStreamHC,
- *            LZ4_createHC (deprecated), LZ4_freeHC  (deprecated)
- *  - lz4frame, lz4file : All LZ4F_* functions
- */
-#if defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-#  define ALLOC(s)          lz4_error_memory_allocation_is_disabled
-#  define ALLOC_AND_ZERO(s) lz4_error_memory_allocation_is_disabled
-#  define FREEMEM(p)        lz4_error_memory_allocation_is_disabled
-#elif defined(LZ4_USER_MEMORY_FUNCTIONS)
-/* memory management functions can be customized by user project.
- * Below functions must exist somewhere in the Project
- * and be available at link time */
-void* LZ4_malloc(size_t s);
-void* LZ4_calloc(size_t n, size_t s);
-void  LZ4_free(void* p);
-# define ALLOC(s)          LZ4_malloc(s)
-# define ALLOC_AND_ZERO(s) LZ4_calloc(1,s)
-# define FREEMEM(p)        LZ4_free(p)
-#else
-# include <stdlib.h>   /* malloc, calloc, free */
-# define ALLOC(s)          malloc(s)
-# define ALLOC_AND_ZERO(s) calloc(1,s)
-# define FREEMEM(p)        free(p)
-#endif
-
-#if ! LZ4_FREESTANDING
-#  include <string.h>   /* memset, memcpy */
-#endif
-#if !defined(LZ4_memset)
-#  define LZ4_memset(p,v,s) memset((p),(v),(s))
-#endif
-#define MEM_INIT(p,v,s)   LZ4_memset((p),(v),(s))
-
-
-/*-************************************
-*  Common Constants
-**************************************/
-#define MINMATCH 4
-
-#define WILDCOPYLENGTH 8
-#define LASTLITERALS   5   /* see ../doc/lz4_Block_format.md#parsing-restrictions */
-#define MFLIMIT       12   /* see ../doc/lz4_Block_format.md#parsing-restrictions */
-#define MATCH_SAFEGUARD_DISTANCE  ((2*WILDCOPYLENGTH) - MINMATCH)   /* ensure it's possible to write 2 x wildcopyLength without overflowing output buffer */
-#define FASTLOOP_SAFE_DISTANCE 64
-static const int LZ4_minLength = (MFLIMIT+1);
-
-#define KB *(1 <<10)
-#define MB *(1 <<20)
-#define GB *(1U<<30)
-
-#define LZ4_DISTANCE_ABSOLUTE_MAX 65535
-#if (LZ4_DISTANCE_MAX > LZ4_DISTANCE_ABSOLUTE_MAX)   /* max supported by LZ4 format */
-#  error "LZ4_DISTANCE_MAX is too big : must be <= 65535"
-#endif
-
-#define ML_BITS  4
-#define ML_MASK  ((1U<<ML_BITS)-1)
-#define RUN_BITS (8-ML_BITS)
-#define RUN_MASK ((1U<<RUN_BITS)-1)
-
-
-/*-************************************
-*  Error detection
-**************************************/
-#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=1)
-#  include <assert.h>
-#else
-#  ifndef assert
-#    define assert(condition) ((void)0)
-#  endif
-#endif
-
-#define LZ4_STATIC_ASSERT(c)   { enum { LZ4_static_assert = 1/(int)(!!(c)) }; }   /* use after variable declarations */
-
-#if defined(LZ4_DEBUG) && (LZ4_DEBUG>=2)
-#  include <stdio.h>
-   static int g_debuglog_enable = 1;
-#  define DEBUGLOG(l, ...) {                          \
-        if ((g_debuglog_enable) && (l<=LZ4_DEBUG)) {  \
-            fprintf(stderr, __FILE__  " %i: ", __LINE__); \
-            fprintf(stderr, __VA_ARGS__);             \
-            fprintf(stderr, " \n");                   \
-    }   }
-#else
-#  define DEBUGLOG(l, ...) {}    /* disabled */
-#endif
-
-static int LZ4_isAligned(const void* ptr, size_t alignment)
-{
-    return ((size_t)ptr & (alignment -1)) == 0;
-}
-
-
-/*-************************************
-*  Types
-**************************************/
-#include <limits.h>
-#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-# include <stdint.h>
-  typedef  uint8_t BYTE;
-  typedef uint16_t U16;
-  typedef uint32_t U32;
-  typedef  int32_t S32;
-  typedef uint64_t U64;
-  typedef uintptr_t uptrval;
-#else
-# if UINT_MAX != 4294967295UL
-#   error "LZ4 code (when not C++ or C99) assumes that sizeof(int) == 4"
-# endif
-  typedef unsigned char       BYTE;
-  typedef unsigned short      U16;
-  typedef unsigned int        U32;
-  typedef   signed int        S32;
-  typedef unsigned long long  U64;
-  typedef size_t              uptrval;   /* generally true, except OpenVMS-64 */
-#endif
-
-#if defined(__x86_64__)
-  typedef U64    reg_t;   /* 64-bits in x32 mode */
-#else
-  typedef size_t reg_t;   /* 32-bits in x32 mode */
-#endif
-
-typedef enum {
-    notLimited = 0,
-    limitedOutput = 1,
-    fillOutput = 2
-} limitedOutput_directive;
-
-
-/*-************************************
-*  Reading and writing into memory
-**************************************/
-
-/**
- * LZ4 relies on memcpy with a constant size being inlined. In freestanding
- * environments, the compiler can't assume the implementation of memcpy() is
- * standard compliant, so it can't apply its specialized memcpy() inlining
- * logic. When possible, use __builtin_memcpy() to tell the compiler to analyze
- * memcpy() as if it were standard compliant, so it can inline it in freestanding
- * environments. This is needed when decompressing the Linux Kernel, for example.
- */
-#if !defined(LZ4_memcpy)
-#  if defined(__GNUC__) && (__GNUC__ >= 4)
-#    define LZ4_memcpy(dst, src, size) __builtin_memcpy(dst, src, size)
-#  else
-#    define LZ4_memcpy(dst, src, size) memcpy(dst, src, size)
-#  endif
-#endif
-
-#if !defined(LZ4_memmove)
-#  if defined(__GNUC__) && (__GNUC__ >= 4)
-#    define LZ4_memmove __builtin_memmove
-#  else
-#    define LZ4_memmove memmove
-#  endif
-#endif
-
-static unsigned LZ4_isLittleEndian(void)
-{
-    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental */
-    return one.c[0];
-}
-
-#if defined(__GNUC__) || defined(__INTEL_COMPILER)
-#define LZ4_PACK( __Declaration__ ) __Declaration__ __attribute__((__packed__))
-#elif defined(_MSC_VER)
-#define LZ4_PACK( __Declaration__ ) __pragma( pack(push, 1) ) __Declaration__ __pragma( pack(pop))
-#endif
-
-#if defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==2)
-/* lie to the compiler about data alignment; use with caution */
-
-static U16 LZ4_read16(const void* memPtr) { return *(const U16*) memPtr; }
-static U32 LZ4_read32(const void* memPtr) { return *(const U32*) memPtr; }
-static reg_t LZ4_read_ARCH(const void* memPtr) { return *(const reg_t*) memPtr; }
-
-static void LZ4_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
-static void LZ4_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
-
-#elif defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==1)
-
-/* __pack instructions are safer, but compiler specific, hence potentially problematic for some compilers */
-/* currently only defined for gcc and icc */
-LZ4_PACK(typedef struct { U16 u16; }) LZ4_unalign16;
-LZ4_PACK(typedef struct { U32 u32; }) LZ4_unalign32;
-LZ4_PACK(typedef struct { reg_t uArch; }) LZ4_unalignST;
-
-static U16 LZ4_read16(const void* ptr) { return ((const LZ4_unalign16*)ptr)->u16; }
-static U32 LZ4_read32(const void* ptr) { return ((const LZ4_unalign32*)ptr)->u32; }
-static reg_t LZ4_read_ARCH(const void* ptr) { return ((const LZ4_unalignST*)ptr)->uArch; }
-
-static void LZ4_write16(void* memPtr, U16 value) { ((LZ4_unalign16*)memPtr)->u16 = value; }
-static void LZ4_write32(void* memPtr, U32 value) { ((LZ4_unalign32*)memPtr)->u32 = value; }
-
-#else  /* safe and portable access using memcpy() */
-
-static U16 LZ4_read16(const void* memPtr)
-{
-    U16 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-static U32 LZ4_read32(const void* memPtr)
-{
-    U32 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-static reg_t LZ4_read_ARCH(const void* memPtr)
-{
-    reg_t val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-static void LZ4_write16(void* memPtr, U16 value)
-{
-    LZ4_memcpy(memPtr, &value, sizeof(value));
-}
-
-static void LZ4_write32(void* memPtr, U32 value)
-{
-    LZ4_memcpy(memPtr, &value, sizeof(value));
-}
-
-#endif /* LZ4_FORCE_MEMORY_ACCESS */
-
-
-static U16 LZ4_readLE16(const void* memPtr)
-{
-    if (LZ4_isLittleEndian()) {
-        return LZ4_read16(memPtr);
-    } else {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U16)((U16)p[0] | (p[1]<<8));
-    }
-}
-
-#ifdef LZ4_STATIC_LINKING_ONLY_ENDIANNESS_INDEPENDENT_OUTPUT
-static U32 LZ4_readLE32(const void* memPtr)
-{
-    if (LZ4_isLittleEndian()) {
-        return LZ4_read32(memPtr);
-    } else {
-        const BYTE* p = (const BYTE*)memPtr;
-        return (U32)p[0] | (p[1]<<8) | (p[2]<<16) | (p[3]<<24);
-    }
-}
-#endif
-
-static void LZ4_writeLE16(void* memPtr, U16 value)
-{
-    if (LZ4_isLittleEndian()) {
-        LZ4_write16(memPtr, value);
-    } else {
-        BYTE* p = (BYTE*)memPtr;
-        p[0] = (BYTE) value;
-        p[1] = (BYTE)(value>>8);
-    }
-}
-
-/* customized variant of memcpy, which can overwrite up to 8 bytes beyond dstEnd */
-LZ4_FORCE_INLINE
-void LZ4_wildCopy8(void* dstPtr, const void* srcPtr, void* dstEnd)
-{
-    BYTE* d = (BYTE*)dstPtr;
-    const BYTE* s = (const BYTE*)srcPtr;
-    BYTE* const e = (BYTE*)dstEnd;
-
-    do { LZ4_memcpy(d,s,8); d+=8; s+=8; } while (d<e);
-}
-
-static const unsigned inc32table[8] = {0, 1, 2,  1,  0,  4, 4, 4};
-static const int      dec64table[8] = {0, 0, 0, -1, -4,  1, 2, 3};
-
-
-#ifndef LZ4_FAST_DEC_LOOP
-#  if defined __i386__ || defined _M_IX86 || defined __x86_64__ || defined _M_X64
-#    define LZ4_FAST_DEC_LOOP 1
-#  elif defined(__aarch64__) && defined(__APPLE__)
-#    define LZ4_FAST_DEC_LOOP 1
-#  elif defined(__aarch64__) && !defined(__clang__)
-     /* On non-Apple aarch64, we disable this optimization for clang because
-      * on certain mobile chipsets, performance is reduced with clang. For
-      * more information refer to https://github.com/lz4/lz4/pull/707 */
-#    define LZ4_FAST_DEC_LOOP 1
-#  else
-#    define LZ4_FAST_DEC_LOOP 0
-#  endif
-#endif
-
-#if LZ4_FAST_DEC_LOOP
-
-LZ4_FORCE_INLINE void
-LZ4_memcpy_using_offset_base(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
-{
-    assert(srcPtr + offset == dstPtr);
-    if (offset < 8) {
-        LZ4_write32(dstPtr, 0);   /* silence an msan warning when offset==0 */
-        dstPtr[0] = srcPtr[0];
-        dstPtr[1] = srcPtr[1];
-        dstPtr[2] = srcPtr[2];
-        dstPtr[3] = srcPtr[3];
-        srcPtr += inc32table[offset];
-        LZ4_memcpy(dstPtr+4, srcPtr, 4);
-        srcPtr -= dec64table[offset];
-        dstPtr += 8;
-    } else {
-        LZ4_memcpy(dstPtr, srcPtr, 8);
-        dstPtr += 8;
-        srcPtr += 8;
-    }
-
-    LZ4_wildCopy8(dstPtr, srcPtr, dstEnd);
-}
-
-/* customized variant of memcpy, which can overwrite up to 32 bytes beyond dstEnd
- * this version copies two times 16 bytes (instead of one time 32 bytes)
- * because it must be compatible with offsets >= 16. */
-LZ4_FORCE_INLINE void
-LZ4_wildCopy32(void* dstPtr, const void* srcPtr, void* dstEnd)
-{
-    BYTE* d = (BYTE*)dstPtr;
-    const BYTE* s = (const BYTE*)srcPtr;
-    BYTE* const e = (BYTE*)dstEnd;
-
-    do { LZ4_memcpy(d,s,16); LZ4_memcpy(d+16,s+16,16); d+=32; s+=32; } while (d<e);
-}
-
-/* LZ4_memcpy_using_offset()  presumes :
- * - dstEnd >= dstPtr + MINMATCH
- * - there is at least 12 bytes available to write after dstEnd */
-LZ4_FORCE_INLINE void
-LZ4_memcpy_using_offset(BYTE* dstPtr, const BYTE* srcPtr, BYTE* dstEnd, const size_t offset)
-{
-    BYTE v[8];
-
-    assert(dstEnd >= dstPtr + MINMATCH);
-
-    switch(offset) {
-    case 1:
-        MEM_INIT(v, *srcPtr, 8);
-        break;
-    case 2:
-        LZ4_memcpy(v, srcPtr, 2);
-        LZ4_memcpy(&v[2], srcPtr, 2);
-#if defined(_MSC_VER) && (_MSC_VER <= 1937) /* MSVC 2022 ver 17.7 or earlier */
-#  pragma warning(push)
-#  pragma warning(disable : 6385) /* warning C6385: Reading invalid data from 'v'. */
-#endif
-        LZ4_memcpy(&v[4], v, 4);
-#if defined(_MSC_VER) && (_MSC_VER <= 1937) /* MSVC 2022 ver 17.7 or earlier */
-#  pragma warning(pop)
-#endif
-        break;
-    case 4:
-        LZ4_memcpy(v, srcPtr, 4);
-        LZ4_memcpy(&v[4], srcPtr, 4);
-        break;
-    default:
-        LZ4_memcpy_using_offset_base(dstPtr, srcPtr, dstEnd, offset);
-        return;
-    }
-
-    LZ4_memcpy(dstPtr, v, 8);
-    dstPtr += 8;
-    while (dstPtr < dstEnd) {
-        LZ4_memcpy(dstPtr, v, 8);
-        dstPtr += 8;
-    }
-}
-#endif
-
-
-/*-************************************
-*  Common functions
-**************************************/
-static unsigned LZ4_NbCommonBytes (reg_t val)
-{
-    assert(val != 0);
-    if (LZ4_isLittleEndian()) {
-        if (sizeof(val) == 8) {
-#       if defined(_MSC_VER) && (_MSC_VER >= 1800) && (defined(_M_AMD64) && !defined(_M_ARM64EC)) && !defined(LZ4_FORCE_SW_BITCOUNT)
-/*-*************************************************************************************************
-* ARM64EC is a Microsoft-designed ARM64 ABI compatible with AMD64 applications on ARM64 Windows 11.
-* The ARM64EC ABI does not support AVX/AVX2/AVX512 instructions, nor their relevant intrinsics
-* including _tzcnt_u64. Therefore, we need to neuter the _tzcnt_u64 code path for ARM64EC.
-****************************************************************************************************/
-#         if defined(__clang__) && (__clang_major__ < 10)
-            /* Avoid undefined clang-cl intrinsics issue.
-             * See https://github.com/lz4/lz4/pull/1017 for details. */
-            return (unsigned)__builtin_ia32_tzcnt_u64(val) >> 3;
-#         else
-            /* x64 CPUS without BMI support interpret `TZCNT` as `REP BSF` */
-            return (unsigned)_tzcnt_u64(val) >> 3;
-#         endif
-#       elif defined(_MSC_VER) && defined(_WIN64) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r = 0;
-            _BitScanForward64(&r, (U64)val);
-            return (unsigned)r >> 3;
-#       elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
-                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
-                                        !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (unsigned)__builtin_ctzll((U64)val) >> 3;
-#       else
-            const U64 m = 0x0101010101010101ULL;
-            val ^= val - 1;
-            return (unsigned)(((U64)((val & (m - 1)) * m)) >> 56);
-#       endif
-        } else /* 32 bits */ {
-#       if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            unsigned long r;
-            _BitScanForward(&r, (U32)val);
-            return (unsigned)r >> 3;
-#       elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
-                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
-                        !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (unsigned)__builtin_ctz((U32)val) >> 3;
-#       else
-            const U32 m = 0x01010101;
-            return (unsigned)((((val - 1) ^ val) & (m - 1)) * m) >> 24;
-#       endif
-        }
-    } else   /* Big Endian CPU */ {
-        if (sizeof(val)==8) {
-#       if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
-                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
-                        !defined(__TINYC__) && !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (unsigned)__builtin_clzll((U64)val) >> 3;
-#       else
-#if 1
-            /* this method is probably faster,
-             * but adds a 128 bytes lookup table */
-            static const unsigned char ctz7_tab[128] = {
-                7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-                4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
-            };
-            U64 const mask = 0x0101010101010101ULL;
-            U64 const t = (((val >> 8) - mask) | val) & mask;
-            return ctz7_tab[(t * 0x0080402010080402ULL) >> 57];
-#else
-            /* this method doesn't consume memory space like the previous one,
-             * but it contains several branches,
-             * that may end up slowing execution */
-            static const U32 by32 = sizeof(val)*4;  /* 32 on 64 bits (goal), 16 on 32 bits.
-            Just to avoid some static analyzer complaining about shift by 32 on 32-bits target.
-            Note that this code path is never triggered in 32-bits mode. */
-            unsigned r;
-            if (!(val>>by32)) { r=4; } else { r=0; val>>=by32; }
-            if (!(val>>16)) { r+=2; val>>=8; } else { val>>=24; }
-            r += (!val);
-            return r;
-#endif
-#       endif
-        } else /* 32 bits */ {
-#       if (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
-                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
-                                        !defined(LZ4_FORCE_SW_BITCOUNT)
-            return (unsigned)__builtin_clz((U32)val) >> 3;
-#       else
-            val >>= 8;
-            val = ((((val + 0x00FFFF00) | 0x00FFFFFF) + val) |
-              (val + 0x00FF0000)) >> 24;
-            return (unsigned)val ^ 3;
-#       endif
-        }
-    }
-}
-
-
-#define STEPSIZE sizeof(reg_t)
-LZ4_FORCE_INLINE
-unsigned LZ4_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* pInLimit)
-{
-    const BYTE* const pStart = pIn;
-
-    if (likely(pIn < pInLimit-(STEPSIZE-1))) {
-        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
-        if (!diff) {
-            pIn+=STEPSIZE; pMatch+=STEPSIZE;
-        } else {
-            return LZ4_NbCommonBytes(diff);
-    }   }
-
-    while (likely(pIn < pInLimit-(STEPSIZE-1))) {
-        reg_t const diff = LZ4_read_ARCH(pMatch) ^ LZ4_read_ARCH(pIn);
-        if (!diff) { pIn+=STEPSIZE; pMatch+=STEPSIZE; continue; }
-        pIn += LZ4_NbCommonBytes(diff);
-        return (unsigned)(pIn - pStart);
-    }
-
-    if ((STEPSIZE==8) && (pIn<(pInLimit-3)) && (LZ4_read32(pMatch) == LZ4_read32(pIn))) { pIn+=4; pMatch+=4; }
-    if ((pIn<(pInLimit-1)) && (LZ4_read16(pMatch) == LZ4_read16(pIn))) { pIn+=2; pMatch+=2; }
-    if ((pIn<pInLimit) && (*pMatch == *pIn)) pIn++;
-    return (unsigned)(pIn - pStart);
-}
-
-
-#ifndef LZ4_COMMONDEFS_ONLY
-/*-************************************
-*  Local Constants
-**************************************/
-static const int LZ4_64Klimit = ((64 KB) + (MFLIMIT-1));
-static const U32 LZ4_skipTrigger = 6;  /* Increase this value ==> compression run slower on incompressible data */
-
-
-/*-************************************
-*  Local Structures and types
-**************************************/
-typedef enum { clearedTable = 0, byPtr, byU32, byU16 } tableType_t;
-
-/**
- * This enum distinguishes several different modes of accessing previous
- * content in the stream.
- *
- * - noDict        : There is no preceding content.
- * - withPrefix64k : Table entries up to ctx->dictSize before the current blob
- *                   blob being compressed are valid and refer to the preceding
- *                   content (of length ctx->dictSize), which is available
- *                   contiguously preceding in memory the content currently
- *                   being compressed.
- * - usingExtDict  : Like withPrefix64k, but the preceding content is somewhere
- *                   else in memory, starting at ctx->dictionary with length
- *                   ctx->dictSize.
- * - usingDictCtx  : Everything concerning the preceding content is
- *                   in a separate context, pointed to by ctx->dictCtx.
- *                   ctx->dictionary, ctx->dictSize, and table entries
- *                   in the current context that refer to positions
- *                   preceding the beginning of the current compression are
- *                   ignored. Instead, ctx->dictCtx->dictionary and ctx->dictCtx
- *                   ->dictSize describe the location and size of the preceding
- *                   content, and matches are found by looking in the ctx
- *                   ->dictCtx->hashTable.
- */
-typedef enum { noDict = 0, withPrefix64k, usingExtDict, usingDictCtx } dict_directive;
-typedef enum { noDictIssue = 0, dictSmall } dictIssue_directive;
-
-
-/*-************************************
-*  Local Utils
-**************************************/
-int LZ4_versionNumber (void) { return LZ4_VERSION_NUMBER; }
-const char* LZ4_versionString(void) { return LZ4_VERSION_STRING; }
-int LZ4_compressBound(int isize)  { return LZ4_COMPRESSBOUND(isize); }
-int LZ4_sizeofState(void) { return sizeof(LZ4_stream_t); }
-
-
-/*-****************************************
-*  Internal Definitions, used only in Tests
-*******************************************/
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize);
-
-int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,
-                                     int compressedSize, int maxOutputSize,
-                                     const void* dictStart, size_t dictSize);
-int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest,
-                                     int compressedSize, int targetOutputSize, int dstCapacity,
-                                     const void* dictStart, size_t dictSize);
-#if defined (__cplusplus)
-}
-#endif
-
-/*-******************************
-*  Compression functions
-********************************/
-LZ4_FORCE_INLINE U32 LZ4_hash4(U32 sequence, tableType_t const tableType)
-{
-    if (tableType == byU16)
-        return ((sequence * 2654435761U) >> ((MINMATCH*8)-(LZ4_HASHLOG+1)));
-    else
-        return ((sequence * 2654435761U) >> ((MINMATCH*8)-LZ4_HASHLOG));
-}
-
-LZ4_FORCE_INLINE U32 LZ4_hash5(U64 sequence, tableType_t const tableType)
-{
-    const U32 hashLog = (tableType == byU16) ? LZ4_HASHLOG+1 : LZ4_HASHLOG;
-    if (LZ4_isLittleEndian()) {
-        const U64 prime5bytes = 889523592379ULL;
-        return (U32)(((sequence << 24) * prime5bytes) >> (64 - hashLog));
-    } else {
-        const U64 prime8bytes = 11400714785074694791ULL;
-        return (U32)(((sequence >> 24) * prime8bytes) >> (64 - hashLog));
-    }
-}
-
-LZ4_FORCE_INLINE U32 LZ4_hashPosition(const void* const p, tableType_t const tableType)
-{
-    if ((sizeof(reg_t)==8) && (tableType != byU16)) return LZ4_hash5(LZ4_read_ARCH(p), tableType);
-
-#ifdef LZ4_STATIC_LINKING_ONLY_ENDIANNESS_INDEPENDENT_OUTPUT
-    return LZ4_hash4(LZ4_readLE32(p), tableType);
-#else
-    return LZ4_hash4(LZ4_read32(p), tableType);
-#endif
-}
-
-LZ4_FORCE_INLINE void LZ4_clearHash(U32 h, void* tableBase, tableType_t const tableType)
-{
-    switch (tableType)
-    {
-    default: /* fallthrough */
-    case clearedTable: { /* illegal! */ assert(0); return; }
-    case byPtr: { const BYTE** hashTable = (const BYTE**)tableBase; hashTable[h] = NULL; return; }
-    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = 0; return; }
-    case byU16: { U16* hashTable = (U16*) tableBase; hashTable[h] = 0; return; }
-    }
-}
-
-LZ4_FORCE_INLINE void LZ4_putIndexOnHash(U32 idx, U32 h, void* tableBase, tableType_t const tableType)
-{
-    switch (tableType)
-    {
-    default: /* fallthrough */
-    case clearedTable: /* fallthrough */
-    case byPtr: { /* illegal! */ assert(0); return; }
-    case byU32: { U32* hashTable = (U32*) tableBase; hashTable[h] = idx; return; }
-    case byU16: { U16* hashTable = (U16*) tableBase; assert(idx < 65536); hashTable[h] = (U16)idx; return; }
-    }
-}
-
-/* LZ4_putPosition*() : only used in byPtr mode */
-LZ4_FORCE_INLINE void LZ4_putPositionOnHash(const BYTE* p, U32 h,
-                                  void* tableBase, tableType_t const tableType)
-{
-    const BYTE** const hashTable = (const BYTE**)tableBase;
-    assert(tableType == byPtr); (void)tableType;
-    hashTable[h] = p;
-}
-
-LZ4_FORCE_INLINE void LZ4_putPosition(const BYTE* p, void* tableBase, tableType_t tableType)
-{
-    U32 const h = LZ4_hashPosition(p, tableType);
-    LZ4_putPositionOnHash(p, h, tableBase, tableType);
-}
-
-/* LZ4_getIndexOnHash() :
- * Index of match position registered in hash table.
- * hash position must be calculated by using base+index, or dictBase+index.
- * Assumption 1 : only valid if tableType == byU32 or byU16.
- * Assumption 2 : h is presumed valid (within limits of hash table)
- */
-LZ4_FORCE_INLINE U32 LZ4_getIndexOnHash(U32 h, const void* tableBase, tableType_t tableType)
-{
-    LZ4_STATIC_ASSERT(LZ4_MEMORY_USAGE > 2);
-    if (tableType == byU32) {
-        const U32* const hashTable = (const U32*) tableBase;
-        assert(h < (1U << (LZ4_MEMORY_USAGE-2)));
-        return hashTable[h];
-    }
-    if (tableType == byU16) {
-        const U16* const hashTable = (const U16*) tableBase;
-        assert(h < (1U << (LZ4_MEMORY_USAGE-1)));
-        return hashTable[h];
-    }
-    assert(0); return 0;  /* forbidden case */
-}
-
-static const BYTE* LZ4_getPositionOnHash(U32 h, const void* tableBase, tableType_t tableType)
-{
-    assert(tableType == byPtr); (void)tableType;
-    { const BYTE* const* hashTable = (const BYTE* const*) tableBase; return hashTable[h]; }
-}
-
-LZ4_FORCE_INLINE const BYTE*
-LZ4_getPosition(const BYTE* p,
-                const void* tableBase, tableType_t tableType)
-{
-    U32 const h = LZ4_hashPosition(p, tableType);
-    return LZ4_getPositionOnHash(h, tableBase, tableType);
-}
-
-LZ4_FORCE_INLINE void
-LZ4_prepareTable(LZ4_stream_t_internal* const cctx,
-           const int inputSize,
-           const tableType_t tableType) {
-    /* If the table hasn't been used, it's guaranteed to be zeroed out, and is
-     * therefore safe to use no matter what mode we're in. Otherwise, we figure
-     * out if it's safe to leave as is or whether it needs to be reset.
-     */
-    if ((tableType_t)cctx->tableType != clearedTable) {
-        assert(inputSize >= 0);
-        if ((tableType_t)cctx->tableType != tableType
-          || ((tableType == byU16) && cctx->currentOffset + (unsigned)inputSize >= 0xFFFFU)
-          || ((tableType == byU32) && cctx->currentOffset > 1 GB)
-          || tableType == byPtr
-          || inputSize >= 4 KB)
-        {
-            DEBUGLOG(4, "LZ4_prepareTable: Resetting table in %p", cctx);
-            MEM_INIT(cctx->hashTable, 0, LZ4_HASHTABLESIZE);
-            cctx->currentOffset = 0;
-            cctx->tableType = (U32)clearedTable;
-        } else {
-            DEBUGLOG(4, "LZ4_prepareTable: Re-use hash table (no reset)");
-        }
-    }
-
-    /* Adding a gap, so all previous entries are > LZ4_DISTANCE_MAX back,
-     * is faster than compressing without a gap.
-     * However, compressing with currentOffset == 0 is faster still,
-     * so we preserve that case.
-     */
-    if (cctx->currentOffset != 0 && tableType == byU32) {
-        DEBUGLOG(5, "LZ4_prepareTable: adding 64KB to currentOffset");
-        cctx->currentOffset += 64 KB;
-    }
-
-    /* Finally, clear history */
-    cctx->dictCtx = NULL;
-    cctx->dictionary = NULL;
-    cctx->dictSize = 0;
-}
-
-/** LZ4_compress_generic_validated() :
- *  inlined, to ensure branches are decided at compilation time.
- *  The following conditions are presumed already validated:
- *  - source != NULL
- *  - inputSize > 0
- */
-LZ4_FORCE_INLINE int LZ4_compress_generic_validated(
-                 LZ4_stream_t_internal* const cctx,
-                 const char* const source,
-                 char* const dest,
-                 const int inputSize,
-                 int*  inputConsumed, /* only written when outputDirective == fillOutput */
-                 const int maxOutputSize,
-                 const limitedOutput_directive outputDirective,
-                 const tableType_t tableType,
-                 const dict_directive dictDirective,
-                 const dictIssue_directive dictIssue,
-                 const int acceleration)
-{
-    int result;
-    const BYTE* ip = (const BYTE*)source;
-
-    U32 const startIndex = cctx->currentOffset;
-    const BYTE* base = (const BYTE*)source - startIndex;
-    const BYTE* lowLimit;
-
-    const LZ4_stream_t_internal* dictCtx = (const LZ4_stream_t_internal*) cctx->dictCtx;
-    const BYTE* const dictionary =
-        dictDirective == usingDictCtx ? dictCtx->dictionary : cctx->dictionary;
-    const U32 dictSize =
-        dictDirective == usingDictCtx ? dictCtx->dictSize : cctx->dictSize;
-    const U32 dictDelta =
-        (dictDirective == usingDictCtx) ? startIndex - dictCtx->currentOffset : 0;   /* make indexes in dictCtx comparable with indexes in current context */
-
-    int const maybe_extMem = (dictDirective == usingExtDict) || (dictDirective == usingDictCtx);
-    U32 const prefixIdxLimit = startIndex - dictSize;   /* used when dictDirective == dictSmall */
-    const BYTE* const dictEnd = dictionary ? dictionary + dictSize : dictionary;
-    const BYTE* anchor = (const BYTE*) source;
-    const BYTE* const iend = ip + inputSize;
-    const BYTE* const mflimitPlusOne = iend - MFLIMIT + 1;
-    const BYTE* const matchlimit = iend - LASTLITERALS;
-
-    /* the dictCtx currentOffset is indexed on the start of the dictionary,
-     * while a dictionary in the current context precedes the currentOffset */
-    const BYTE* dictBase = (dictionary == NULL) ? NULL :
-                           (dictDirective == usingDictCtx) ?
-                            dictionary + dictSize - dictCtx->currentOffset :
-                            dictionary + dictSize - startIndex;
-
-    BYTE* op = (BYTE*) dest;
-    BYTE* const olimit = op + maxOutputSize;
-
-    U32 offset = 0;
-    U32 forwardH;
-
-    DEBUGLOG(5, "LZ4_compress_generic_validated: srcSize=%i, tableType=%u", inputSize, tableType);
-    assert(ip != NULL);
-    if (tableType == byU16) assert(inputSize<LZ4_64Klimit);  /* Size too large (not within 64K limit) */
-    if (tableType == byPtr) assert(dictDirective==noDict);   /* only supported use case with byPtr */
-    /* If init conditions are not met, we don't have to mark stream
-     * as having dirty context, since no action was taken yet */
-    if (outputDirective == fillOutput && maxOutputSize < 1) { return 0; } /* Impossible to store anything */
-    assert(acceleration >= 1);
-
-    lowLimit = (const BYTE*)source - (dictDirective == withPrefix64k ? dictSize : 0);
-
-    /* Update context state */
-    if (dictDirective == usingDictCtx) {
-        /* Subsequent linked blocks can't use the dictionary. */
-        /* Instead, they use the block we just compressed. */
-        cctx->dictCtx = NULL;
-        cctx->dictSize = (U32)inputSize;
-    } else {
-        cctx->dictSize += (U32)inputSize;
-    }
-    cctx->currentOffset += (U32)inputSize;
-    cctx->tableType = (U32)tableType;
-
-    if (inputSize<LZ4_minLength) goto _last_literals;        /* Input too small, no compression (all literals) */
-
-    /* First Byte */
-    {   U32 const h = LZ4_hashPosition(ip, tableType);
-        if (tableType == byPtr) {
-            LZ4_putPositionOnHash(ip, h, cctx->hashTable, byPtr);
-        } else {
-            LZ4_putIndexOnHash(startIndex, h, cctx->hashTable, tableType);
-    }   }
-    ip++; forwardH = LZ4_hashPosition(ip, tableType);
-
-    /* Main Loop */
-    for ( ; ; ) {
-        const BYTE* match;
-        BYTE* token;
-        const BYTE* filledIp;
-
-        /* Find a match */
-        if (tableType == byPtr) {
-            const BYTE* forwardIp = ip;
-            int step = 1;
-            int searchMatchNb = acceleration << LZ4_skipTrigger;
-            do {
-                U32 const h = forwardH;
-                ip = forwardIp;
-                forwardIp += step;
-                step = (searchMatchNb++ >> LZ4_skipTrigger);
-
-                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
-                assert(ip < mflimitPlusOne);
-
-                match = LZ4_getPositionOnHash(h, cctx->hashTable, tableType);
-                forwardH = LZ4_hashPosition(forwardIp, tableType);
-                LZ4_putPositionOnHash(ip, h, cctx->hashTable, tableType);
-
-            } while ( (match+LZ4_DISTANCE_MAX < ip)
-                   || (LZ4_read32(match) != LZ4_read32(ip)) );
-
-        } else {   /* byU32, byU16 */
-
-            const BYTE* forwardIp = ip;
-            int step = 1;
-            int searchMatchNb = acceleration << LZ4_skipTrigger;
-            do {
-                U32 const h = forwardH;
-                U32 const current = (U32)(forwardIp - base);
-                U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
-                assert(matchIndex <= current);
-                assert(forwardIp - base < (ptrdiff_t)(2 GB - 1));
-                ip = forwardIp;
-                forwardIp += step;
-                step = (searchMatchNb++ >> LZ4_skipTrigger);
-
-                if (unlikely(forwardIp > mflimitPlusOne)) goto _last_literals;
-                assert(ip < mflimitPlusOne);
-
-                if (dictDirective == usingDictCtx) {
-                    if (matchIndex < startIndex) {
-                        /* there was no match, try the dictionary */
-                        assert(tableType == byU32);
-                        matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
-                        match = dictBase + matchIndex;
-                        matchIndex += dictDelta;   /* make dictCtx index comparable with current context */
-                        lowLimit = dictionary;
-                    } else {
-                        match = base + matchIndex;
-                        lowLimit = (const BYTE*)source;
-                    }
-                } else if (dictDirective == usingExtDict) {
-                    if (matchIndex < startIndex) {
-                        DEBUGLOG(7, "extDict candidate: matchIndex=%5u  <  startIndex=%5u", matchIndex, startIndex);
-                        assert(startIndex - matchIndex >= MINMATCH);
-                        assert(dictBase);
-                        match = dictBase + matchIndex;
-                        lowLimit = dictionary;
-                    } else {
-                        match = base + matchIndex;
-                        lowLimit = (const BYTE*)source;
-                    }
-                } else {   /* single continuous memory segment */
-                    match = base + matchIndex;
-                }
-                forwardH = LZ4_hashPosition(forwardIp, tableType);
-                LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
-
-                DEBUGLOG(7, "candidate at pos=%u  (offset=%u \n", matchIndex, current - matchIndex);
-                if ((dictIssue == dictSmall) && (matchIndex < prefixIdxLimit)) { continue; }    /* match outside of valid area */
-                assert(matchIndex < current);
-                if ( ((tableType != byU16) || (LZ4_DISTANCE_MAX < LZ4_DISTANCE_ABSOLUTE_MAX))
-                  && (matchIndex+LZ4_DISTANCE_MAX < current)) {
-                    continue;
-                } /* too far */
-                assert((current - matchIndex) <= LZ4_DISTANCE_MAX);  /* match now expected within distance */
-
-                if (LZ4_read32(match) == LZ4_read32(ip)) {
-                    if (maybe_extMem) offset = current - matchIndex;
-                    break;   /* match found */
-                }
-
-            } while(1);
-        }
-
-        /* Catch up */
-        filledIp = ip;
-        assert(ip > anchor); /* this is always true as ip has been advanced before entering the main loop */
-        if ((match > lowLimit) && unlikely(ip[-1] == match[-1])) {
-            do { ip--; match--; } while (((ip > anchor) & (match > lowLimit)) && (unlikely(ip[-1] == match[-1])));
-        }
-
-        /* Encode Literals */
-        {   unsigned const litLength = (unsigned)(ip - anchor);
-            token = op++;
-            if ((outputDirective == limitedOutput) &&  /* Check output buffer overflow */
-                (unlikely(op + litLength + (2 + 1 + LASTLITERALS) + (litLength/255) > olimit)) ) {
-                return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
-            }
-            if ((outputDirective == fillOutput) &&
-                (unlikely(op + (litLength+240)/255 /* litlen */ + litLength /* literals */ + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit))) {
-                op--;
-                goto _last_literals;
-            }
-            if (litLength >= RUN_MASK) {
-                unsigned len = litLength - RUN_MASK;
-                *token = (RUN_MASK<<ML_BITS);
-                for(; len >= 255 ; len-=255) *op++ = 255;
-                *op++ = (BYTE)len;
-            }
-            else *token = (BYTE)(litLength<<ML_BITS);
-
-            /* Copy Literals */
-            LZ4_wildCopy8(op, anchor, op+litLength);
-            op+=litLength;
-            DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
-                        (int)(anchor-(const BYTE*)source), litLength, (int)(ip-(const BYTE*)source));
-        }
-
-_next_match:
-        /* at this stage, the following variables must be correctly set :
-         * - ip : at start of LZ operation
-         * - match : at start of previous pattern occurrence; can be within current prefix, or within extDict
-         * - offset : if maybe_ext_memSegment==1 (constant)
-         * - lowLimit : must be == dictionary to mean "match is within extDict"; must be == source otherwise
-         * - token and *token : position to write 4-bits for match length; higher 4-bits for literal length supposed already written
-         */
-
-        if ((outputDirective == fillOutput) &&
-            (op + 2 /* offset */ + 1 /* token */ + MFLIMIT - MINMATCH /* min last literals so last match is <= end - MFLIMIT */ > olimit)) {
-            /* the match was too close to the end, rewind and go to last literals */
-            op = token;
-            goto _last_literals;
-        }
-
-        /* Encode Offset */
-        if (maybe_extMem) {   /* static test */
-            DEBUGLOG(6, "             with offset=%u  (ext if > %i)", offset, (int)(ip - (const BYTE*)source));
-            assert(offset <= LZ4_DISTANCE_MAX && offset > 0);
-            LZ4_writeLE16(op, (U16)offset); op+=2;
-        } else  {
-            DEBUGLOG(6, "             with offset=%u  (same segment)", (U32)(ip - match));
-            assert(ip-match <= LZ4_DISTANCE_MAX);
-            LZ4_writeLE16(op, (U16)(ip - match)); op+=2;
-        }
-
-        /* Encode MatchLength */
-        {   unsigned matchCode;
-
-            if ( (dictDirective==usingExtDict || dictDirective==usingDictCtx)
-              && (lowLimit==dictionary) /* match within extDict */ ) {
-                const BYTE* limit = ip + (dictEnd-match);
-                assert(dictEnd > match);
-                if (limit > matchlimit) limit = matchlimit;
-                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, limit);
-                ip += (size_t)matchCode + MINMATCH;
-                if (ip==limit) {
-                    unsigned const more = LZ4_count(limit, (const BYTE*)source, matchlimit);
-                    matchCode += more;
-                    ip += more;
-                }
-                DEBUGLOG(6, "             with matchLength=%u starting in extDict", matchCode+MINMATCH);
-            } else {
-                matchCode = LZ4_count(ip+MINMATCH, match+MINMATCH, matchlimit);
-                ip += (size_t)matchCode + MINMATCH;
-                DEBUGLOG(6, "             with matchLength=%u", matchCode+MINMATCH);
-            }
-
-            if ((outputDirective) &&    /* Check output buffer overflow */
-                (unlikely(op + (1 + LASTLITERALS) + (matchCode+240)/255 > olimit)) ) {
-                if (outputDirective == fillOutput) {
-                    /* Match description too long : reduce it */
-                    U32 newMatchCode = 15 /* in token */ - 1 /* to avoid needing a zero byte */ + ((U32)(olimit - op) - 1 - LASTLITERALS) * 255;
-                    ip -= matchCode - newMatchCode;
-                    assert(newMatchCode < matchCode);
-                    matchCode = newMatchCode;
-                    if (unlikely(ip <= filledIp)) {
-                        /* We have already filled up to filledIp so if ip ends up less than filledIp
-                         * we have positions in the hash table beyond the current position. This is
-                         * a problem if we reuse the hash table. So we have to remove these positions
-                         * from the hash table.
-                         */
-                        const BYTE* ptr;
-                        DEBUGLOG(5, "Clearing %u positions", (U32)(filledIp - ip));
-                        for (ptr = ip; ptr <= filledIp; ++ptr) {
-                            U32 const h = LZ4_hashPosition(ptr, tableType);
-                            LZ4_clearHash(h, cctx->hashTable, tableType);
-                        }
-                    }
-                } else {
-                    assert(outputDirective == limitedOutput);
-                    return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
-                }
-            }
-            if (matchCode >= ML_MASK) {
-                *token += ML_MASK;
-                matchCode -= ML_MASK;
-                LZ4_write32(op, 0xFFFFFFFF);
-                while (matchCode >= 4*255) {
-                    op+=4;
-                    LZ4_write32(op, 0xFFFFFFFF);
-                    matchCode -= 4*255;
-                }
-                op += matchCode / 255;
-                *op++ = (BYTE)(matchCode % 255);
-            } else
-                *token += (BYTE)(matchCode);
-        }
-        /* Ensure we have enough space for the last literals. */
-        assert(!(outputDirective == fillOutput && op + 1 + LASTLITERALS > olimit));
-
-        anchor = ip;
-
-        /* Test end of chunk */
-        if (ip >= mflimitPlusOne) break;
-
-        /* Fill table */
-        {   U32 const h = LZ4_hashPosition(ip-2, tableType);
-            if (tableType == byPtr) {
-                LZ4_putPositionOnHash(ip-2, h, cctx->hashTable, byPtr);
-            } else {
-                U32 const idx = (U32)((ip-2) - base);
-                LZ4_putIndexOnHash(idx, h, cctx->hashTable, tableType);
-        }   }
-
-        /* Test next position */
-        if (tableType == byPtr) {
-
-            match = LZ4_getPosition(ip, cctx->hashTable, tableType);
-            LZ4_putPosition(ip, cctx->hashTable, tableType);
-            if ( (match+LZ4_DISTANCE_MAX >= ip)
-              && (LZ4_read32(match) == LZ4_read32(ip)) )
-            { token=op++; *token=0; goto _next_match; }
-
-        } else {   /* byU32, byU16 */
-
-            U32 const h = LZ4_hashPosition(ip, tableType);
-            U32 const current = (U32)(ip-base);
-            U32 matchIndex = LZ4_getIndexOnHash(h, cctx->hashTable, tableType);
-            assert(matchIndex < current);
-            if (dictDirective == usingDictCtx) {
-                if (matchIndex < startIndex) {
-                    /* there was no match, try the dictionary */
-                    assert(tableType == byU32);
-                    matchIndex = LZ4_getIndexOnHash(h, dictCtx->hashTable, byU32);
-                    match = dictBase + matchIndex;
-                    lowLimit = dictionary;   /* required for match length counter */
-                    matchIndex += dictDelta;
-                } else {
-                    match = base + matchIndex;
-                    lowLimit = (const BYTE*)source;  /* required for match length counter */
-                }
-            } else if (dictDirective==usingExtDict) {
-                if (matchIndex < startIndex) {
-                    assert(dictBase);
-                    match = dictBase + matchIndex;
-                    lowLimit = dictionary;   /* required for match length counter */
-                } else {
-                    match = base + matchIndex;
-                    lowLimit = (const BYTE*)source;   /* required for match length counter */
-                }
-            } else {   /* single memory segment */
-                match = base + matchIndex;
-            }
-            LZ4_putIndexOnHash(current, h, cctx->hashTable, tableType);
-            assert(matchIndex < current);
-            if ( ((dictIssue==dictSmall) ? (matchIndex >= prefixIdxLimit) : 1)
-              && (((tableType==byU16) && (LZ4_DISTANCE_MAX == LZ4_DISTANCE_ABSOLUTE_MAX)) ? 1 : (matchIndex+LZ4_DISTANCE_MAX >= current))
-              && (LZ4_read32(match) == LZ4_read32(ip)) ) {
-                token=op++;
-                *token=0;
-                if (maybe_extMem) offset = current - matchIndex;
-                DEBUGLOG(6, "seq.start:%i, literals=%u, match.start:%i",
-                            (int)(anchor-(const BYTE*)source), 0, (int)(ip-(const BYTE*)source));
-                goto _next_match;
-            }
-        }
-
-        /* Prepare next loop */
-        forwardH = LZ4_hashPosition(++ip, tableType);
-
-    }
-
-_last_literals:
-    /* Encode Last Literals */
-    {   size_t lastRun = (size_t)(iend - anchor);
-        if ( (outputDirective) &&  /* Check output buffer overflow */
-            (op + lastRun + 1 + ((lastRun+255-RUN_MASK)/255) > olimit)) {
-            if (outputDirective == fillOutput) {
-                /* adapt lastRun to fill 'dst' */
-                assert(olimit >= op);
-                lastRun  = (size_t)(olimit-op) - 1/*token*/;
-                lastRun -= (lastRun + 256 - RUN_MASK) / 256;  /*additional length tokens*/
-            } else {
-                assert(outputDirective == limitedOutput);
-                return 0;   /* cannot compress within `dst` budget. Stored indexes in hash table are nonetheless fine */
-            }
-        }
-        DEBUGLOG(6, "Final literal run : %i literals", (int)lastRun);
-        if (lastRun >= RUN_MASK) {
-            size_t accumulator = lastRun - RUN_MASK;
-            *op++ = RUN_MASK << ML_BITS;
-            for(; accumulator >= 255 ; accumulator-=255) *op++ = 255;
-            *op++ = (BYTE) accumulator;
-        } else {
-            *op++ = (BYTE)(lastRun<<ML_BITS);
-        }
-        LZ4_memcpy(op, anchor, lastRun);
-        ip = anchor + lastRun;
-        op += lastRun;
-    }
-
-    if (outputDirective == fillOutput) {
-        *inputConsumed = (int) (((const char*)ip)-source);
-    }
-    result = (int)(((char*)op) - dest);
-    assert(result > 0);
-    DEBUGLOG(5, "LZ4_compress_generic: compressed %i bytes into %i bytes", inputSize, result);
-    return result;
-}
-
-/** LZ4_compress_generic() :
- *  inlined, to ensure branches are decided at compilation time;
- *  takes care of src == (NULL, 0)
- *  and forward the rest to LZ4_compress_generic_validated */
-LZ4_FORCE_INLINE int LZ4_compress_generic(
-                 LZ4_stream_t_internal* const cctx,
-                 const char* const src,
-                 char* const dst,
-                 const int srcSize,
-                 int *inputConsumed, /* only written when outputDirective == fillOutput */
-                 const int dstCapacity,
-                 const limitedOutput_directive outputDirective,
-                 const tableType_t tableType,
-                 const dict_directive dictDirective,
-                 const dictIssue_directive dictIssue,
-                 const int acceleration)
-{
-    DEBUGLOG(5, "LZ4_compress_generic: srcSize=%i, dstCapacity=%i",
-                srcSize, dstCapacity);
-
-    if ((U32)srcSize > (U32)LZ4_MAX_INPUT_SIZE) { return 0; }  /* Unsupported srcSize, too large (or negative) */
-    if (srcSize == 0) {   /* src == NULL supported if srcSize == 0 */
-        if (outputDirective != notLimited && dstCapacity <= 0) return 0;  /* no output, can't write anything */
-        DEBUGLOG(5, "Generating an empty block");
-        assert(outputDirective == notLimited || dstCapacity >= 1);
-        assert(dst != NULL);
-        dst[0] = 0;
-        if (outputDirective == fillOutput) {
-            assert (inputConsumed != NULL);
-            *inputConsumed = 0;
-        }
-        return 1;
-    }
-    assert(src != NULL);
-
-    return LZ4_compress_generic_validated(cctx, src, dst, srcSize,
-                inputConsumed, /* only written into if outputDirective == fillOutput */
-                dstCapacity, outputDirective,
-                tableType, dictDirective, dictIssue, acceleration);
-}
-
-
-int LZ4_compress_fast_extState(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int acceleration)
-{
-    LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;
-    assert(ctx != NULL);
-    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
-    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
-    if (maxOutputSize >= LZ4_compressBound(inputSize)) {
-        if (inputSize < LZ4_64Klimit) {
-            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, byU16, noDict, noDictIssue, acceleration);
-        } else {
-            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
-        }
-    } else {
-        if (inputSize < LZ4_64Klimit) {
-            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, byU16, noDict, noDictIssue, acceleration);
-        } else {
-            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)source > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            return LZ4_compress_generic(ctx, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, noDict, noDictIssue, acceleration);
-        }
-    }
-}
-
-/**
- * LZ4_compress_fast_extState_fastReset() :
- * A variant of LZ4_compress_fast_extState().
- *
- * Using this variant avoids an expensive initialization step. It is only safe
- * to call if the state buffer is known to be correctly initialized already
- * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of
- * "correctly initialized").
- */
-int LZ4_compress_fast_extState_fastReset(void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration)
-{
-    LZ4_stream_t_internal* const ctx = &((LZ4_stream_t*)state)->internal_donotuse;
-    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
-    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
-    assert(ctx != NULL);
-
-    if (dstCapacity >= LZ4_compressBound(srcSize)) {
-        if (srcSize < LZ4_64Klimit) {
-            const tableType_t tableType = byU16;
-            LZ4_prepareTable(ctx, srcSize, tableType);
-            if (ctx->currentOffset) {
-                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, dictSmall, acceleration);
-            } else {
-                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
-            }
-        } else {
-            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            LZ4_prepareTable(ctx, srcSize, tableType);
-            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, 0, notLimited, tableType, noDict, noDictIssue, acceleration);
-        }
-    } else {
-        if (srcSize < LZ4_64Klimit) {
-            const tableType_t tableType = byU16;
-            LZ4_prepareTable(ctx, srcSize, tableType);
-            if (ctx->currentOffset) {
-                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, dictSmall, acceleration);
-            } else {
-                return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
-            }
-        } else {
-            const tableType_t tableType = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            LZ4_prepareTable(ctx, srcSize, tableType);
-            return LZ4_compress_generic(ctx, src, dst, srcSize, NULL, dstCapacity, limitedOutput, tableType, noDict, noDictIssue, acceleration);
-        }
-    }
-}
-
-
-int LZ4_compress_fast(const char* src, char* dest, int srcSize, int dstCapacity, int acceleration)
-{
-    int result;
-#if (LZ4_HEAPMODE)
-    LZ4_stream_t* const ctxPtr = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
-    if (ctxPtr == NULL) return 0;
-#else
-    LZ4_stream_t ctx;
-    LZ4_stream_t* const ctxPtr = &ctx;
-#endif
-    result = LZ4_compress_fast_extState(ctxPtr, src, dest, srcSize, dstCapacity, acceleration);
-
-#if (LZ4_HEAPMODE)
-    FREEMEM(ctxPtr);
-#endif
-    return result;
-}
-
-
-int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity)
-{
-    return LZ4_compress_fast(src, dst, srcSize, dstCapacity, 1);
-}
-
-
-/* Note!: This function leaves the stream in an unclean/broken state!
- * It is not safe to subsequently use the same state with a _fastReset() or
- * _continue() call without resetting it. */
-static int LZ4_compress_destSize_extState_internal(LZ4_stream_t* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize, int acceleration)
-{
-    void* const s = LZ4_initStream(state, sizeof (*state));
-    assert(s != NULL); (void)s;
-
-    if (targetDstSize >= LZ4_compressBound(*srcSizePtr)) {  /* compression success is guaranteed */
-        return LZ4_compress_fast_extState(state, src, dst, *srcSizePtr, targetDstSize, acceleration);
-    } else {
-        if (*srcSizePtr < LZ4_64Klimit) {
-            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, byU16, noDict, noDictIssue, acceleration);
-        } else {
-            tableType_t const addrMode = ((sizeof(void*)==4) && ((uptrval)src > LZ4_DISTANCE_MAX)) ? byPtr : byU32;
-            return LZ4_compress_generic(&state->internal_donotuse, src, dst, *srcSizePtr, srcSizePtr, targetDstSize, fillOutput, addrMode, noDict, noDictIssue, acceleration);
-    }   }
-}
-
-int LZ4_compress_destSize_extState(void* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize, int acceleration)
-{
-    int const r = LZ4_compress_destSize_extState_internal((LZ4_stream_t*)state, src, dst, srcSizePtr, targetDstSize, acceleration);
-    /* clean the state on exit */
-    LZ4_initStream(state, sizeof (LZ4_stream_t));
-    return r;
-}
-
-
-int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize)
-{
-#if (LZ4_HEAPMODE)
-    LZ4_stream_t* const ctx = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));   /* malloc-calloc always properly aligned */
-    if (ctx == NULL) return 0;
-#else
-    LZ4_stream_t ctxBody;
-    LZ4_stream_t* const ctx = &ctxBody;
-#endif
-
-    int result = LZ4_compress_destSize_extState_internal(ctx, src, dst, srcSizePtr, targetDstSize, 1);
-
-#if (LZ4_HEAPMODE)
-    FREEMEM(ctx);
-#endif
-    return result;
-}
-
-
-
-/*-******************************
-*  Streaming functions
-********************************/
-
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-LZ4_stream_t* LZ4_createStream(void)
-{
-    LZ4_stream_t* const lz4s = (LZ4_stream_t*)ALLOC(sizeof(LZ4_stream_t));
-    LZ4_STATIC_ASSERT(sizeof(LZ4_stream_t) >= sizeof(LZ4_stream_t_internal));
-    DEBUGLOG(4, "LZ4_createStream %p", lz4s);
-    if (lz4s == NULL) return NULL;
-    LZ4_initStream(lz4s, sizeof(*lz4s));
-    return lz4s;
-}
-#endif
-
-static size_t LZ4_stream_t_alignment(void)
-{
-#if LZ4_ALIGN_TEST
-    typedef struct { char c; LZ4_stream_t t; } t_a;
-    return sizeof(t_a) - sizeof(LZ4_stream_t);
-#else
-    return 1;  /* effectively disabled */
-#endif
-}
-
-LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
-{
-    DEBUGLOG(5, "LZ4_initStream");
-    if (buffer == NULL) { return NULL; }
-    if (size < sizeof(LZ4_stream_t)) { return NULL; }
-    if (!LZ4_isAligned(buffer, LZ4_stream_t_alignment())) return NULL;
-    MEM_INIT(buffer, 0, sizeof(LZ4_stream_t_internal));
-    return (LZ4_stream_t*)buffer;
-}
-
-/* resetStream is now deprecated,
- * prefer initStream() which is more general */
-void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
-{
-    DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);
-    MEM_INIT(LZ4_stream, 0, sizeof(LZ4_stream_t_internal));
-}
-
-void LZ4_resetStream_fast(LZ4_stream_t* ctx) {
-    LZ4_prepareTable(&(ctx->internal_donotuse), 0, byU32);
-}
-
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
-{
-    if (!LZ4_stream) return 0;   /* support free on NULL */
-    DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);
-    FREEMEM(LZ4_stream);
-    return (0);
-}
-#endif
-
-
-typedef enum { _ld_fast, _ld_slow } LoadDict_mode_e;
-#define HASH_UNIT sizeof(reg_t)
-int LZ4_loadDict_internal(LZ4_stream_t* LZ4_dict,
-                    const char* dictionary, int dictSize,
-                    LoadDict_mode_e _ld)
-{
-    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
-    const tableType_t tableType = byU32;
-    const BYTE* p = (const BYTE*)dictionary;
-    const BYTE* const dictEnd = p + dictSize;
-    U32 idx32;
-
-    DEBUGLOG(4, "LZ4_loadDict (%i bytes from %p into %p)", dictSize, dictionary, LZ4_dict);
-
-    /* It's necessary to reset the context,
-     * and not just continue it with prepareTable()
-     * to avoid any risk of generating overflowing matchIndex
-     * when compressing using this dictionary */
-    LZ4_resetStream(LZ4_dict);
-
-    /* We always increment the offset by 64 KB, since, if the dict is longer,
-     * we truncate it to the last 64k, and if it's shorter, we still want to
-     * advance by a whole window length so we can provide the guarantee that
-     * there are only valid offsets in the window, which allows an optimization
-     * in LZ4_compress_fast_continue() where it uses noDictIssue even when the
-     * dictionary isn't a full 64k. */
-    dict->currentOffset += 64 KB;
-
-    if (dictSize < (int)HASH_UNIT) {
-        return 0;
-    }
-
-    if ((dictEnd - p) > 64 KB) p = dictEnd - 64 KB;
-    dict->dictionary = p;
-    dict->dictSize = (U32)(dictEnd - p);
-    dict->tableType = (U32)tableType;
-    idx32 = dict->currentOffset - dict->dictSize;
-
-    while (p <= dictEnd-HASH_UNIT) {
-        U32 const h = LZ4_hashPosition(p, tableType);
-        /* Note: overwriting => favors positions end of dictionary */
-        LZ4_putIndexOnHash(idx32, h, dict->hashTable, tableType);
-        p+=3; idx32+=3;
-    }
-
-    if (_ld == _ld_slow) {
-        /* Fill hash table with additional references, to improve compression capability */
-        p = dict->dictionary;
-        idx32 = dict->currentOffset - dict->dictSize;
-        while (p <= dictEnd-HASH_UNIT) {
-            U32 const h = LZ4_hashPosition(p, tableType);
-            U32 const limit = dict->currentOffset - 64 KB;
-            if (LZ4_getIndexOnHash(h, dict->hashTable, tableType) <= limit) {
-                /* Note: not overwriting => favors positions beginning of dictionary */
-                LZ4_putIndexOnHash(idx32, h, dict->hashTable, tableType);
-            }
-            p++; idx32++;
-        }
-    }
-
-    return (int)dict->dictSize;
-}
-
-int LZ4_loadDict(LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
-{
-    return LZ4_loadDict_internal(LZ4_dict, dictionary, dictSize, _ld_fast);
-}
-
-int LZ4_loadDictSlow(LZ4_stream_t* LZ4_dict, const char* dictionary, int dictSize)
-{
-    return LZ4_loadDict_internal(LZ4_dict, dictionary, dictSize, _ld_slow);
-}
-
-void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream)
-{
-    const LZ4_stream_t_internal* dictCtx = (dictionaryStream == NULL) ? NULL :
-        &(dictionaryStream->internal_donotuse);
-
-    DEBUGLOG(4, "LZ4_attach_dictionary (%p, %p, size %u)",
-             workingStream, dictionaryStream,
-             dictCtx != NULL ? dictCtx->dictSize : 0);
-
-    if (dictCtx != NULL) {
-        /* If the current offset is zero, we will never look in the
-         * external dictionary context, since there is no value a table
-         * entry can take that indicate a miss. In that case, we need
-         * to bump the offset to something non-zero.
-         */
-        if (workingStream->internal_donotuse.currentOffset == 0) {
-            workingStream->internal_donotuse.currentOffset = 64 KB;
-        }
-
-        /* Don't actually attach an empty dictionary.
-         */
-        if (dictCtx->dictSize == 0) {
-            dictCtx = NULL;
-        }
-    }
-    workingStream->internal_donotuse.dictCtx = dictCtx;
-}
-
-
-static void LZ4_renormDictT(LZ4_stream_t_internal* LZ4_dict, int nextSize)
-{
-    assert(nextSize >= 0);
-    if (LZ4_dict->currentOffset + (unsigned)nextSize > 0x80000000) {   /* potential ptrdiff_t overflow (32-bits mode) */
-        /* rescale hash table */
-        U32 const delta = LZ4_dict->currentOffset - 64 KB;
-        const BYTE* dictEnd = LZ4_dict->dictionary + LZ4_dict->dictSize;
-        int i;
-        DEBUGLOG(4, "LZ4_renormDictT");
-        for (i=0; i<LZ4_HASH_SIZE_U32; i++) {
-            if (LZ4_dict->hashTable[i] < delta) LZ4_dict->hashTable[i]=0;
-            else LZ4_dict->hashTable[i] -= delta;
-        }
-        LZ4_dict->currentOffset = 64 KB;
-        if (LZ4_dict->dictSize > 64 KB) LZ4_dict->dictSize = 64 KB;
-        LZ4_dict->dictionary = dictEnd - LZ4_dict->dictSize;
-    }
-}
-
-
-int LZ4_compress_fast_continue (LZ4_stream_t* LZ4_stream,
-                                const char* source, char* dest,
-                                int inputSize, int maxOutputSize,
-                                int acceleration)
-{
-    const tableType_t tableType = byU32;
-    LZ4_stream_t_internal* const streamPtr = &LZ4_stream->internal_donotuse;
-    const char* dictEnd = streamPtr->dictSize ? (const char*)streamPtr->dictionary + streamPtr->dictSize : NULL;
-
-    DEBUGLOG(5, "LZ4_compress_fast_continue (inputSize=%i, dictSize=%u)", inputSize, streamPtr->dictSize);
-
-    LZ4_renormDictT(streamPtr, inputSize);   /* fix index overflow */
-    if (acceleration < 1) acceleration = LZ4_ACCELERATION_DEFAULT;
-    if (acceleration > LZ4_ACCELERATION_MAX) acceleration = LZ4_ACCELERATION_MAX;
-
-    /* invalidate tiny dictionaries */
-    if ( (streamPtr->dictSize < 4)     /* tiny dictionary : not enough for a hash */
-      && (dictEnd != source)           /* prefix mode */
-      && (inputSize > 0)               /* tolerance : don't lose history, in case next invocation would use prefix mode */
-      && (streamPtr->dictCtx == NULL)  /* usingDictCtx */
-      ) {
-        DEBUGLOG(5, "LZ4_compress_fast_continue: dictSize(%u) at addr:%p is too small", streamPtr->dictSize, streamPtr->dictionary);
-        /* remove dictionary existence from history, to employ faster prefix mode */
-        streamPtr->dictSize = 0;
-        streamPtr->dictionary = (const BYTE*)source;
-        dictEnd = source;
-    }
-
-    /* Check overlapping input/dictionary space */
-    {   const char* const sourceEnd = source + inputSize;
-        if ((sourceEnd > (const char*)streamPtr->dictionary) && (sourceEnd < dictEnd)) {
-            streamPtr->dictSize = (U32)(dictEnd - sourceEnd);
-            if (streamPtr->dictSize > 64 KB) streamPtr->dictSize = 64 KB;
-            if (streamPtr->dictSize < 4) streamPtr->dictSize = 0;
-            streamPtr->dictionary = (const BYTE*)dictEnd - streamPtr->dictSize;
-        }
-    }
-
-    /* prefix mode : source data follows dictionary */
-    if (dictEnd == source) {
-        if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset))
-            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, dictSmall, acceleration);
-        else
-            return LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, withPrefix64k, noDictIssue, acceleration);
-    }
-
-    /* external dictionary mode */
-    {   int result;
-        if (streamPtr->dictCtx) {
-            /* We depend here on the fact that dictCtx'es (produced by
-             * LZ4_loadDict) guarantee that their tables contain no references
-             * to offsets between dictCtx->currentOffset - 64 KB and
-             * dictCtx->currentOffset - dictCtx->dictSize. This makes it safe
-             * to use noDictIssue even when the dict isn't a full 64 KB.
-             */
-            if (inputSize > 4 KB) {
-                /* For compressing large blobs, it is faster to pay the setup
-                 * cost to copy the dictionary's tables into the active context,
-                 * so that the compression loop is only looking into one table.
-                 */
-                LZ4_memcpy(streamPtr, streamPtr->dictCtx, sizeof(*streamPtr));
-                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
-            } else {
-                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingDictCtx, noDictIssue, acceleration);
-            }
-        } else {  /* small data <= 4 KB */
-            if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
-                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, dictSmall, acceleration);
-            } else {
-                result = LZ4_compress_generic(streamPtr, source, dest, inputSize, NULL, maxOutputSize, limitedOutput, tableType, usingExtDict, noDictIssue, acceleration);
-            }
-        }
-        streamPtr->dictionary = (const BYTE*)source;
-        streamPtr->dictSize = (U32)inputSize;
-        return result;
-    }
-}
-
-
-/* Hidden debug function, to force-test external dictionary mode */
-int LZ4_compress_forceExtDict (LZ4_stream_t* LZ4_dict, const char* source, char* dest, int srcSize)
-{
-    LZ4_stream_t_internal* const streamPtr = &LZ4_dict->internal_donotuse;
-    int result;
-
-    LZ4_renormDictT(streamPtr, srcSize);
-
-    if ((streamPtr->dictSize < 64 KB) && (streamPtr->dictSize < streamPtr->currentOffset)) {
-        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, dictSmall, 1);
-    } else {
-        result = LZ4_compress_generic(streamPtr, source, dest, srcSize, NULL, 0, notLimited, byU32, usingExtDict, noDictIssue, 1);
-    }
-
-    streamPtr->dictionary = (const BYTE*)source;
-    streamPtr->dictSize = (U32)srcSize;
-
-    return result;
-}
-
-
-/*! LZ4_saveDict() :
- *  If previously compressed data block is not guaranteed to remain available at its memory location,
- *  save it into a safer place (char* safeBuffer).
- *  Note : no need to call LZ4_loadDict() afterwards, dictionary is immediately usable,
- *         one can therefore call LZ4_compress_fast_continue() right after.
- * @return : saved dictionary size in bytes (necessarily <= dictSize), or 0 if error.
- */
-int LZ4_saveDict (LZ4_stream_t* LZ4_dict, char* safeBuffer, int dictSize)
-{
-    LZ4_stream_t_internal* const dict = &LZ4_dict->internal_donotuse;
-
-    DEBUGLOG(5, "LZ4_saveDict : dictSize=%i, safeBuffer=%p", dictSize, safeBuffer);
-
-    if ((U32)dictSize > 64 KB) { dictSize = 64 KB; } /* useless to define a dictionary > 64 KB */
-    if ((U32)dictSize > dict->dictSize) { dictSize = (int)dict->dictSize; }
-
-    if (safeBuffer == NULL) assert(dictSize == 0);
-    if (dictSize > 0) {
-        const BYTE* const previousDictEnd = dict->dictionary + dict->dictSize;
-        assert(dict->dictionary);
-        LZ4_memmove(safeBuffer, previousDictEnd - dictSize, (size_t)dictSize);
-    }
-
-    dict->dictionary = (const BYTE*)safeBuffer;
-    dict->dictSize = (U32)dictSize;
-
-    return dictSize;
-}
-
-
-
-/*-*******************************
- *  Decompression functions
- ********************************/
-
-typedef enum { decode_full_block = 0, partial_decode = 1 } earlyEnd_directive;
-
-#undef MIN
-#define MIN(a,b)    ( (a) < (b) ? (a) : (b) )
-
-
-/* variant for decompress_unsafe()
- * does not know end of input
- * presumes input is well formed
- * note : will consume at least one byte */
-static size_t read_long_length_no_check(const BYTE** pp)
-{
-    size_t b, l = 0;
-    do { b = **pp; (*pp)++; l += b; } while (b==255);
-    DEBUGLOG(6, "read_long_length_no_check: +length=%zu using %zu input bytes", l, l/255 + 1)
-    return l;
-}
-
-/* core decoder variant for LZ4_decompress_fast*()
- * for legacy support only : these entry points are deprecated.
- * - Presumes input is correctly formed (no defense vs malformed inputs)
- * - Does not know input size (presume input buffer is "large enough")
- * - Decompress a full block (only)
- * @return : nb of bytes read from input.
- * Note : this variant is not optimized for speed, just for maintenance.
- *        the goal is to remove support of decompress_fast*() variants by v2.0
-**/
-LZ4_FORCE_INLINE int
-LZ4_decompress_unsafe_generic(
-                 const BYTE* const istart,
-                 BYTE* const ostart,
-                 int decompressedSize,
-
-                 size_t prefixSize,
-                 const BYTE* const dictStart,  /* only if dict==usingExtDict */
-                 const size_t dictSize         /* note: =0 if dictStart==NULL */
-                 )
-{
-    const BYTE* ip = istart;
-    BYTE* op = (BYTE*)ostart;
-    BYTE* const oend = ostart + decompressedSize;
-    const BYTE* const prefixStart = ostart - prefixSize;
-
-    DEBUGLOG(5, "LZ4_decompress_unsafe_generic");
-    if (dictStart == NULL) assert(dictSize == 0);
-
-    while (1) {
-        /* start new sequence */
-        unsigned token = *ip++;
-
-        /* literals */
-        {   size_t ll = token >> ML_BITS;
-            if (ll==15) {
-                /* long literal length */
-                ll += read_long_length_no_check(&ip);
-            }
-            if ((size_t)(oend-op) < ll) return -1; /* output buffer overflow */
-            LZ4_memmove(op, ip, ll); /* support in-place decompression */
-            op += ll;
-            ip += ll;
-            if ((size_t)(oend-op) < MFLIMIT) {
-                if (op==oend) break;  /* end of block */
-                DEBUGLOG(5, "invalid: literals end at distance %zi from end of block", oend-op);
-                /* incorrect end of block :
-                 * last match must start at least MFLIMIT==12 bytes before end of output block */
-                return -1;
-        }   }
-
-        /* match */
-        {   size_t ml = token & 15;
-            size_t const offset = LZ4_readLE16(ip);
-            ip+=2;
-
-            if (ml==15) {
-                /* long literal length */
-                ml += read_long_length_no_check(&ip);
-            }
-            ml += MINMATCH;
-
-            if ((size_t)(oend-op) < ml) return -1; /* output buffer overflow */
-
-            {   const BYTE* match = op - offset;
-
-                /* out of range */
-                if (offset > (size_t)(op - prefixStart) + dictSize) {
-                    DEBUGLOG(6, "offset out of range");
-                    return -1;
-                }
-
-                /* check special case : extDict */
-                if (offset > (size_t)(op - prefixStart)) {
-                    /* extDict scenario */
-                    const BYTE* const dictEnd = dictStart + dictSize;
-                    const BYTE* extMatch = dictEnd - (offset - (size_t)(op-prefixStart));
-                    size_t const extml = (size_t)(dictEnd - extMatch);
-                    if (extml > ml) {
-                        /* match entirely within extDict */
-                        LZ4_memmove(op, extMatch, ml);
-                        op += ml;
-                        ml = 0;
-                    } else {
-                        /* match split between extDict & prefix */
-                        LZ4_memmove(op, extMatch, extml);
-                        op += extml;
-                        ml -= extml;
-                    }
-                    match = prefixStart;
-                }
-
-                /* match copy - slow variant, supporting overlap copy */
-                {   size_t u;
-                    for (u=0; u<ml; u++) {
-                        op[u] = match[u];
-            }   }   }
-            op += ml;
-            if ((size_t)(oend-op) < LASTLITERALS) {
-                DEBUGLOG(5, "invalid: match ends at distance %zi from end of block", oend-op);
-                /* incorrect end of block :
-                 * last match must stop at least LASTLITERALS==5 bytes before end of output block */
-                return -1;
-            }
-        } /* match */
-    } /* main loop */
-    return (int)(ip - istart);
-}
-
-
-/* Read the variable-length literal or match length.
- *
- * @ip : input pointer
- * @ilimit : position after which if length is not decoded, the input is necessarily corrupted.
- * @initial_check - check ip >= ipmax before start of loop.  Returns initial_error if so.
- * @error (output) - error code.  Must be set to 0 before call.
-**/
-typedef size_t Rvl_t;
-static const Rvl_t rvl_error = (Rvl_t)(-1);
-LZ4_FORCE_INLINE Rvl_t
-read_variable_length(const BYTE** ip, const BYTE* ilimit,
-                     int initial_check)
-{
-    Rvl_t s, length = 0;
-    assert(ip != NULL);
-    assert(*ip !=  NULL);
-    assert(ilimit != NULL);
-    if (initial_check && unlikely((*ip) >= ilimit)) {    /* read limit reached */
-        return rvl_error;
-    }
-    s = **ip;
-    (*ip)++;
-    length += s;
-    if (unlikely((*ip) > ilimit)) {    /* read limit reached */
-        return rvl_error;
-    }
-    /* accumulator overflow detection (32-bit mode only) */
-    if ((sizeof(length) < 8) && unlikely(length > ((Rvl_t)(-1)/2)) ) {
-        return rvl_error;
-    }
-    if (likely(s != 255)) return length;
-    do {
-        s = **ip;
-        (*ip)++;
-        length += s;
-        if (unlikely((*ip) > ilimit)) {    /* read limit reached */
-            return rvl_error;
-        }
-        /* accumulator overflow detection (32-bit mode only) */
-        if ((sizeof(length) < 8) && unlikely(length > ((Rvl_t)(-1)/2)) ) {
-            return rvl_error;
-        }
-    } while (s == 255);
-
-    return length;
-}
-
-/*! LZ4_decompress_generic() :
- *  This generic decompression function covers all use cases.
- *  It shall be instantiated several times, using different sets of directives.
- *  Note that it is important for performance that this function really get inlined,
- *  in order to remove useless branches during compilation optimization.
- */
-LZ4_FORCE_INLINE int
-LZ4_decompress_generic(
-                 const char* const src,
-                 char* const dst,
-                 int srcSize,
-                 int outputSize,         /* If endOnInput==endOnInputSize, this value is `dstCapacity` */
-
-                 earlyEnd_directive partialDecoding,  /* full, partial */
-                 dict_directive dict,                 /* noDict, withPrefix64k, usingExtDict */
-                 const BYTE* const lowPrefix,  /* always <= dst, == dst when no prefix */
-                 const BYTE* const dictStart,  /* only if dict==usingExtDict */
-                 const size_t dictSize         /* note : = 0 if noDict */
-                 )
-{
-    if ((src == NULL) || (outputSize < 0)) { return -1; }
-
-    {   const BYTE* ip = (const BYTE*) src;
-        const BYTE* const iend = ip + srcSize;
-
-        BYTE* op = (BYTE*) dst;
-        BYTE* const oend = op + outputSize;
-        BYTE* cpy;
-
-        const BYTE* const dictEnd = (dictStart == NULL) ? NULL : dictStart + dictSize;
-
-        const int checkOffset = (dictSize < (int)(64 KB));
-
-
-        /* Set up the "end" pointers for the shortcut. */
-        const BYTE* const shortiend = iend - 14 /*maxLL*/ - 2 /*offset*/;
-        const BYTE* const shortoend = oend - 14 /*maxLL*/ - 18 /*maxML*/;
-
-        const BYTE* match;
-        size_t offset;
-        unsigned token;
-        size_t length;
-
-
-        DEBUGLOG(5, "LZ4_decompress_generic (srcSize:%i, dstSize:%i)", srcSize, outputSize);
-
-        /* Special cases */
-        assert(lowPrefix <= op);
-        if (unlikely(outputSize==0)) {
-            /* Empty output buffer */
-            if (partialDecoding) return 0;
-            return ((srcSize==1) && (*ip==0)) ? 0 : -1;
-        }
-        if (unlikely(srcSize==0)) { return -1; }
-
-    /* LZ4_FAST_DEC_LOOP:
-     * designed for modern OoO performance cpus,
-     * where copying reliably 32-bytes is preferable to an unpredictable branch.
-     * note : fast loop may show a regression for some client arm chips. */
-#if LZ4_FAST_DEC_LOOP
-        if ((oend - op) < FASTLOOP_SAFE_DISTANCE) {
-            DEBUGLOG(6, "move to safe decode loop");
-            goto safe_decode;
-        }
-
-        /* Fast loop : decode sequences as long as output < oend-FASTLOOP_SAFE_DISTANCE */
-        DEBUGLOG(6, "using fast decode loop");
-        while (1) {
-            /* Main fastloop assertion: We can always wildcopy FASTLOOP_SAFE_DISTANCE */
-            assert(oend - op >= FASTLOOP_SAFE_DISTANCE);
-            assert(ip < iend);
-            token = *ip++;
-            length = token >> ML_BITS;  /* literal length */
-            DEBUGLOG(7, "blockPos%6u: litLength token = %u", (unsigned)(op-(BYTE*)dst), (unsigned)length);
-
-            /* decode literal length */
-            if (length == RUN_MASK) {
-                size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1);
-                if (addl == rvl_error) {
-                    DEBUGLOG(6, "error reading long literal length");
-                    goto _output_error;
-                }
-                length += addl;
-                if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */
-                if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */
-
-                /* copy literals */
-                LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH);
-                if ((op+length>oend-32) || (ip+length>iend-32)) { goto safe_literal_copy; }
-                LZ4_wildCopy32(op, ip, op+length);
-                ip += length; op += length;
-            } else if (ip <= iend-(16 + 1/*max lit + offset + nextToken*/)) {
-                /* We don't need to check oend, since we check it once for each loop below */
-                DEBUGLOG(7, "copy %u bytes in a 16-bytes stripe", (unsigned)length);
-                /* Literals can only be <= 14, but hope compilers optimize better when copy by a register size */
-                LZ4_memcpy(op, ip, 16);
-                ip += length; op += length;
-            } else {
-                goto safe_literal_copy;
-            }
-
-            /* get offset */
-            offset = LZ4_readLE16(ip); ip+=2;
-            DEBUGLOG(6, "blockPos%6u: offset = %u", (unsigned)(op-(BYTE*)dst), (unsigned)offset);
-            match = op - offset;
-            assert(match <= op);  /* overflow check */
-
-            /* get matchlength */
-            length = token & ML_MASK;
-            DEBUGLOG(7, "  match length token = %u (len==%u)", (unsigned)length, (unsigned)length+MINMATCH);
-
-            if (length == ML_MASK) {
-                size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0);
-                if (addl == rvl_error) {
-                    DEBUGLOG(5, "error reading long match length");
-                    goto _output_error;
-                }
-                length += addl;
-                length += MINMATCH;
-                DEBUGLOG(7, "  long match length == %u", (unsigned)length);
-                if (unlikely((uptrval)(op)+length<(uptrval)op)) { goto _output_error; } /* overflow detection */
-                if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) {
-                    goto safe_match_copy;
-                }
-            } else {
-                length += MINMATCH;
-                if (op + length >= oend - FASTLOOP_SAFE_DISTANCE) {
-                    DEBUGLOG(7, "moving to safe_match_copy (ml==%u)", (unsigned)length);
-                    goto safe_match_copy;
-                }
-
-                /* Fastpath check: skip LZ4_wildCopy32 when true */
-                if ((dict == withPrefix64k) || (match >= lowPrefix)) {
-                    if (offset >= 8) {
-                        assert(match >= lowPrefix);
-                        assert(match <= op);
-                        assert(op + 18 <= oend);
-
-                        LZ4_memcpy(op, match, 8);
-                        LZ4_memcpy(op+8, match+8, 8);
-                        LZ4_memcpy(op+16, match+16, 2);
-                        op += length;
-                        continue;
-            }   }   }
-
-            if ( checkOffset && (unlikely(match + dictSize < lowPrefix)) ) {
-                DEBUGLOG(5, "Error : pos=%zi, offset=%zi => outside buffers", op-lowPrefix, op-match);
-                goto _output_error;
-            }
-            /* match starting within external dictionary */
-            if ((dict==usingExtDict) && (match < lowPrefix)) {
-                assert(dictEnd != NULL);
-                if (unlikely(op+length > oend-LASTLITERALS)) {
-                    if (partialDecoding) {
-                        DEBUGLOG(7, "partialDecoding: dictionary match, close to dstEnd");
-                        length = MIN(length, (size_t)(oend-op));
-                    } else {
-                        DEBUGLOG(6, "end-of-block condition violated")
-                        goto _output_error;
-                }   }
-
-                if (length <= (size_t)(lowPrefix-match)) {
-                    /* match fits entirely within external dictionary : just copy */
-                    LZ4_memmove(op, dictEnd - (lowPrefix-match), length);
-                    op += length;
-                } else {
-                    /* match stretches into both external dictionary and current block */
-                    size_t const copySize = (size_t)(lowPrefix - match);
-                    size_t const restSize = length - copySize;
-                    LZ4_memcpy(op, dictEnd - copySize, copySize);
-                    op += copySize;
-                    if (restSize > (size_t)(op - lowPrefix)) {  /* overlap copy */
-                        BYTE* const endOfMatch = op + restSize;
-                        const BYTE* copyFrom = lowPrefix;
-                        while (op < endOfMatch) { *op++ = *copyFrom++; }
-                    } else {
-                        LZ4_memcpy(op, lowPrefix, restSize);
-                        op += restSize;
-                }   }
-                continue;
-            }
-
-            /* copy match within block */
-            cpy = op + length;
-
-            assert((op <= oend) && (oend-op >= 32));
-            if (unlikely(offset<16)) {
-                LZ4_memcpy_using_offset(op, match, cpy, offset);
-            } else {
-                LZ4_wildCopy32(op, match, cpy);
-            }
-
-            op = cpy;   /* wildcopy correction */
-        }
-    safe_decode:
-#endif
-
-        /* Main Loop : decode remaining sequences where output < FASTLOOP_SAFE_DISTANCE */
-        DEBUGLOG(6, "using safe decode loop");
-        while (1) {
-            assert(ip < iend);
-            token = *ip++;
-            length = token >> ML_BITS;  /* literal length */
-            DEBUGLOG(7, "blockPos%6u: litLength token = %u", (unsigned)(op-(BYTE*)dst), (unsigned)length);
-
-            /* A two-stage shortcut for the most common case:
-             * 1) If the literal length is 0..14, and there is enough space,
-             * enter the shortcut and copy 16 bytes on behalf of the literals
-             * (in the fast mode, only 8 bytes can be safely copied this way).
-             * 2) Further if the match length is 4..18, copy 18 bytes in a similar
-             * manner; but we ensure that there's enough space in the output for
-             * those 18 bytes earlier, upon entering the shortcut (in other words,
-             * there is a combined check for both stages).
-             */
-            if ( (length != RUN_MASK)
-                /* strictly "less than" on input, to re-enter the loop with at least one byte */
-              && likely((ip < shortiend) & (op <= shortoend)) ) {
-                /* Copy the literals */
-                LZ4_memcpy(op, ip, 16);
-                op += length; ip += length;
-
-                /* The second stage: prepare for match copying, decode full info.
-                 * If it doesn't work out, the info won't be wasted. */
-                length = token & ML_MASK; /* match length */
-                DEBUGLOG(7, "blockPos%6u: matchLength token = %u (len=%u)", (unsigned)(op-(BYTE*)dst), (unsigned)length, (unsigned)length + 4);
-                offset = LZ4_readLE16(ip); ip += 2;
-                match = op - offset;
-                assert(match <= op); /* check overflow */
-
-                /* Do not deal with overlapping matches. */
-                if ( (length != ML_MASK)
-                  && (offset >= 8)
-                  && (dict==withPrefix64k || match >= lowPrefix) ) {
-                    /* Copy the match. */
-                    LZ4_memcpy(op + 0, match + 0, 8);
-                    LZ4_memcpy(op + 8, match + 8, 8);
-                    LZ4_memcpy(op +16, match +16, 2);
-                    op += length + MINMATCH;
-                    /* Both stages worked, load the next token. */
-                    continue;
-                }
-
-                /* The second stage didn't work out, but the info is ready.
-                 * Propel it right to the point of match copying. */
-                goto _copy_match;
-            }
-
-            /* decode literal length */
-            if (length == RUN_MASK) {
-                size_t const addl = read_variable_length(&ip, iend-RUN_MASK, 1);
-                if (addl == rvl_error) { goto _output_error; }
-                length += addl;
-                if (unlikely((uptrval)(op)+length<(uptrval)(op))) { goto _output_error; } /* overflow detection */
-                if (unlikely((uptrval)(ip)+length<(uptrval)(ip))) { goto _output_error; } /* overflow detection */
-            }
-
-#if LZ4_FAST_DEC_LOOP
-        safe_literal_copy:
-#endif
-            /* copy literals */
-            cpy = op+length;
-
-            LZ4_STATIC_ASSERT(MFLIMIT >= WILDCOPYLENGTH);
-            if ((cpy>oend-MFLIMIT) || (ip+length>iend-(2+1+LASTLITERALS))) {
-                /* We've either hit the input parsing restriction or the output parsing restriction.
-                 * In the normal scenario, decoding a full block, it must be the last sequence,
-                 * otherwise it's an error (invalid input or dimensions).
-                 * In partialDecoding scenario, it's necessary to ensure there is no buffer overflow.
-                 */
-                if (partialDecoding) {
-                    /* Since we are partial decoding we may be in this block because of the output parsing
-                     * restriction, which is not valid since the output buffer is allowed to be undersized.
-                     */
-                    DEBUGLOG(7, "partialDecoding: copying literals, close to input or output end")
-                    DEBUGLOG(7, "partialDecoding: literal length = %u", (unsigned)length);
-                    DEBUGLOG(7, "partialDecoding: remaining space in dstBuffer : %i", (int)(oend - op));
-                    DEBUGLOG(7, "partialDecoding: remaining space in srcBuffer : %i", (int)(iend - ip));
-                    /* Finishing in the middle of a literals segment,
-                     * due to lack of input.
-                     */
-                    if (ip+length > iend) {
-                        length = (size_t)(iend-ip);
-                        cpy = op + length;
-                    }
-                    /* Finishing in the middle of a literals segment,
-                     * due to lack of output space.
-                     */
-                    if (cpy > oend) {
-                        cpy = oend;
-                        assert(op<=oend);
-                        length = (size_t)(oend-op);
-                    }
-                } else {
-                     /* We must be on the last sequence (or invalid) because of the parsing limitations
-                      * so check that we exactly consume the input and don't overrun the output buffer.
-                      */
-                    if ((ip+length != iend) || (cpy > oend)) {
-                        DEBUGLOG(5, "should have been last run of literals")
-                        DEBUGLOG(5, "ip(%p) + length(%i) = %p != iend (%p)", ip, (int)length, ip+length, iend);
-                        DEBUGLOG(5, "or cpy(%p) > (oend-MFLIMIT)(%p)", cpy, oend-MFLIMIT);
-                        DEBUGLOG(5, "after writing %u bytes / %i bytes available", (unsigned)(op-(BYTE*)dst), outputSize);
-                        goto _output_error;
-                    }
-                }
-                LZ4_memmove(op, ip, length);  /* supports overlapping memory regions, for in-place decompression scenarios */
-                ip += length;
-                op += length;
-                /* Necessarily EOF when !partialDecoding.
-                 * When partialDecoding, it is EOF if we've either
-                 * filled the output buffer or
-                 * can't proceed with reading an offset for following match.
-                 */
-                if (!partialDecoding || (cpy == oend) || (ip >= (iend-2))) {
-                    break;
-                }
-            } else {
-                LZ4_wildCopy8(op, ip, cpy);   /* can overwrite up to 8 bytes beyond cpy */
-                ip += length; op = cpy;
-            }
-
-            /* get offset */
-            offset = LZ4_readLE16(ip); ip+=2;
-            match = op - offset;
-
-            /* get matchlength */
-            length = token & ML_MASK;
-            DEBUGLOG(7, "blockPos%6u: matchLength token = %u", (unsigned)(op-(BYTE*)dst), (unsigned)length);
-
-    _copy_match:
-            if (length == ML_MASK) {
-                size_t const addl = read_variable_length(&ip, iend - LASTLITERALS + 1, 0);
-                if (addl == rvl_error) { goto _output_error; }
-                length += addl;
-                if (unlikely((uptrval)(op)+length<(uptrval)op)) goto _output_error;   /* overflow detection */
-            }
-            length += MINMATCH;
-
-#if LZ4_FAST_DEC_LOOP
-        safe_match_copy:
-#endif
-            if ((checkOffset) && (unlikely(match + dictSize < lowPrefix))) goto _output_error;   /* Error : offset outside buffers */
-            /* match starting within external dictionary */
-            if ((dict==usingExtDict) && (match < lowPrefix)) {
-                assert(dictEnd != NULL);
-                if (unlikely(op+length > oend-LASTLITERALS)) {
-                    if (partialDecoding) length = MIN(length, (size_t)(oend-op));
-                    else goto _output_error;   /* doesn't respect parsing restriction */
-                }
-
-                if (length <= (size_t)(lowPrefix-match)) {
-                    /* match fits entirely within external dictionary : just copy */
-                    LZ4_memmove(op, dictEnd - (lowPrefix-match), length);
-                    op += length;
-                } else {
-                    /* match stretches into both external dictionary and current block */
-                    size_t const copySize = (size_t)(lowPrefix - match);
-                    size_t const restSize = length - copySize;
-                    LZ4_memcpy(op, dictEnd - copySize, copySize);
-                    op += copySize;
-                    if (restSize > (size_t)(op - lowPrefix)) {  /* overlap copy */
-                        BYTE* const endOfMatch = op + restSize;
-                        const BYTE* copyFrom = lowPrefix;
-                        while (op < endOfMatch) *op++ = *copyFrom++;
-                    } else {
-                        LZ4_memcpy(op, lowPrefix, restSize);
-                        op += restSize;
-                }   }
-                continue;
-            }
-            assert(match >= lowPrefix);
-
-            /* copy match within block */
-            cpy = op + length;
-
-            /* partialDecoding : may end anywhere within the block */
-            assert(op<=oend);
-            if (partialDecoding && (cpy > oend-MATCH_SAFEGUARD_DISTANCE)) {
-                size_t const mlen = MIN(length, (size_t)(oend-op));
-                const BYTE* const matchEnd = match + mlen;
-                BYTE* const copyEnd = op + mlen;
-                if (matchEnd > op) {   /* overlap copy */
-                    while (op < copyEnd) { *op++ = *match++; }
-                } else {
-                    LZ4_memcpy(op, match, mlen);
-                }
-                op = copyEnd;
-                if (op == oend) { break; }
-                continue;
-            }
-
-            if (unlikely(offset<8)) {
-                LZ4_write32(op, 0);   /* silence msan warning when offset==0 */
-                op[0] = match[0];
-                op[1] = match[1];
-                op[2] = match[2];
-                op[3] = match[3];
-                match += inc32table[offset];
-                LZ4_memcpy(op+4, match, 4);
-                match -= dec64table[offset];
-            } else {
-                LZ4_memcpy(op, match, 8);
-                match += 8;
-            }
-            op += 8;
-
-            if (unlikely(cpy > oend-MATCH_SAFEGUARD_DISTANCE)) {
-                BYTE* const oCopyLimit = oend - (WILDCOPYLENGTH-1);
-                if (cpy > oend-LASTLITERALS) { goto _output_error; } /* Error : last LASTLITERALS bytes must be literals (uncompressed) */
-                if (op < oCopyLimit) {
-                    LZ4_wildCopy8(op, match, oCopyLimit);
-                    match += oCopyLimit - op;
-                    op = oCopyLimit;
-                }
-                while (op < cpy) { *op++ = *match++; }
-            } else {
-                LZ4_memcpy(op, match, 8);
-                if (length > 16) { LZ4_wildCopy8(op+8, match+8, cpy); }
-            }
-            op = cpy;   /* wildcopy correction */
-        }
-
-        /* end of decoding */
-        DEBUGLOG(5, "decoded %i bytes", (int) (((char*)op)-dst));
-        return (int) (((char*)op)-dst);     /* Nb of output bytes decoded */
-
-        /* Overflow error detected */
-    _output_error:
-        return (int) (-(((const char*)ip)-src))-1;
-    }
-}
-
-
-/*===== Instantiate the API decoding functions. =====*/
-
-LZ4_FORCE_O2
-int LZ4_decompress_safe(const char* source, char* dest, int compressedSize, int maxDecompressedSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxDecompressedSize,
-                                  decode_full_block, noDict,
-                                  (BYTE*)dest, NULL, 0);
-}
-
-LZ4_FORCE_O2
-int LZ4_decompress_safe_partial(const char* src, char* dst, int compressedSize, int targetOutputSize, int dstCapacity)
-{
-    dstCapacity = MIN(targetOutputSize, dstCapacity);
-    return LZ4_decompress_generic(src, dst, compressedSize, dstCapacity,
-                                  partial_decode,
-                                  noDict, (BYTE*)dst, NULL, 0);
-}
-
-LZ4_FORCE_O2
-int LZ4_decompress_fast(const char* source, char* dest, int originalSize)
-{
-    DEBUGLOG(5, "LZ4_decompress_fast");
-    return LZ4_decompress_unsafe_generic(
-                (const BYTE*)source, (BYTE*)dest, originalSize,
-                0, NULL, 0);
-}
-
-/*===== Instantiate a few more decoding cases, used more than once. =====*/
-
-LZ4_FORCE_O2 /* Exported, an obsolete API function. */
-int LZ4_decompress_safe_withPrefix64k(const char* source, char* dest, int compressedSize, int maxOutputSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                  decode_full_block, withPrefix64k,
-                                  (BYTE*)dest - 64 KB, NULL, 0);
-}
-
-LZ4_FORCE_O2
-static int LZ4_decompress_safe_partial_withPrefix64k(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity)
-{
-    dstCapacity = MIN(targetOutputSize, dstCapacity);
-    return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity,
-                                  partial_decode, withPrefix64k,
-                                  (BYTE*)dest - 64 KB, NULL, 0);
-}
-
-/* Another obsolete API function, paired with the previous one. */
-int LZ4_decompress_fast_withPrefix64k(const char* source, char* dest, int originalSize)
-{
-    return LZ4_decompress_unsafe_generic(
-                (const BYTE*)source, (BYTE*)dest, originalSize,
-                64 KB, NULL, 0);
-}
-
-LZ4_FORCE_O2
-static int LZ4_decompress_safe_withSmallPrefix(const char* source, char* dest, int compressedSize, int maxOutputSize,
-                                               size_t prefixSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                  decode_full_block, noDict,
-                                  (BYTE*)dest-prefixSize, NULL, 0);
-}
-
-LZ4_FORCE_O2
-static int LZ4_decompress_safe_partial_withSmallPrefix(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity,
-                                               size_t prefixSize)
-{
-    dstCapacity = MIN(targetOutputSize, dstCapacity);
-    return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity,
-                                  partial_decode, noDict,
-                                  (BYTE*)dest-prefixSize, NULL, 0);
-}
-
-LZ4_FORCE_O2
-int LZ4_decompress_safe_forceExtDict(const char* source, char* dest,
-                                     int compressedSize, int maxOutputSize,
-                                     const void* dictStart, size_t dictSize)
-{
-    DEBUGLOG(5, "LZ4_decompress_safe_forceExtDict");
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                  decode_full_block, usingExtDict,
-                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
-}
-
-LZ4_FORCE_O2
-int LZ4_decompress_safe_partial_forceExtDict(const char* source, char* dest,
-                                     int compressedSize, int targetOutputSize, int dstCapacity,
-                                     const void* dictStart, size_t dictSize)
-{
-    dstCapacity = MIN(targetOutputSize, dstCapacity);
-    return LZ4_decompress_generic(source, dest, compressedSize, dstCapacity,
-                                  partial_decode, usingExtDict,
-                                  (BYTE*)dest, (const BYTE*)dictStart, dictSize);
-}
-
-LZ4_FORCE_O2
-static int LZ4_decompress_fast_extDict(const char* source, char* dest, int originalSize,
-                                       const void* dictStart, size_t dictSize)
-{
-    return LZ4_decompress_unsafe_generic(
-                (const BYTE*)source, (BYTE*)dest, originalSize,
-                0, (const BYTE*)dictStart, dictSize);
-}
-
-/* The "double dictionary" mode, for use with e.g. ring buffers: the first part
- * of the dictionary is passed as prefix, and the second via dictStart + dictSize.
- * These routines are used only once, in LZ4_decompress_*_continue().
- */
-LZ4_FORCE_INLINE
-int LZ4_decompress_safe_doubleDict(const char* source, char* dest, int compressedSize, int maxOutputSize,
-                                   size_t prefixSize, const void* dictStart, size_t dictSize)
-{
-    return LZ4_decompress_generic(source, dest, compressedSize, maxOutputSize,
-                                  decode_full_block, usingExtDict,
-                                  (BYTE*)dest-prefixSize, (const BYTE*)dictStart, dictSize);
-}
-
-/*===== streaming decompression functions =====*/
-
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-LZ4_streamDecode_t* LZ4_createStreamDecode(void)
-{
-    LZ4_STATIC_ASSERT(sizeof(LZ4_streamDecode_t) >= sizeof(LZ4_streamDecode_t_internal));
-    return (LZ4_streamDecode_t*) ALLOC_AND_ZERO(sizeof(LZ4_streamDecode_t));
-}
-
-int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
-{
-    if (LZ4_stream == NULL) { return 0; }  /* support free on NULL */
-    FREEMEM(LZ4_stream);
-    return 0;
-}
-#endif
-
-/*! LZ4_setStreamDecode() :
- *  Use this function to instruct where to find the dictionary.
- *  This function is not necessary if previous data is still available where it was decoded.
- *  Loading a size of 0 is allowed (same effect as no dictionary).
- * @return : 1 if OK, 0 if error
- */
-int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
-{
-    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-    lz4sd->prefixSize = (size_t)dictSize;
-    if (dictSize) {
-        assert(dictionary != NULL);
-        lz4sd->prefixEnd = (const BYTE*) dictionary + dictSize;
-    } else {
-        lz4sd->prefixEnd = (const BYTE*) dictionary;
-    }
-    lz4sd->externalDict = NULL;
-    lz4sd->extDictSize  = 0;
-    return 1;
-}
-
-/*! LZ4_decoderRingBufferSize() :
- *  when setting a ring buffer for streaming decompression (optional scenario),
- *  provides the minimum size of this ring buffer
- *  to be compatible with any source respecting maxBlockSize condition.
- *  Note : in a ring buffer scenario,
- *  blocks are presumed decompressed next to each other.
- *  When not enough space remains for next block (remainingSize < maxBlockSize),
- *  decoding resumes from beginning of ring buffer.
- * @return : minimum ring buffer size,
- *           or 0 if there is an error (invalid maxBlockSize).
- */
-int LZ4_decoderRingBufferSize(int maxBlockSize)
-{
-    if (maxBlockSize < 0) return 0;
-    if (maxBlockSize > LZ4_MAX_INPUT_SIZE) return 0;
-    if (maxBlockSize < 16) maxBlockSize = 16;
-    return LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize);
-}
-
-/*
-*_continue() :
-    These decoding functions allow decompression of multiple blocks in "streaming" mode.
-    Previously decoded blocks must still be available at the memory position where they were decoded.
-    If it's not possible, save the relevant part of decoded data into a safe buffer,
-    and indicate where it stands using LZ4_setStreamDecode()
-*/
-LZ4_FORCE_O2
-int LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* source, char* dest, int compressedSize, int maxOutputSize)
-{
-    LZ4_streamDecode_t_internal* lz4sd = &LZ4_streamDecode->internal_donotuse;
-    int result;
-
-    if (lz4sd->prefixSize == 0) {
-        /* The first call, no dictionary yet. */
-        assert(lz4sd->extDictSize == 0);
-        result = LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = (size_t)result;
-        lz4sd->prefixEnd = (BYTE*)dest + result;
-    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
-        /* They're rolling the current segment. */
-        if (lz4sd->prefixSize >= 64 KB - 1)
-            result = LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
-        else if (lz4sd->extDictSize == 0)
-            result = LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize,
-                                                         lz4sd->prefixSize);
-        else
-            result = LZ4_decompress_safe_doubleDict(source, dest, compressedSize, maxOutputSize,
-                                                    lz4sd->prefixSize, lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize += (size_t)result;
-        lz4sd->prefixEnd  += result;
-    } else {
-        /* The buffer wraps around, or they're switching to another buffer. */
-        lz4sd->extDictSize = lz4sd->prefixSize;
-        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
-        result = LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize,
-                                                  lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = (size_t)result;
-        lz4sd->prefixEnd  = (BYTE*)dest + result;
-    }
-
-    return result;
-}
-
-LZ4_FORCE_O2 int
-LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode,
-                        const char* source, char* dest, int originalSize)
-{
-    LZ4_streamDecode_t_internal* const lz4sd =
-        (assert(LZ4_streamDecode!=NULL), &LZ4_streamDecode->internal_donotuse);
-    int result;
-
-    DEBUGLOG(5, "LZ4_decompress_fast_continue (toDecodeSize=%i)", originalSize);
-    assert(originalSize >= 0);
-
-    if (lz4sd->prefixSize == 0) {
-        DEBUGLOG(5, "first invocation : no prefix nor extDict");
-        assert(lz4sd->extDictSize == 0);
-        result = LZ4_decompress_fast(source, dest, originalSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = (size_t)originalSize;
-        lz4sd->prefixEnd = (BYTE*)dest + originalSize;
-    } else if (lz4sd->prefixEnd == (BYTE*)dest) {
-        DEBUGLOG(5, "continue using existing prefix");
-        result = LZ4_decompress_unsafe_generic(
-                        (const BYTE*)source, (BYTE*)dest, originalSize,
-                        lz4sd->prefixSize,
-                        lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize += (size_t)originalSize;
-        lz4sd->prefixEnd  += originalSize;
-    } else {
-        DEBUGLOG(5, "prefix becomes extDict");
-        lz4sd->extDictSize = lz4sd->prefixSize;
-        lz4sd->externalDict = lz4sd->prefixEnd - lz4sd->extDictSize;
-        result = LZ4_decompress_fast_extDict(source, dest, originalSize,
-                                             lz4sd->externalDict, lz4sd->extDictSize);
-        if (result <= 0) return result;
-        lz4sd->prefixSize = (size_t)originalSize;
-        lz4sd->prefixEnd  = (BYTE*)dest + originalSize;
-    }
-
-    return result;
-}
-
-
-/*
-Advanced decoding functions :
-*_usingDict() :
-    These decoding functions work the same as "_continue" ones,
-    the dictionary must be explicitly provided within parameters
-*/
-
-int LZ4_decompress_safe_usingDict(const char* source, char* dest, int compressedSize, int maxOutputSize, const char* dictStart, int dictSize)
-{
-    if (dictSize==0)
-        return LZ4_decompress_safe(source, dest, compressedSize, maxOutputSize);
-    if (dictStart+dictSize == dest) {
-        if (dictSize >= 64 KB - 1) {
-            return LZ4_decompress_safe_withPrefix64k(source, dest, compressedSize, maxOutputSize);
-        }
-        assert(dictSize >= 0);
-        return LZ4_decompress_safe_withSmallPrefix(source, dest, compressedSize, maxOutputSize, (size_t)dictSize);
-    }
-    assert(dictSize >= 0);
-    return LZ4_decompress_safe_forceExtDict(source, dest, compressedSize, maxOutputSize, dictStart, (size_t)dictSize);
-}
-
-int LZ4_decompress_safe_partial_usingDict(const char* source, char* dest, int compressedSize, int targetOutputSize, int dstCapacity, const char* dictStart, int dictSize)
-{
-    if (dictSize==0)
-        return LZ4_decompress_safe_partial(source, dest, compressedSize, targetOutputSize, dstCapacity);
-    if (dictStart+dictSize == dest) {
-        if (dictSize >= 64 KB - 1) {
-            return LZ4_decompress_safe_partial_withPrefix64k(source, dest, compressedSize, targetOutputSize, dstCapacity);
-        }
-        assert(dictSize >= 0);
-        return LZ4_decompress_safe_partial_withSmallPrefix(source, dest, compressedSize, targetOutputSize, dstCapacity, (size_t)dictSize);
-    }
-    assert(dictSize >= 0);
-    return LZ4_decompress_safe_partial_forceExtDict(source, dest, compressedSize, targetOutputSize, dstCapacity, dictStart, (size_t)dictSize);
-}
-
-int LZ4_decompress_fast_usingDict(const char* source, char* dest, int originalSize, const char* dictStart, int dictSize)
-{
-    if (dictSize==0 || dictStart+dictSize == dest)
-        return LZ4_decompress_unsafe_generic(
-                        (const BYTE*)source, (BYTE*)dest, originalSize,
-                        (size_t)dictSize, NULL, 0);
-    assert(dictSize >= 0);
-    return LZ4_decompress_fast_extDict(source, dest, originalSize, dictStart, (size_t)dictSize);
-}
-
-
-/*=*************************************************
-*  Obsolete Functions
-***************************************************/
-/* obsolete compression functions */
-int LZ4_compress_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize)
-{
-    return LZ4_compress_default(source, dest, inputSize, maxOutputSize);
-}
-int LZ4_compress(const char* src, char* dest, int srcSize)
-{
-    return LZ4_compress_default(src, dest, srcSize, LZ4_compressBound(srcSize));
-}
-int LZ4_compress_limitedOutput_withState (void* state, const char* src, char* dst, int srcSize, int dstSize)
-{
-    return LZ4_compress_fast_extState(state, src, dst, srcSize, dstSize, 1);
-}
-int LZ4_compress_withState (void* state, const char* src, char* dst, int srcSize)
-{
-    return LZ4_compress_fast_extState(state, src, dst, srcSize, LZ4_compressBound(srcSize), 1);
-}
-int LZ4_compress_limitedOutput_continue (LZ4_stream_t* LZ4_stream, const char* src, char* dst, int srcSize, int dstCapacity)
-{
-    return LZ4_compress_fast_continue(LZ4_stream, src, dst, srcSize, dstCapacity, 1);
-}
-int LZ4_compress_continue (LZ4_stream_t* LZ4_stream, const char* source, char* dest, int inputSize)
-{
-    return LZ4_compress_fast_continue(LZ4_stream, source, dest, inputSize, LZ4_compressBound(inputSize), 1);
-}
-
-/*
-These decompression functions are deprecated and should no longer be used.
-They are only provided here for compatibility with older user programs.
-- LZ4_uncompress is totally equivalent to LZ4_decompress_fast
-- LZ4_uncompress_unknownOutputSize is totally equivalent to LZ4_decompress_safe
-*/
-int LZ4_uncompress (const char* source, char* dest, int outputSize)
-{
-    return LZ4_decompress_fast(source, dest, outputSize);
-}
-int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize)
-{
-    return LZ4_decompress_safe(source, dest, isize, maxOutputSize);
-}
-
-/* Obsolete Streaming functions */
-
-int LZ4_sizeofStreamState(void) { return sizeof(LZ4_stream_t); }
-
-int LZ4_resetStreamState(void* state, char* inputBuffer)
-{
-    (void)inputBuffer;
-    LZ4_resetStream((LZ4_stream_t*)state);
-    return 0;
-}
-
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-void* LZ4_create (char* inputBuffer)
-{
-    (void)inputBuffer;
-    return LZ4_createStream();
-}
-#endif
-
-char* LZ4_slideInputBuffer (void* state)
-{
-    /* avoid const char * -> char * conversion warning */
-    return (char *)(uptrval)((LZ4_stream_t*)state)->internal_donotuse.dictionary;
-}
-
-#endif   /* LZ4_COMMONDEFS_ONLY */
diff --git a/native/lz4/vendor/lib/lz4.h b/native/lz4/vendor/lib/lz4.h
deleted file mode 100644
index 80e3e5c..0000000
--- a/native/lz4/vendor/lib/lz4.h
+++ /dev/null
@@ -1,884 +0,0 @@
-/*
- *  LZ4 - Fast LZ compression algorithm
- *  Header File
- *  Copyright (C) 2011-2023, Yann Collet.
-
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-    - LZ4 homepage : http://www.lz4.org
-    - LZ4 source repository : https://github.com/lz4/lz4
-*/
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-#ifndef LZ4_H_2983827168210
-#define LZ4_H_2983827168210
-
-/* --- Dependency --- */
-#include <stddef.h>   /* size_t */
-
-
-/**
-  Introduction
-
-  LZ4 is lossless compression algorithm, providing compression speed >500 MB/s per core,
-  scalable with multi-cores CPU. It features an extremely fast decoder, with speed in
-  multiple GB/s per core, typically reaching RAM speed limits on multi-core systems.
-
-  The LZ4 compression library provides in-memory compression and decompression functions.
-  It gives full buffer control to user.
-  Compression can be done in:
-    - a single step (described as Simple Functions)
-    - a single step, reusing a context (described in Advanced Functions)
-    - unbounded multiple steps (described as Streaming compression)
-
-  lz4.h generates and decodes LZ4-compressed blocks (doc/lz4_Block_format.md).
-  Decompressing such a compressed block requires additional metadata.
-  Exact metadata depends on exact decompression function.
-  For the typical case of LZ4_decompress_safe(),
-  metadata includes block's compressed size, and maximum bound of decompressed size.
-  Each application is free to encode and pass such metadata in whichever way it wants.
-
-  lz4.h only handle blocks, it can not generate Frames.
-
-  Blocks are different from Frames (doc/lz4_Frame_format.md).
-  Frames bundle both blocks and metadata in a specified manner.
-  Embedding metadata is required for compressed data to be self-contained and portable.
-  Frame format is delivered through a companion API, declared in lz4frame.h.
-  The `lz4` CLI can only manage frames.
-*/
-
-/*^***************************************************************
-*  Export parameters
-*****************************************************************/
-/*
-*  LZ4_DLL_EXPORT :
-*  Enable exporting of functions when building a Windows DLL
-*  LZ4LIB_VISIBILITY :
-*  Control library symbols visibility.
-*/
-#ifndef LZ4LIB_VISIBILITY
-#  if defined(__GNUC__) && (__GNUC__ >= 4)
-#    define LZ4LIB_VISIBILITY __attribute__ ((visibility ("default")))
-#  else
-#    define LZ4LIB_VISIBILITY
-#  endif
-#endif
-#if defined(LZ4_DLL_EXPORT) && (LZ4_DLL_EXPORT==1)
-#  define LZ4LIB_API __declspec(dllexport) LZ4LIB_VISIBILITY
-#elif defined(LZ4_DLL_IMPORT) && (LZ4_DLL_IMPORT==1)
-#  define LZ4LIB_API __declspec(dllimport) LZ4LIB_VISIBILITY /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/
-#else
-#  define LZ4LIB_API LZ4LIB_VISIBILITY
-#endif
-
-/*! LZ4_FREESTANDING :
- *  When this macro is set to 1, it enables "freestanding mode" that is
- *  suitable for typical freestanding environment which doesn't support
- *  standard C library.
- *
- *  - LZ4_FREESTANDING is a compile-time switch.
- *  - It requires the following macros to be defined:
- *    LZ4_memcpy, LZ4_memmove, LZ4_memset.
- *  - It only enables LZ4/HC functions which don't use heap.
- *    All LZ4F_* functions are not supported.
- *  - See tests/freestanding.c to check its basic setup.
- */
-#if defined(LZ4_FREESTANDING) && (LZ4_FREESTANDING == 1)
-#  define LZ4_HEAPMODE 0
-#  define LZ4HC_HEAPMODE 0
-#  define LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION 1
-#  if !defined(LZ4_memcpy)
-#    error "LZ4_FREESTANDING requires macro 'LZ4_memcpy'."
-#  endif
-#  if !defined(LZ4_memset)
-#    error "LZ4_FREESTANDING requires macro 'LZ4_memset'."
-#  endif
-#  if !defined(LZ4_memmove)
-#    error "LZ4_FREESTANDING requires macro 'LZ4_memmove'."
-#  endif
-#elif ! defined(LZ4_FREESTANDING)
-#  define LZ4_FREESTANDING 0
-#endif
-
-
-/*------   Version   ------*/
-#define LZ4_VERSION_MAJOR    1    /* for breaking interface changes  */
-#define LZ4_VERSION_MINOR   10    /* for new (non-breaking) interface capabilities */
-#define LZ4_VERSION_RELEASE  0    /* for tweaks, bug-fixes, or development */
-
-#define LZ4_VERSION_NUMBER (LZ4_VERSION_MAJOR *100*100 + LZ4_VERSION_MINOR *100 + LZ4_VERSION_RELEASE)
-
-#define LZ4_LIB_VERSION LZ4_VERSION_MAJOR.LZ4_VERSION_MINOR.LZ4_VERSION_RELEASE
-#define LZ4_QUOTE(str) #str
-#define LZ4_EXPAND_AND_QUOTE(str) LZ4_QUOTE(str)
-#define LZ4_VERSION_STRING LZ4_EXPAND_AND_QUOTE(LZ4_LIB_VERSION)  /* requires v1.7.3+ */
-
-LZ4LIB_API int LZ4_versionNumber (void);  /**< library version number; useful to check dll version; requires v1.3.0+ */
-LZ4LIB_API const char* LZ4_versionString (void);   /**< library version string; useful to check dll version; requires v1.7.5+ */
-
-
-/*-************************************
-*  Tuning memory usage
-**************************************/
-/*!
- * LZ4_MEMORY_USAGE :
- * Can be selected at compile time, by setting LZ4_MEMORY_USAGE.
- * Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB)
- * Increasing memory usage improves compression ratio, generally at the cost of speed.
- * Reduced memory usage may improve speed at the cost of ratio, thanks to better cache locality.
- * Default value is 14, for 16KB, which nicely fits into most L1 caches.
- */
-#ifndef LZ4_MEMORY_USAGE
-# define LZ4_MEMORY_USAGE LZ4_MEMORY_USAGE_DEFAULT
-#endif
-
-/* These are absolute limits, they should not be changed by users */
-#define LZ4_MEMORY_USAGE_MIN 10
-#define LZ4_MEMORY_USAGE_DEFAULT 14
-#define LZ4_MEMORY_USAGE_MAX 20
-
-#if (LZ4_MEMORY_USAGE < LZ4_MEMORY_USAGE_MIN)
-#  error "LZ4_MEMORY_USAGE is too small !"
-#endif
-
-#if (LZ4_MEMORY_USAGE > LZ4_MEMORY_USAGE_MAX)
-#  error "LZ4_MEMORY_USAGE is too large !"
-#endif
-
-/*-************************************
-*  Simple Functions
-**************************************/
-/*! LZ4_compress_default() :
- *  Compresses 'srcSize' bytes from buffer 'src'
- *  into already allocated 'dst' buffer of size 'dstCapacity'.
- *  Compression is guaranteed to succeed if 'dstCapacity' >= LZ4_compressBound(srcSize).
- *  It also runs faster, so it's a recommended setting.
- *  If the function cannot compress 'src' into a more limited 'dst' budget,
- *  compression stops *immediately*, and the function result is zero.
- *  In which case, 'dst' content is undefined (invalid).
- *      srcSize : max supported value is LZ4_MAX_INPUT_SIZE.
- *      dstCapacity : size of buffer 'dst' (which must be already allocated)
- *     @return  : the number of bytes written into buffer 'dst' (necessarily <= dstCapacity)
- *                or 0 if compression fails
- * Note : This function is protected against buffer overflow scenarios (never writes outside 'dst' buffer, nor read outside 'source' buffer).
- */
-LZ4LIB_API int LZ4_compress_default(const char* src, char* dst, int srcSize, int dstCapacity);
-
-/*! LZ4_decompress_safe() :
- * @compressedSize : is the exact complete size of the compressed block.
- * @dstCapacity : is the size of destination buffer (which must be already allocated),
- *                presumed an upper bound of decompressed size.
- * @return : the number of bytes decompressed into destination buffer (necessarily <= dstCapacity)
- *           If destination buffer is not large enough, decoding will stop and output an error code (negative value).
- *           If the source stream is detected malformed, the function will stop decoding and return a negative result.
- * Note 1 : This function is protected against malicious data packets :
- *          it will never writes outside 'dst' buffer, nor read outside 'source' buffer,
- *          even if the compressed block is maliciously modified to order the decoder to do these actions.
- *          In such case, the decoder stops immediately, and considers the compressed block malformed.
- * Note 2 : compressedSize and dstCapacity must be provided to the function, the compressed block does not contain them.
- *          The implementation is free to send / store / derive this information in whichever way is most beneficial.
- *          If there is a need for a different format which bundles together both compressed data and its metadata, consider looking at lz4frame.h instead.
- */
-LZ4LIB_API int LZ4_decompress_safe (const char* src, char* dst, int compressedSize, int dstCapacity);
-
-
-/*-************************************
-*  Advanced Functions
-**************************************/
-#define LZ4_MAX_INPUT_SIZE        0x7E000000   /* 2 113 929 216 bytes */
-#define LZ4_COMPRESSBOUND(isize)  ((unsigned)(isize) > (unsigned)LZ4_MAX_INPUT_SIZE ? 0 : (isize) + ((isize)/255) + 16)
-
-/*! LZ4_compressBound() :
-    Provides the maximum size that LZ4 compression may output in a "worst case" scenario (input data not compressible)
-    This function is primarily useful for memory allocation purposes (destination buffer size).
-    Macro LZ4_COMPRESSBOUND() is also provided for compilation-time evaluation (stack memory allocation for example).
-    Note that LZ4_compress_default() compresses faster when dstCapacity is >= LZ4_compressBound(srcSize)
-        inputSize  : max supported value is LZ4_MAX_INPUT_SIZE
-        return : maximum output size in a "worst case" scenario
-              or 0, if input size is incorrect (too large or negative)
-*/
-LZ4LIB_API int LZ4_compressBound(int inputSize);
-
-/*! LZ4_compress_fast() :
-    Same as LZ4_compress_default(), but allows selection of "acceleration" factor.
-    The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
-    It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
-    An acceleration value of "1" is the same as regular LZ4_compress_default()
-    Values <= 0 will be replaced by LZ4_ACCELERATION_DEFAULT (currently == 1, see lz4.c).
-    Values > LZ4_ACCELERATION_MAX will be replaced by LZ4_ACCELERATION_MAX (currently == 65537, see lz4.c).
-*/
-LZ4LIB_API int LZ4_compress_fast (const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-
-
-/*! LZ4_compress_fast_extState() :
- *  Same as LZ4_compress_fast(), using an externally allocated memory space for its state.
- *  Use LZ4_sizeofState() to know how much memory must be allocated,
- *  and allocate it on 8-bytes boundaries (using `malloc()` typically).
- *  Then, provide this buffer as `void* state` to compression function.
- */
-LZ4LIB_API int LZ4_sizeofState(void);
-LZ4LIB_API int LZ4_compress_fast_extState (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-
-/*! LZ4_compress_destSize() :
- *  Reverse the logic : compresses as much data as possible from 'src' buffer
- *  into already allocated buffer 'dst', of size >= 'dstCapacity'.
- *  This function either compresses the entire 'src' content into 'dst' if it's large enough,
- *  or fill 'dst' buffer completely with as much data as possible from 'src'.
- *  note: acceleration parameter is fixed to "default".
- *
- * *srcSizePtr : in+out parameter. Initially contains size of input.
- *               Will be modified to indicate how many bytes where read from 'src' to fill 'dst'.
- *               New value is necessarily <= input value.
- * @return : Nb bytes written into 'dst' (necessarily <= dstCapacity)
- *           or 0 if compression fails.
- *
- * Note : from v1.8.2 to v1.9.1, this function had a bug (fixed in v1.9.2+):
- *        the produced compressed content could, in specific circumstances,
- *        require to be decompressed into a destination buffer larger
- *        by at least 1 byte than the content to decompress.
- *        If an application uses `LZ4_compress_destSize()`,
- *        it's highly recommended to update liblz4 to v1.9.2 or better.
- *        If this can't be done or ensured,
- *        the receiving decompression function should provide
- *        a dstCapacity which is > decompressedSize, by at least 1 byte.
- *        See https://github.com/lz4/lz4/issues/859 for details
- */
-LZ4LIB_API int LZ4_compress_destSize(const char* src, char* dst, int* srcSizePtr, int targetDstSize);
-
-/*! LZ4_decompress_safe_partial() :
- *  Decompress an LZ4 compressed block, of size 'srcSize' at position 'src',
- *  into destination buffer 'dst' of size 'dstCapacity'.
- *  Up to 'targetOutputSize' bytes will be decoded.
- *  The function stops decoding on reaching this objective.
- *  This can be useful to boost performance
- *  whenever only the beginning of a block is required.
- *
- * @return : the number of bytes decoded in `dst` (necessarily <= targetOutputSize)
- *           If source stream is detected malformed, function returns a negative result.
- *
- *  Note 1 : @return can be < targetOutputSize, if compressed block contains less data.
- *
- *  Note 2 : targetOutputSize must be <= dstCapacity
- *
- *  Note 3 : this function effectively stops decoding on reaching targetOutputSize,
- *           so dstCapacity is kind of redundant.
- *           This is because in older versions of this function,
- *           decoding operation would still write complete sequences.
- *           Therefore, there was no guarantee that it would stop writing at exactly targetOutputSize,
- *           it could write more bytes, though only up to dstCapacity.
- *           Some "margin" used to be required for this operation to work properly.
- *           Thankfully, this is no longer necessary.
- *           The function nonetheless keeps the same signature, in an effort to preserve API compatibility.
- *
- *  Note 4 : If srcSize is the exact size of the block,
- *           then targetOutputSize can be any value,
- *           including larger than the block's decompressed size.
- *           The function will, at most, generate block's decompressed size.
- *
- *  Note 5 : If srcSize is _larger_ than block's compressed size,
- *           then targetOutputSize **MUST** be <= block's decompressed size.
- *           Otherwise, *silent corruption will occur*.
- */
-LZ4LIB_API int LZ4_decompress_safe_partial (const char* src, char* dst, int srcSize, int targetOutputSize, int dstCapacity);
-
-
-/*-*********************************************
-*  Streaming Compression Functions
-***********************************************/
-typedef union LZ4_stream_u LZ4_stream_t;  /* incomplete type (defined later) */
-
-/*!
- Note about RC_INVOKED
-
- - RC_INVOKED is predefined symbol of rc.exe (the resource compiler which is part of MSVC/Visual Studio).
-   https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros
-
- - Since rc.exe is a legacy compiler, it truncates long symbol (> 30 chars)
-   and reports warning "RC4011: identifier truncated".
-
- - To eliminate the warning, we surround long preprocessor symbol with
-   "#if !defined(RC_INVOKED) ... #endif" block that means
-   "skip this block when rc.exe is trying to read it".
-*/
-#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-LZ4LIB_API LZ4_stream_t* LZ4_createStream(void);
-LZ4LIB_API int           LZ4_freeStream (LZ4_stream_t* streamPtr);
-#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */
-#endif
-
-/*! LZ4_resetStream_fast() : v1.9.0+
- *  Use this to prepare an LZ4_stream_t for a new chain of dependent blocks
- *  (e.g., LZ4_compress_fast_continue()).
- *
- *  An LZ4_stream_t must be initialized once before usage.
- *  This is automatically done when created by LZ4_createStream().
- *  However, should the LZ4_stream_t be simply declared on stack (for example),
- *  it's necessary to initialize it first, using LZ4_initStream().
- *
- *  After init, start any new stream with LZ4_resetStream_fast().
- *  A same LZ4_stream_t can be re-used multiple times consecutively
- *  and compress multiple streams,
- *  provided that it starts each new stream with LZ4_resetStream_fast().
- *
- *  LZ4_resetStream_fast() is much faster than LZ4_initStream(),
- *  but is not compatible with memory regions containing garbage data.
- *
- *  Note: it's only useful to call LZ4_resetStream_fast()
- *        in the context of streaming compression.
- *        The *extState* functions perform their own resets.
- *        Invoking LZ4_resetStream_fast() before is redundant, and even counterproductive.
- */
-LZ4LIB_API void LZ4_resetStream_fast (LZ4_stream_t* streamPtr);
-
-/*! LZ4_loadDict() :
- *  Use this function to reference a static dictionary into LZ4_stream_t.
- *  The dictionary must remain available during compression.
- *  LZ4_loadDict() triggers a reset, so any previous data will be forgotten.
- *  The same dictionary will have to be loaded on decompression side for successful decoding.
- *  Dictionary are useful for better compression of small data (KB range).
- *  While LZ4 itself accepts any input as dictionary, dictionary efficiency is also a topic.
- *  When in doubt, employ the Zstandard's Dictionary Builder.
- *  Loading a size of 0 is allowed, and is the same as reset.
- * @return : loaded dictionary size, in bytes (note: only the last 64 KB are loaded)
- */
-LZ4LIB_API int LZ4_loadDict (LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
-
-/*! LZ4_loadDictSlow() : v1.10.0+
- *  Same as LZ4_loadDict(),
- *  but uses a bit more cpu to reference the dictionary content more thoroughly.
- *  This is expected to slightly improve compression ratio.
- *  The extra-cpu cost is likely worth it if the dictionary is re-used across multiple sessions.
- * @return : loaded dictionary size, in bytes (note: only the last 64 KB are loaded)
- */
-LZ4LIB_API int LZ4_loadDictSlow(LZ4_stream_t* streamPtr, const char* dictionary, int dictSize);
-
-/*! LZ4_attach_dictionary() : stable since v1.10.0
- *
- *  This allows efficient re-use of a static dictionary multiple times.
- *
- *  Rather than re-loading the dictionary buffer into a working context before
- *  each compression, or copying a pre-loaded dictionary's LZ4_stream_t into a
- *  working LZ4_stream_t, this function introduces a no-copy setup mechanism,
- *  in which the working stream references @dictionaryStream in-place.
- *
- *  Several assumptions are made about the state of @dictionaryStream.
- *  Currently, only states which have been prepared by LZ4_loadDict() or
- *  LZ4_loadDictSlow() should be expected to work.
- *
- *  Alternatively, the provided @dictionaryStream may be NULL,
- *  in which case any existing dictionary stream is unset.
- *
- *  If a dictionary is provided, it replaces any pre-existing stream history.
- *  The dictionary contents are the only history that can be referenced and
- *  logically immediately precede the data compressed in the first subsequent
- *  compression call.
- *
- *  The dictionary will only remain attached to the working stream through the
- *  first compression call, at the end of which it is cleared.
- * @dictionaryStream stream (and source buffer) must remain in-place / accessible / unchanged
- *  through the completion of the compression session.
- *
- *  Note: there is no equivalent LZ4_attach_*() method on the decompression side
- *  because there is no initialization cost, hence no need to share the cost across multiple sessions.
- *  To decompress LZ4 blocks using dictionary, attached or not,
- *  just employ the regular LZ4_setStreamDecode() for streaming,
- *  or the stateless LZ4_decompress_safe_usingDict() for one-shot decompression.
- */
-LZ4LIB_API void
-LZ4_attach_dictionary(LZ4_stream_t* workingStream,
-                const LZ4_stream_t* dictionaryStream);
-
-/*! LZ4_compress_fast_continue() :
- *  Compress 'src' content using data from previously compressed blocks, for better compression ratio.
- * 'dst' buffer must be already allocated.
- *  If dstCapacity >= LZ4_compressBound(srcSize), compression is guaranteed to succeed, and runs faster.
- *
- * @return : size of compressed block
- *           or 0 if there is an error (typically, cannot fit into 'dst').
- *
- *  Note 1 : Each invocation to LZ4_compress_fast_continue() generates a new block.
- *           Each block has precise boundaries.
- *           Each block must be decompressed separately, calling LZ4_decompress_*() with relevant metadata.
- *           It's not possible to append blocks together and expect a single invocation of LZ4_decompress_*() to decompress them together.
- *
- *  Note 2 : The previous 64KB of source data is __assumed__ to remain present, unmodified, at same address in memory !
- *
- *  Note 3 : When input is structured as a double-buffer, each buffer can have any size, including < 64 KB.
- *           Make sure that buffers are separated, by at least one byte.
- *           This construction ensures that each block only depends on previous block.
- *
- *  Note 4 : If input buffer is a ring-buffer, it can have any size, including < 64 KB.
- *
- *  Note 5 : After an error, the stream status is undefined (invalid), it can only be reset or freed.
- */
-LZ4LIB_API int LZ4_compress_fast_continue (LZ4_stream_t* streamPtr, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-
-/*! LZ4_saveDict() :
- *  If last 64KB data cannot be guaranteed to remain available at its current memory location,
- *  save it into a safer place (char* safeBuffer).
- *  This is schematically equivalent to a memcpy() followed by LZ4_loadDict(),
- *  but is much faster, because LZ4_saveDict() doesn't need to rebuild tables.
- * @return : saved dictionary size in bytes (necessarily <= maxDictSize), or 0 if error.
- */
-LZ4LIB_API int LZ4_saveDict (LZ4_stream_t* streamPtr, char* safeBuffer, int maxDictSize);
-
-
-/*-**********************************************
-*  Streaming Decompression Functions
-*  Bufferless synchronous API
-************************************************/
-typedef union LZ4_streamDecode_u LZ4_streamDecode_t;   /* tracking context */
-
-/*! LZ4_createStreamDecode() and LZ4_freeStreamDecode() :
- *  creation / destruction of streaming decompression tracking context.
- *  A tracking context can be re-used multiple times.
- */
-#if !defined(RC_INVOKED) /* https://docs.microsoft.com/en-us/windows/win32/menurc/predefined-macros */
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-LZ4LIB_API LZ4_streamDecode_t* LZ4_createStreamDecode(void);
-LZ4LIB_API int                 LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream);
-#endif /* !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION) */
-#endif
-
-/*! LZ4_setStreamDecode() :
- *  An LZ4_streamDecode_t context can be allocated once and re-used multiple times.
- *  Use this function to start decompression of a new stream of blocks.
- *  A dictionary can optionally be set. Use NULL or size 0 for a reset order.
- *  Dictionary is presumed stable : it must remain accessible and unmodified during next decompression.
- * @return : 1 if OK, 0 if error
- */
-LZ4LIB_API int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize);
-
-/*! LZ4_decoderRingBufferSize() : v1.8.2+
- *  Note : in a ring buffer scenario (optional),
- *  blocks are presumed decompressed next to each other
- *  up to the moment there is not enough remaining space for next block (remainingSize < maxBlockSize),
- *  at which stage it resumes from beginning of ring buffer.
- *  When setting such a ring buffer for streaming decompression,
- *  provides the minimum size of this ring buffer
- *  to be compatible with any source respecting maxBlockSize condition.
- * @return : minimum ring buffer size,
- *           or 0 if there is an error (invalid maxBlockSize).
- */
-LZ4LIB_API int LZ4_decoderRingBufferSize(int maxBlockSize);
-#define LZ4_DECODER_RING_BUFFER_SIZE(maxBlockSize) (65536 + 14 + (maxBlockSize))  /* for static allocation; maxBlockSize presumed valid */
-
-/*! LZ4_decompress_safe_continue() :
- *  This decoding function allows decompression of consecutive blocks in "streaming" mode.
- *  The difference with the usual independent blocks is that
- *  new blocks are allowed to find references into former blocks.
- *  A block is an unsplittable entity, and must be presented entirely to the decompression function.
- *  LZ4_decompress_safe_continue() only accepts one block at a time.
- *  It's modeled after `LZ4_decompress_safe()` and behaves similarly.
- *
- * @LZ4_streamDecode : decompression state, tracking the position in memory of past data
- * @compressedSize : exact complete size of one compressed block.
- * @dstCapacity : size of destination buffer (which must be already allocated),
- *                must be an upper bound of decompressed size.
- * @return : number of bytes decompressed into destination buffer (necessarily <= dstCapacity)
- *           If destination buffer is not large enough, decoding will stop and output an error code (negative value).
- *           If the source stream is detected malformed, the function will stop decoding and return a negative result.
- *
- *  The last 64KB of previously decoded data *must* remain available and unmodified
- *  at the memory position where they were previously decoded.
- *  If less than 64KB of data has been decoded, all the data must be present.
- *
- *  Special : if decompression side sets a ring buffer, it must respect one of the following conditions :
- *  - Decompression buffer size is _at least_ LZ4_decoderRingBufferSize(maxBlockSize).
- *    maxBlockSize is the maximum size of any single block. It can have any value > 16 bytes.
- *    In which case, encoding and decoding buffers do not need to be synchronized.
- *    Actually, data can be produced by any source compliant with LZ4 format specification, and respecting maxBlockSize.
- *  - Synchronized mode :
- *    Decompression buffer size is _exactly_ the same as compression buffer size,
- *    and follows exactly same update rule (block boundaries at same positions),
- *    and decoding function is provided with exact decompressed size of each block (exception for last block of the stream),
- *    _then_ decoding & encoding ring buffer can have any size, including small ones ( < 64 KB).
- *  - Decompression buffer is larger than encoding buffer, by a minimum of maxBlockSize more bytes.
- *    In which case, encoding and decoding buffers do not need to be synchronized,
- *    and encoding ring buffer can have any size, including small ones ( < 64 KB).
- *
- *  Whenever these conditions are not possible,
- *  save the last 64KB of decoded data into a safe buffer where it can't be modified during decompression,
- *  then indicate where this data is saved using LZ4_setStreamDecode(), before decompressing next block.
-*/
-LZ4LIB_API int
-LZ4_decompress_safe_continue (LZ4_streamDecode_t* LZ4_streamDecode,
-                        const char* src, char* dst,
-                        int srcSize, int dstCapacity);
-
-
-/*! LZ4_decompress_safe_usingDict() :
- *  Works the same as
- *  a combination of LZ4_setStreamDecode() followed by LZ4_decompress_safe_continue()
- *  However, it's stateless: it doesn't need any LZ4_streamDecode_t state.
- *  Dictionary is presumed stable : it must remain accessible and unmodified during decompression.
- *  Performance tip : Decompression speed can be substantially increased
- *                    when dst == dictStart + dictSize.
- */
-LZ4LIB_API int
-LZ4_decompress_safe_usingDict(const char* src, char* dst,
-                              int srcSize, int dstCapacity,
-                              const char* dictStart, int dictSize);
-
-/*! LZ4_decompress_safe_partial_usingDict() :
- *  Behaves the same as LZ4_decompress_safe_partial()
- *  with the added ability to specify a memory segment for past data.
- *  Performance tip : Decompression speed can be substantially increased
- *                    when dst == dictStart + dictSize.
- */
-LZ4LIB_API int
-LZ4_decompress_safe_partial_usingDict(const char* src, char* dst,
-                                      int compressedSize,
-                                      int targetOutputSize, int maxOutputSize,
-                                      const char* dictStart, int dictSize);
-
-#endif /* LZ4_H_2983827168210 */
-
-
-/*^*************************************
- * !!!!!!   STATIC LINKING ONLY   !!!!!!
- ***************************************/
-
-/*-****************************************************************************
- * Experimental section
- *
- * Symbols declared in this section must be considered unstable. Their
- * signatures or semantics may change, or they may be removed altogether in the
- * future. They are therefore only safe to depend on when the caller is
- * statically linked against the library.
- *
- * To protect against unsafe usage, not only are the declarations guarded,
- * the definitions are hidden by default
- * when building LZ4 as a shared/dynamic library.
- *
- * In order to access these declarations,
- * define LZ4_STATIC_LINKING_ONLY in your application
- * before including LZ4's headers.
- *
- * In order to make their implementations accessible dynamically, you must
- * define LZ4_PUBLISH_STATIC_FUNCTIONS when building the LZ4 library.
- ******************************************************************************/
-
-#ifdef LZ4_STATIC_LINKING_ONLY
-
-#ifndef LZ4_STATIC_3504398509
-#define LZ4_STATIC_3504398509
-
-#ifdef LZ4_PUBLISH_STATIC_FUNCTIONS
-# define LZ4LIB_STATIC_API LZ4LIB_API
-#else
-# define LZ4LIB_STATIC_API
-#endif
-
-
-/*! LZ4_compress_fast_extState_fastReset() :
- *  A variant of LZ4_compress_fast_extState().
- *
- *  Using this variant avoids an expensive initialization step.
- *  It is only safe to call if the state buffer is known to be correctly initialized already
- *  (see above comment on LZ4_resetStream_fast() for a definition of "correctly initialized").
- *  From a high level, the difference is that
- *  this function initializes the provided state with a call to something like LZ4_resetStream_fast()
- *  while LZ4_compress_fast_extState() starts with a call to LZ4_resetStream().
- */
-LZ4LIB_STATIC_API int LZ4_compress_fast_extState_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int acceleration);
-
-/*! LZ4_compress_destSize_extState() : introduced in v1.10.0
- *  Same as LZ4_compress_destSize(), but using an externally allocated state.
- *  Also: exposes @acceleration
- */
-int LZ4_compress_destSize_extState(void* state, const char* src, char* dst, int* srcSizePtr, int targetDstSize, int acceleration);
-
-/*! In-place compression and decompression
- *
- * It's possible to have input and output sharing the same buffer,
- * for highly constrained memory environments.
- * In both cases, it requires input to lay at the end of the buffer,
- * and decompression to start at beginning of the buffer.
- * Buffer size must feature some margin, hence be larger than final size.
- *
- * |<------------------------buffer--------------------------------->|
- *                             |<-----------compressed data--------->|
- * |<-----------decompressed size------------------>|
- *                                                  |<----margin---->|
- *
- * This technique is more useful for decompression,
- * since decompressed size is typically larger,
- * and margin is short.
- *
- * In-place decompression will work inside any buffer
- * which size is >= LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize).
- * This presumes that decompressedSize > compressedSize.
- * Otherwise, it means compression actually expanded data,
- * and it would be more efficient to store such data with a flag indicating it's not compressed.
- * This can happen when data is not compressible (already compressed, or encrypted).
- *
- * For in-place compression, margin is larger, as it must be able to cope with both
- * history preservation, requiring input data to remain unmodified up to LZ4_DISTANCE_MAX,
- * and data expansion, which can happen when input is not compressible.
- * As a consequence, buffer size requirements are much higher,
- * and memory savings offered by in-place compression are more limited.
- *
- * There are ways to limit this cost for compression :
- * - Reduce history size, by modifying LZ4_DISTANCE_MAX.
- *   Note that it is a compile-time constant, so all compressions will apply this limit.
- *   Lower values will reduce compression ratio, except when input_size < LZ4_DISTANCE_MAX,
- *   so it's a reasonable trick when inputs are known to be small.
- * - Require the compressor to deliver a "maximum compressed size".
- *   This is the `dstCapacity` parameter in `LZ4_compress*()`.
- *   When this size is < LZ4_COMPRESSBOUND(inputSize), then compression can fail,
- *   in which case, the return code will be 0 (zero).
- *   The caller must be ready for these cases to happen,
- *   and typically design a backup scheme to send data uncompressed.
- * The combination of both techniques can significantly reduce
- * the amount of margin required for in-place compression.
- *
- * In-place compression can work in any buffer
- * which size is >= (maxCompressedSize)
- * with maxCompressedSize == LZ4_COMPRESSBOUND(srcSize) for guaranteed compression success.
- * LZ4_COMPRESS_INPLACE_BUFFER_SIZE() depends on both maxCompressedSize and LZ4_DISTANCE_MAX,
- * so it's possible to reduce memory requirements by playing with them.
- */
-
-#define LZ4_DECOMPRESS_INPLACE_MARGIN(compressedSize)          (((compressedSize) >> 8) + 32)
-#define LZ4_DECOMPRESS_INPLACE_BUFFER_SIZE(decompressedSize)   ((decompressedSize) + LZ4_DECOMPRESS_INPLACE_MARGIN(decompressedSize))  /**< note: presumes that compressedSize < decompressedSize. note2: margin is overestimated a bit, since it could use compressedSize instead */
-
-#ifndef LZ4_DISTANCE_MAX   /* history window size; can be user-defined at compile time */
-#  define LZ4_DISTANCE_MAX 65535   /* set to maximum value by default */
-#endif
-
-#define LZ4_COMPRESS_INPLACE_MARGIN                           (LZ4_DISTANCE_MAX + 32)   /* LZ4_DISTANCE_MAX can be safely replaced by srcSize when it's smaller */
-#define LZ4_COMPRESS_INPLACE_BUFFER_SIZE(maxCompressedSize)   ((maxCompressedSize) + LZ4_COMPRESS_INPLACE_MARGIN)  /**< maxCompressedSize is generally LZ4_COMPRESSBOUND(inputSize), but can be set to any lower value, with the risk that compression can fail (return code 0(zero)) */
-
-#endif   /* LZ4_STATIC_3504398509 */
-#endif   /* LZ4_STATIC_LINKING_ONLY */
-
-
-
-#ifndef LZ4_H_98237428734687
-#define LZ4_H_98237428734687
-
-/*-************************************************************
- *  Private Definitions
- **************************************************************
- * Do not use these definitions directly.
- * They are only exposed to allow static allocation of `LZ4_stream_t` and `LZ4_streamDecode_t`.
- * Accessing members will expose user code to API and/or ABI break in future versions of the library.
- **************************************************************/
-#define LZ4_HASHLOG   (LZ4_MEMORY_USAGE-2)
-#define LZ4_HASHTABLESIZE (1 << LZ4_MEMORY_USAGE)
-#define LZ4_HASH_SIZE_U32 (1 << LZ4_HASHLOG)       /* required as macro for static allocation */
-
-#if defined(__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
-# include <stdint.h>
-  typedef  int8_t  LZ4_i8;
-  typedef uint8_t  LZ4_byte;
-  typedef uint16_t LZ4_u16;
-  typedef uint32_t LZ4_u32;
-#else
-  typedef   signed char  LZ4_i8;
-  typedef unsigned char  LZ4_byte;
-  typedef unsigned short LZ4_u16;
-  typedef unsigned int   LZ4_u32;
-#endif
-
-/*! LZ4_stream_t :
- *  Never ever use below internal definitions directly !
- *  These definitions are not API/ABI safe, and may change in future versions.
- *  If you need static allocation, declare or allocate an LZ4_stream_t object.
-**/
-
-typedef struct LZ4_stream_t_internal LZ4_stream_t_internal;
-struct LZ4_stream_t_internal {
-    LZ4_u32 hashTable[LZ4_HASH_SIZE_U32];
-    const LZ4_byte* dictionary;
-    const LZ4_stream_t_internal* dictCtx;
-    LZ4_u32 currentOffset;
-    LZ4_u32 tableType;
-    LZ4_u32 dictSize;
-    /* Implicit padding to ensure structure is aligned */
-};
-
-#define LZ4_STREAM_MINSIZE  ((1UL << (LZ4_MEMORY_USAGE)) + 32)  /* static size, for inter-version compatibility */
-union LZ4_stream_u {
-    char minStateSize[LZ4_STREAM_MINSIZE];
-    LZ4_stream_t_internal internal_donotuse;
-}; /* previously typedef'd to LZ4_stream_t */
-
-
-/*! LZ4_initStream() : v1.9.0+
- *  An LZ4_stream_t structure must be initialized at least once.
- *  This is automatically done when invoking LZ4_createStream(),
- *  but it's not when the structure is simply declared on stack (for example).
- *
- *  Use LZ4_initStream() to properly initialize a newly declared LZ4_stream_t.
- *  It can also initialize any arbitrary buffer of sufficient size,
- *  and will @return a pointer of proper type upon initialization.
- *
- *  Note : initialization fails if size and alignment conditions are not respected.
- *         In which case, the function will @return NULL.
- *  Note2: An LZ4_stream_t structure guarantees correct alignment and size.
- *  Note3: Before v1.9.0, use LZ4_resetStream() instead
-**/
-LZ4LIB_API LZ4_stream_t* LZ4_initStream (void* stateBuffer, size_t size);
-
-
-/*! LZ4_streamDecode_t :
- *  Never ever use below internal definitions directly !
- *  These definitions are not API/ABI safe, and may change in future versions.
- *  If you need static allocation, declare or allocate an LZ4_streamDecode_t object.
-**/
-typedef struct {
-    const LZ4_byte* externalDict;
-    const LZ4_byte* prefixEnd;
-    size_t extDictSize;
-    size_t prefixSize;
-} LZ4_streamDecode_t_internal;
-
-#define LZ4_STREAMDECODE_MINSIZE 32
-union LZ4_streamDecode_u {
-    char minStateSize[LZ4_STREAMDECODE_MINSIZE];
-    LZ4_streamDecode_t_internal internal_donotuse;
-} ;   /* previously typedef'd to LZ4_streamDecode_t */
-
-
-
-/*-************************************
-*  Obsolete Functions
-**************************************/
-
-/*! Deprecation warnings
- *
- *  Deprecated functions make the compiler generate a warning when invoked.
- *  This is meant to invite users to update their source code.
- *  Should deprecation warnings be a problem, it is generally possible to disable them,
- *  typically with -Wno-deprecated-declarations for gcc
- *  or _CRT_SECURE_NO_WARNINGS in Visual.
- *
- *  Another method is to define LZ4_DISABLE_DEPRECATE_WARNINGS
- *  before including the header file.
- */
-#ifdef LZ4_DISABLE_DEPRECATE_WARNINGS
-#  define LZ4_DEPRECATED(message)   /* disable deprecation warnings */
-#else
-#  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */
-#    define LZ4_DEPRECATED(message) [[deprecated(message)]]
-#  elif defined(_MSC_VER)
-#    define LZ4_DEPRECATED(message) __declspec(deprecated(message))
-#  elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 45))
-#    define LZ4_DEPRECATED(message) __attribute__((deprecated(message)))
-#  elif defined(__GNUC__) && (__GNUC__ * 10 + __GNUC_MINOR__ >= 31)
-#    define LZ4_DEPRECATED(message) __attribute__((deprecated))
-#  else
-#    pragma message("WARNING: LZ4_DEPRECATED needs custom implementation for this compiler")
-#    define LZ4_DEPRECATED(message)   /* disabled */
-#  endif
-#endif /* LZ4_DISABLE_DEPRECATE_WARNINGS */
-
-/*! Obsolete compression functions (since v1.7.3) */
-LZ4_DEPRECATED("use LZ4_compress_default() instead")       LZ4LIB_API int LZ4_compress               (const char* src, char* dest, int srcSize);
-LZ4_DEPRECATED("use LZ4_compress_default() instead")       LZ4LIB_API int LZ4_compress_limitedOutput (const char* src, char* dest, int srcSize, int maxOutputSize);
-LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_withState               (void* state, const char* source, char* dest, int inputSize);
-LZ4_DEPRECATED("use LZ4_compress_fast_extState() instead") LZ4LIB_API int LZ4_compress_limitedOutput_withState (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
-LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_continue                (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize);
-LZ4_DEPRECATED("use LZ4_compress_fast_continue() instead") LZ4LIB_API int LZ4_compress_limitedOutput_continue  (LZ4_stream_t* LZ4_streamPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
-
-/*! Obsolete decompression functions (since v1.8.0) */
-LZ4_DEPRECATED("use LZ4_decompress_fast() instead") LZ4LIB_API int LZ4_uncompress (const char* source, char* dest, int outputSize);
-LZ4_DEPRECATED("use LZ4_decompress_safe() instead") LZ4LIB_API int LZ4_uncompress_unknownOutputSize (const char* source, char* dest, int isize, int maxOutputSize);
-
-/* Obsolete streaming functions (since v1.7.0)
- * degraded functionality; do not use!
- *
- * In order to perform streaming compression, these functions depended on data
- * that is no longer tracked in the state. They have been preserved as well as
- * possible: using them will still produce a correct output. However, they don't
- * actually retain any history between compression calls. The compression ratio
- * achieved will therefore be no better than compressing each chunk
- * independently.
- */
-LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API void* LZ4_create (char* inputBuffer);
-LZ4_DEPRECATED("Use LZ4_createStream() instead") LZ4LIB_API int   LZ4_sizeofStreamState(void);
-LZ4_DEPRECATED("Use LZ4_resetStream() instead")  LZ4LIB_API int   LZ4_resetStreamState(void* state, char* inputBuffer);
-LZ4_DEPRECATED("Use LZ4_saveDict() instead")     LZ4LIB_API char* LZ4_slideInputBuffer (void* state);
-
-/*! Obsolete streaming decoding functions (since v1.7.0) */
-LZ4_DEPRECATED("use LZ4_decompress_safe_usingDict() instead") LZ4LIB_API int LZ4_decompress_safe_withPrefix64k (const char* src, char* dst, int compressedSize, int maxDstSize);
-LZ4_DEPRECATED("use LZ4_decompress_fast_usingDict() instead") LZ4LIB_API int LZ4_decompress_fast_withPrefix64k (const char* src, char* dst, int originalSize);
-
-/*! Obsolete LZ4_decompress_fast variants (since v1.9.0) :
- *  These functions used to be faster than LZ4_decompress_safe(),
- *  but this is no longer the case. They are now slower.
- *  This is because LZ4_decompress_fast() doesn't know the input size,
- *  and therefore must progress more cautiously into the input buffer to not read beyond the end of block.
- *  On top of that `LZ4_decompress_fast()` is not protected vs malformed or malicious inputs, making it a security liability.
- *  As a consequence, LZ4_decompress_fast() is strongly discouraged, and deprecated.
- *
- *  The last remaining LZ4_decompress_fast() specificity is that
- *  it can decompress a block without knowing its compressed size.
- *  Such functionality can be achieved in a more secure manner
- *  by employing LZ4_decompress_safe_partial().
- *
- *  Parameters:
- *  originalSize : is the uncompressed size to regenerate.
- *                 `dst` must be already allocated, its size must be >= 'originalSize' bytes.
- * @return : number of bytes read from source buffer (== compressed size).
- *           The function expects to finish at block's end exactly.
- *           If the source stream is detected malformed, the function stops decoding and returns a negative result.
- *  note : LZ4_decompress_fast*() requires originalSize. Thanks to this information, it never writes past the output buffer.
- *         However, since it doesn't know its 'src' size, it may read an unknown amount of input, past input buffer bounds.
- *         Also, since match offsets are not validated, match reads from 'src' may underflow too.
- *         These issues never happen if input (compressed) data is correct.
- *         But they may happen if input data is invalid (error or intentional tampering).
- *         As a consequence, use these functions in trusted environments with trusted data **only**.
- */
-LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_partial() instead")
-LZ4LIB_API int LZ4_decompress_fast (const char* src, char* dst, int originalSize);
-LZ4_DEPRECATED("This function is deprecated and unsafe. Consider migrating towards LZ4_decompress_safe_continue() instead. "
-               "Note that the contract will change (requires block's compressed size, instead of decompressed size)")
-LZ4LIB_API int LZ4_decompress_fast_continue (LZ4_streamDecode_t* LZ4_streamDecode, const char* src, char* dst, int originalSize);
-LZ4_DEPRECATED("This function is deprecated and unsafe. Consider using LZ4_decompress_safe_partial_usingDict() instead")
-LZ4LIB_API int LZ4_decompress_fast_usingDict (const char* src, char* dst, int originalSize, const char* dictStart, int dictSize);
-
-/*! LZ4_resetStream() :
- *  An LZ4_stream_t structure must be initialized at least once.
- *  This is done with LZ4_initStream(), or LZ4_resetStream().
- *  Consider switching to LZ4_initStream(),
- *  invoking LZ4_resetStream() will trigger deprecation warnings in the future.
- */
-LZ4LIB_API void LZ4_resetStream (LZ4_stream_t* streamPtr);
-
-
-#endif /* LZ4_H_98237428734687 */
-
-
-#if defined (__cplusplus)
-}
-#endif
diff --git a/native/lz4/vendor/lib/lz4hc.c b/native/lz4/vendor/lib/lz4hc.c
deleted file mode 100644
index 4d8c36a..0000000
--- a/native/lz4/vendor/lib/lz4hc.c
+++ /dev/null
@@ -1,2192 +0,0 @@
-/*
-    LZ4 HC - High Compression Mode of LZ4
-    Copyright (C) 2011-2020, Yann Collet.
-
-    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are
-    met:
-
-    * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-    copyright notice, this list of conditions and the following disclaimer
-    in the documentation and/or other materials provided with the
-    distribution.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-    You can contact the author at :
-       - LZ4 source repository : https://github.com/lz4/lz4
-       - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-/* note : lz4hc is not an independent module, it requires lz4.h/lz4.c for proper compilation */
-
-
-/* *************************************
-*  Tuning Parameter
-***************************************/
-
-/*! HEAPMODE :
- *  Select how stateless HC compression functions like `LZ4_compress_HC()`
- *  allocate memory for their workspace:
- *  in stack (0:fastest), or in heap (1:default, requires malloc()).
- *  Since workspace is rather large, heap mode is recommended.
-**/
-#ifndef LZ4HC_HEAPMODE
-#  define LZ4HC_HEAPMODE 1
-#endif
-
-
-/*===    Dependency    ===*/
-#define LZ4_HC_STATIC_LINKING_ONLY
-#include "lz4hc.h"
-#include <limits.h>
-
-
-/*===   Shared lz4.c code   ===*/
-#ifndef LZ4_SRC_INCLUDED
-# if defined(__GNUC__)
-#  pragma GCC diagnostic ignored "-Wunused-function"
-# endif
-# if defined (__clang__)
-#  pragma clang diagnostic ignored "-Wunused-function"
-# endif
-# define LZ4_COMMONDEFS_ONLY
-# include "lz4.c"   /* LZ4_count, constants, mem */
-#endif
-
-
-/*===   Enums   ===*/
-typedef enum { noDictCtx, usingDictCtxHc } dictCtx_directive;
-
-
-/*===   Constants   ===*/
-#define OPTIMAL_ML (int)((ML_MASK-1)+MINMATCH)
-#define LZ4_OPT_NUM   (1<<12)
-
-
-/*===   Macros   ===*/
-#define MIN(a,b)   ( (a) < (b) ? (a) : (b) )
-#define MAX(a,b)   ( (a) > (b) ? (a) : (b) )
-
-
-/*===   Levels definition   ===*/
-typedef enum { lz4mid, lz4hc, lz4opt } lz4hc_strat_e;
-typedef struct {
-    lz4hc_strat_e strat;
-    int nbSearches;
-    U32 targetLength;
-} cParams_t;
-static const cParams_t k_clTable[LZ4HC_CLEVEL_MAX+1] = {
-    { lz4mid,    2, 16 },  /* 0, unused */
-    { lz4mid,    2, 16 },  /* 1, unused */
-    { lz4mid,    2, 16 },  /* 2 */
-    { lz4hc,     4, 16 },  /* 3 */
-    { lz4hc,     8, 16 },  /* 4 */
-    { lz4hc,    16, 16 },  /* 5 */
-    { lz4hc,    32, 16 },  /* 6 */
-    { lz4hc,    64, 16 },  /* 7 */
-    { lz4hc,   128, 16 },  /* 8 */
-    { lz4hc,   256, 16 },  /* 9 */
-    { lz4opt,   96, 64 },  /*10==LZ4HC_CLEVEL_OPT_MIN*/
-    { lz4opt,  512,128 },  /*11 */
-    { lz4opt,16384,LZ4_OPT_NUM },  /* 12==LZ4HC_CLEVEL_MAX */
-};
-
-static cParams_t LZ4HC_getCLevelParams(int cLevel)
-{
-    /* note : clevel convention is a bit different from lz4frame,
-     * possibly something worth revisiting for consistency */
-    if (cLevel < 1)
-        cLevel = LZ4HC_CLEVEL_DEFAULT;
-    cLevel = MIN(LZ4HC_CLEVEL_MAX, cLevel);
-    return k_clTable[cLevel];
-}
-
-
-/*===   Hashing   ===*/
-#define LZ4HC_HASHSIZE 4
-#define HASH_FUNCTION(i)      (((i) * 2654435761U) >> ((MINMATCH*8)-LZ4HC_HASH_LOG))
-static U32 LZ4HC_hashPtr(const void* ptr) { return HASH_FUNCTION(LZ4_read32(ptr)); }
-
-#if defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==2)
-/* lie to the compiler about data alignment; use with caution */
-static U64 LZ4_read64(const void* memPtr) { return *(const U64*) memPtr; }
-
-#elif defined(LZ4_FORCE_MEMORY_ACCESS) && (LZ4_FORCE_MEMORY_ACCESS==1)
-/* __pack instructions are safer, but compiler specific */
-LZ4_PACK(typedef struct { U64 u64; }) LZ4_unalign64;
-static U64 LZ4_read64(const void* ptr) { return ((const LZ4_unalign64*)ptr)->u64; }
-
-#else  /* safe and portable access using memcpy() */
-static U64 LZ4_read64(const void* memPtr)
-{
-    U64 val; LZ4_memcpy(&val, memPtr, sizeof(val)); return val;
-}
-
-#endif /* LZ4_FORCE_MEMORY_ACCESS */
-
-#define LZ4MID_HASHSIZE 8
-#define LZ4MID_HASHLOG (LZ4HC_HASH_LOG-1)
-#define LZ4MID_HASHTABLESIZE (1 << LZ4MID_HASHLOG)
-
-static U32 LZ4MID_hash4(U32 v) { return (v * 2654435761U) >> (32-LZ4MID_HASHLOG); }
-static U32 LZ4MID_hash4Ptr(const void* ptr) { return LZ4MID_hash4(LZ4_read32(ptr)); }
-/* note: hash7 hashes the lower 56-bits.
- * It presumes input was read using little endian.*/
-static U32 LZ4MID_hash7(U64 v) { return (U32)(((v  << (64-56)) * 58295818150454627ULL) >> (64-LZ4MID_HASHLOG)) ; }
-static U64 LZ4_readLE64(const void* memPtr);
-static U32 LZ4MID_hash8Ptr(const void* ptr) { return LZ4MID_hash7(LZ4_readLE64(ptr)); }
-
-static U64 LZ4_readLE64(const void* memPtr)
-{
-    if (LZ4_isLittleEndian()) {
-        return LZ4_read64(memPtr);
-    } else {
-        const BYTE* p = (const BYTE*)memPtr;
-        /* note: relies on the compiler to simplify this expression */
-        return (U64)p[0] | ((U64)p[1]<<8) | ((U64)p[2]<<16) | ((U64)p[3]<<24)
-            | ((U64)p[4]<<32) | ((U64)p[5]<<40) | ((U64)p[6]<<48) | ((U64)p[7]<<56);
-    }
-}
-
-
-/*===   Count match length   ===*/
-LZ4_FORCE_INLINE
-unsigned LZ4HC_NbCommonBytes32(U32 val)
-{
-    assert(val != 0);
-    if (LZ4_isLittleEndian()) {
-#     if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(LZ4_FORCE_SW_BITCOUNT)
-        unsigned long r;
-        _BitScanReverse(&r, val);
-        return (unsigned)((31 - r) >> 3);
-#     elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
-                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
-                                        !defined(LZ4_FORCE_SW_BITCOUNT)
-        return (unsigned)__builtin_clz(val) >> 3;
-#     else
-        val >>= 8;
-        val = ((((val + 0x00FFFF00) | 0x00FFFFFF) + val) |
-              (val + 0x00FF0000)) >> 24;
-        return (unsigned)val ^ 3;
-#     endif
-    } else {
-#     if defined(_MSC_VER) && (_MSC_VER >= 1400) && !defined(LZ4_FORCE_SW_BITCOUNT)
-        unsigned long r;
-        _BitScanForward(&r, val);
-        return (unsigned)(r >> 3);
-#     elif (defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 3) || \
-                            ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 4))))) && \
-                                        !defined(LZ4_FORCE_SW_BITCOUNT)
-        return (unsigned)__builtin_ctz(val) >> 3;
-#     else
-        const U32 m = 0x01010101;
-        return (unsigned)((((val - 1) ^ val) & (m - 1)) * m) >> 24;
-#     endif
-    }
-}
-
-/** LZ4HC_countBack() :
- * @return : negative value, nb of common bytes before ip/match */
-LZ4_FORCE_INLINE
-int LZ4HC_countBack(const BYTE* const ip, const BYTE* const match,
-                    const BYTE* const iMin, const BYTE* const mMin)
-{
-    int back = 0;
-    int const min = (int)MAX(iMin - ip, mMin - match);
-    assert(min <= 0);
-    assert(ip >= iMin); assert((size_t)(ip-iMin) < (1U<<31));
-    assert(match >= mMin); assert((size_t)(match - mMin) < (1U<<31));
-
-    while ((back - min) > 3) {
-        U32 const v = LZ4_read32(ip + back - 4) ^ LZ4_read32(match + back - 4);
-        if (v) {
-            return (back - (int)LZ4HC_NbCommonBytes32(v));
-        } else back -= 4; /* 4-byte step */
-    }
-    /* check remainder if any */
-    while ( (back > min)
-         && (ip[back-1] == match[back-1]) )
-            back--;
-    return back;
-}
-
-/*===   Chain table updates   ===*/
-#define DELTANEXTU16(table, pos) table[(U16)(pos)]   /* faster */
-/* Make fields passed to, and updated by LZ4HC_encodeSequence explicit */
-#define UPDATABLE(ip, op, anchor) &ip, &op, &anchor
-
-
-/**************************************
-*  Init
-**************************************/
-static void LZ4HC_clearTables (LZ4HC_CCtx_internal* hc4)
-{
-    MEM_INIT(hc4->hashTable, 0, sizeof(hc4->hashTable));
-    MEM_INIT(hc4->chainTable, 0xFF, sizeof(hc4->chainTable));
-}
-
-static void LZ4HC_init_internal (LZ4HC_CCtx_internal* hc4, const BYTE* start)
-{
-    size_t const bufferSize = (size_t)(hc4->end - hc4->prefixStart);
-    size_t newStartingOffset = bufferSize + hc4->dictLimit;
-    DEBUGLOG(5, "LZ4HC_init_internal");
-    assert(newStartingOffset >= bufferSize);  /* check overflow */
-    if (newStartingOffset > 1 GB) {
-        LZ4HC_clearTables(hc4);
-        newStartingOffset = 0;
-    }
-    newStartingOffset += 64 KB;
-    hc4->nextToUpdate = (U32)newStartingOffset;
-    hc4->prefixStart = start;
-    hc4->end = start;
-    hc4->dictStart = start;
-    hc4->dictLimit = (U32)newStartingOffset;
-    hc4->lowLimit = (U32)newStartingOffset;
-}
-
-
-/**************************************
-*  Encode
-**************************************/
-/* LZ4HC_encodeSequence() :
- * @return : 0 if ok,
- *           1 if buffer issue detected */
-LZ4_FORCE_INLINE int LZ4HC_encodeSequence (
-    const BYTE** _ip,
-    BYTE** _op,
-    const BYTE** _anchor,
-    int matchLength,
-    int offset,
-    limitedOutput_directive limit,
-    BYTE* oend)
-{
-#define ip      (*_ip)
-#define op      (*_op)
-#define anchor  (*_anchor)
-
-    size_t length;
-    BYTE* const token = op++;
-
-#if defined(LZ4_DEBUG) && (LZ4_DEBUG >= 6)
-    static const BYTE* start = NULL;
-    static U32 totalCost = 0;
-    U32 const pos = (start==NULL) ? 0 : (U32)(anchor - start);
-    U32 const ll = (U32)(ip - anchor);
-    U32 const llAdd = (ll>=15) ? ((ll-15) / 255) + 1 : 0;
-    U32 const mlAdd = (matchLength>=19) ? ((matchLength-19) / 255) + 1 : 0;
-    U32 const cost = 1 + llAdd + ll + 2 + mlAdd;
-    if (start==NULL) start = anchor;  /* only works for single segment */
-    /* g_debuglog_enable = (pos >= 2228) & (pos <= 2262); */
-    DEBUGLOG(6, "pos:%7u -- literals:%4u, match:%4i, offset:%5i, cost:%4u + %5u",
-                pos,
-                (U32)(ip - anchor), matchLength, offset,
-                cost, totalCost);
-    totalCost += cost;
-#endif
-
-    /* Encode Literal length */
-    length = (size_t)(ip - anchor);
-    LZ4_STATIC_ASSERT(notLimited == 0);
-    /* Check output limit */
-    if (limit && ((op + (length / 255) + length + (2 + 1 + LASTLITERALS)) > oend)) {
-        DEBUGLOG(6, "Not enough room to write %i literals (%i bytes remaining)",
-                (int)length, (int)(oend - op));
-        return 1;
-    }
-    if (length >= RUN_MASK) {
-        size_t len = length - RUN_MASK;
-        *token = (RUN_MASK << ML_BITS);
-        for(; len >= 255 ; len -= 255) *op++ = 255;
-        *op++ = (BYTE)len;
-    } else {
-        *token = (BYTE)(length << ML_BITS);
-    }
-
-    /* Copy Literals */
-    LZ4_wildCopy8(op, anchor, op + length);
-    op += length;
-
-    /* Encode Offset */
-    assert(offset <= LZ4_DISTANCE_MAX );
-    assert(offset > 0);
-    LZ4_writeLE16(op, (U16)(offset)); op += 2;
-
-    /* Encode MatchLength */
-    assert(matchLength >= MINMATCH);
-    length = (size_t)matchLength - MINMATCH;
-    if (limit && (op + (length / 255) + (1 + LASTLITERALS) > oend)) {
-        DEBUGLOG(6, "Not enough room to write match length");
-        return 1;   /* Check output limit */
-    }
-    if (length >= ML_MASK) {
-        *token += ML_MASK;
-        length -= ML_MASK;
-        for(; length >= 510 ; length -= 510) { *op++ = 255; *op++ = 255; }
-        if (length >= 255) { length -= 255; *op++ = 255; }
-        *op++ = (BYTE)length;
-    } else {
-        *token += (BYTE)(length);
-    }
-
-    /* Prepare next loop */
-    ip += matchLength;
-    anchor = ip;
-
-    return 0;
-
-#undef ip
-#undef op
-#undef anchor
-}
-
-
-typedef struct {
-    int off;
-    int len;
-    int back;  /* negative value */
-} LZ4HC_match_t;
-
-LZ4HC_match_t LZ4HC_searchExtDict(const BYTE* ip, U32 ipIndex,
-        const BYTE* const iLowLimit, const BYTE* const iHighLimit,
-        const LZ4HC_CCtx_internal* dictCtx, U32 gDictEndIndex,
-        int currentBestML, int nbAttempts)
-{
-    size_t const lDictEndIndex = (size_t)(dictCtx->end - dictCtx->prefixStart) + dictCtx->dictLimit;
-    U32 lDictMatchIndex = dictCtx->hashTable[LZ4HC_hashPtr(ip)];
-    U32 matchIndex = lDictMatchIndex + gDictEndIndex - (U32)lDictEndIndex;
-    int offset = 0, sBack = 0;
-    assert(lDictEndIndex <= 1 GB);
-    if (lDictMatchIndex>0)
-        DEBUGLOG(7, "lDictEndIndex = %zu, lDictMatchIndex = %u", lDictEndIndex, lDictMatchIndex);
-    while (ipIndex - matchIndex <= LZ4_DISTANCE_MAX && nbAttempts--) {
-        const BYTE* const matchPtr = dictCtx->prefixStart - dictCtx->dictLimit + lDictMatchIndex;
-
-        if (LZ4_read32(matchPtr) == LZ4_read32(ip)) {
-            int mlt;
-            int back = 0;
-            const BYTE* vLimit = ip + (lDictEndIndex - lDictMatchIndex);
-            if (vLimit > iHighLimit) vLimit = iHighLimit;
-            mlt = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH;
-            back = (ip > iLowLimit) ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictCtx->prefixStart) : 0;
-            mlt -= back;
-            if (mlt > currentBestML) {
-                currentBestML = mlt;
-                offset = (int)(ipIndex - matchIndex);
-                sBack = back;
-                DEBUGLOG(7, "found match of length %i within extDictCtx", currentBestML);
-        }   }
-
-        {   U32 const nextOffset = DELTANEXTU16(dictCtx->chainTable, lDictMatchIndex);
-            lDictMatchIndex -= nextOffset;
-            matchIndex -= nextOffset;
-    }   }
-
-    {   LZ4HC_match_t md;
-        md.len = currentBestML;
-        md.off = offset;
-        md.back = sBack;
-        return md;
-    }
-}
-
-typedef LZ4HC_match_t (*LZ4MID_searchIntoDict_f)(const BYTE* ip, U32 ipIndex,
-        const BYTE* const iHighLimit,
-        const LZ4HC_CCtx_internal* dictCtx, U32 gDictEndIndex);
-
-static LZ4HC_match_t LZ4MID_searchHCDict(const BYTE* ip, U32 ipIndex,
-        const BYTE* const iHighLimit,
-        const LZ4HC_CCtx_internal* dictCtx, U32 gDictEndIndex)
-{
-    return LZ4HC_searchExtDict(ip,ipIndex,
-                            ip, iHighLimit,
-                            dictCtx, gDictEndIndex,
-                            MINMATCH-1, 2);
-}
-
-static LZ4HC_match_t LZ4MID_searchExtDict(const BYTE* ip, U32 ipIndex,
-        const BYTE* const iHighLimit,
-        const LZ4HC_CCtx_internal* dictCtx, U32 gDictEndIndex)
-{
-    size_t const lDictEndIndex = (size_t)(dictCtx->end - dictCtx->prefixStart) + dictCtx->dictLimit;
-    const U32* const hash4Table = dictCtx->hashTable;
-    const U32* const hash8Table = hash4Table + LZ4MID_HASHTABLESIZE;
-    DEBUGLOG(7, "LZ4MID_searchExtDict (ipIdx=%u)", ipIndex);
-
-    /* search long match first */
-    {   U32 l8DictMatchIndex = hash8Table[LZ4MID_hash8Ptr(ip)];
-        U32 m8Index = l8DictMatchIndex + gDictEndIndex - (U32)lDictEndIndex;
-        assert(lDictEndIndex <= 1 GB);
-        if (ipIndex - m8Index <= LZ4_DISTANCE_MAX) {
-            const BYTE* const matchPtr = dictCtx->prefixStart - dictCtx->dictLimit + l8DictMatchIndex;
-            const size_t safeLen = MIN(lDictEndIndex - l8DictMatchIndex, (size_t)(iHighLimit - ip));
-            int mlt = (int)LZ4_count(ip, matchPtr, ip + safeLen);
-            if (mlt >= MINMATCH) {
-                LZ4HC_match_t md;
-                DEBUGLOG(7, "Found long ExtDict match of len=%u", mlt);
-                md.len = mlt;
-                md.off = (int)(ipIndex - m8Index);
-                md.back = 0;
-                return md;
-            }
-        }
-    }
-
-    /* search for short match second */
-    {   U32 l4DictMatchIndex = hash4Table[LZ4MID_hash4Ptr(ip)];
-        U32 m4Index = l4DictMatchIndex + gDictEndIndex - (U32)lDictEndIndex;
-        if (ipIndex - m4Index <= LZ4_DISTANCE_MAX) {
-            const BYTE* const matchPtr = dictCtx->prefixStart - dictCtx->dictLimit + l4DictMatchIndex;
-            const size_t safeLen = MIN(lDictEndIndex - l4DictMatchIndex, (size_t)(iHighLimit - ip));
-            int mlt = (int)LZ4_count(ip, matchPtr, ip + safeLen);
-            if (mlt >= MINMATCH) {
-                LZ4HC_match_t md;
-                DEBUGLOG(7, "Found short ExtDict match of len=%u", mlt);
-                md.len = mlt;
-                md.off = (int)(ipIndex - m4Index);
-                md.back = 0;
-                return md;
-            }
-        }
-    }
-
-    /* nothing found */
-    {   LZ4HC_match_t const md = {0, 0, 0 };
-        return md;
-    }
-}
-
-/**************************************
-*  Mid Compression (level 2)
-**************************************/
-
-LZ4_FORCE_INLINE void
-LZ4MID_addPosition(U32* hTable, U32 hValue, U32 index)
-{
-    hTable[hValue] = index;
-}
-
-#define ADDPOS8(_p, _idx) LZ4MID_addPosition(hash8Table, LZ4MID_hash8Ptr(_p), _idx)
-#define ADDPOS4(_p, _idx) LZ4MID_addPosition(hash4Table, LZ4MID_hash4Ptr(_p), _idx)
-
-/* Fill hash tables with references into dictionary.
- * The resulting table is only exploitable by LZ4MID (level 2) */
-static void
-LZ4MID_fillHTable (LZ4HC_CCtx_internal* cctx, const void* dict, size_t size)
-{
-    U32* const hash4Table = cctx->hashTable;
-    U32* const hash8Table = hash4Table + LZ4MID_HASHTABLESIZE;
-    const BYTE* const prefixPtr = (const BYTE*)dict;
-    U32 const prefixIdx = cctx->dictLimit;
-    U32 const target = prefixIdx + (U32)size - LZ4MID_HASHSIZE;
-    U32 idx = cctx->nextToUpdate;
-    assert(dict == cctx->prefixStart);
-    DEBUGLOG(4, "LZ4MID_fillHTable (size:%zu)", size);
-    if (size <= LZ4MID_HASHSIZE)
-        return;
-
-    for (; idx < target; idx += 3) {
-        ADDPOS4(prefixPtr+idx-prefixIdx, idx);
-        ADDPOS8(prefixPtr+idx+1-prefixIdx, idx+1);
-    }
-
-    idx = (size > 32 KB + LZ4MID_HASHSIZE) ? target - 32 KB : cctx->nextToUpdate;
-    for (; idx < target; idx += 1) {
-        ADDPOS8(prefixPtr+idx-prefixIdx, idx);
-    }
-
-    cctx->nextToUpdate = target;
-}
-
-static LZ4MID_searchIntoDict_f select_searchDict_function(const LZ4HC_CCtx_internal* dictCtx)
-{
-    if (dictCtx == NULL) return NULL;
-    if (LZ4HC_getCLevelParams(dictCtx->compressionLevel).strat == lz4mid)
-        return LZ4MID_searchExtDict;
-    return LZ4MID_searchHCDict;
-}
-
-static int LZ4MID_compress (
-    LZ4HC_CCtx_internal* const ctx,
-    const char* const src,
-    char* const dst,
-    int* srcSizePtr,
-    int const maxOutputSize,
-    const limitedOutput_directive limit,
-    const dictCtx_directive dict
-    )
-{
-    U32* const hash4Table = ctx->hashTable;
-    U32* const hash8Table = hash4Table + LZ4MID_HASHTABLESIZE;
-    const BYTE* ip = (const BYTE*)src;
-    const BYTE* anchor = ip;
-    const BYTE* const iend = ip + *srcSizePtr;
-    const BYTE* const mflimit = iend - MFLIMIT;
-    const BYTE* const matchlimit = (iend - LASTLITERALS);
-    const BYTE* const ilimit = (iend - LZ4MID_HASHSIZE);
-    BYTE* op = (BYTE*)dst;
-    BYTE* oend = op + maxOutputSize;
-
-    const BYTE* const prefixPtr = ctx->prefixStart;
-    const U32 prefixIdx = ctx->dictLimit;
-    const U32 ilimitIdx = (U32)(ilimit - prefixPtr) + prefixIdx;
-    const BYTE* const dictStart = ctx->dictStart;
-    const U32 dictIdx = ctx->lowLimit;
-    const U32 gDictEndIndex = ctx->lowLimit;
-    const LZ4MID_searchIntoDict_f searchIntoDict = (dict == usingDictCtxHc) ? select_searchDict_function(ctx->dictCtx) : NULL;
-    unsigned matchLength;
-    unsigned matchDistance;
-
-    /* input sanitization */
-    DEBUGLOG(5, "LZ4MID_compress (%i bytes)", *srcSizePtr);
-    if (dict == usingDictCtxHc) DEBUGLOG(5, "usingDictCtxHc");
-    assert(*srcSizePtr >= 0);
-    if (*srcSizePtr) assert(src != NULL);
-    if (maxOutputSize) assert(dst != NULL);
-    if (*srcSizePtr < 0) return 0;  /* invalid */
-    if (maxOutputSize < 0) return 0; /* invalid */
-    if (*srcSizePtr > LZ4_MAX_INPUT_SIZE) {
-        /* forbidden: no input is allowed to be that large */
-        return 0;
-    }
-    if (limit == fillOutput) oend -= LASTLITERALS;  /* Hack for support LZ4 format restriction */
-    if (*srcSizePtr < LZ4_minLength)
-        goto _lz4mid_last_literals;  /* Input too small, no compression (all literals) */
-
-    /* main loop */
-    while (ip <= mflimit) {
-        const U32 ipIndex = (U32)(ip - prefixPtr) + prefixIdx;
-        /* search long match */
-        {   U32 const h8 = LZ4MID_hash8Ptr(ip);
-            U32 const pos8 = hash8Table[h8];
-            assert(h8 < LZ4MID_HASHTABLESIZE);
-            assert(pos8 < ipIndex);
-            LZ4MID_addPosition(hash8Table, h8, ipIndex);
-            if (ipIndex - pos8 <= LZ4_DISTANCE_MAX) {
-                /* match candidate found */
-                if (pos8 >= prefixIdx) {
-                    const BYTE* const matchPtr = prefixPtr + pos8 - prefixIdx;
-                    assert(matchPtr < ip);
-                    matchLength = LZ4_count(ip, matchPtr, matchlimit);
-                    if (matchLength >= MINMATCH) {
-                        DEBUGLOG(7, "found long match at pos %u (len=%u)", pos8, matchLength);
-                        matchDistance = ipIndex - pos8;
-                        goto _lz4mid_encode_sequence;
-                    }
-                } else {
-                    if (pos8 >= dictIdx) {
-                        /* extDict match candidate */
-                        const BYTE* const matchPtr = dictStart + (pos8 - dictIdx);
-                        const size_t safeLen = MIN(prefixIdx - pos8, (size_t)(matchlimit - ip));
-                        matchLength = LZ4_count(ip, matchPtr, ip + safeLen);
-                        if (matchLength >= MINMATCH) {
-                            DEBUGLOG(7, "found long match at ExtDict pos %u (len=%u)", pos8, matchLength);
-                            matchDistance = ipIndex - pos8;
-                            goto _lz4mid_encode_sequence;
-                        }
-                    }
-                }
-        }   }
-        /* search short match */
-        {   U32 const h4 = LZ4MID_hash4Ptr(ip);
-            U32 const pos4 = hash4Table[h4];
-            assert(h4 < LZ4MID_HASHTABLESIZE);
-            assert(pos4 < ipIndex);
-            LZ4MID_addPosition(hash4Table, h4, ipIndex);
-            if (ipIndex - pos4 <= LZ4_DISTANCE_MAX) {
-                /* match candidate found */
-                if (pos4 >= prefixIdx) {
-                /* only search within prefix */
-                    const BYTE* const matchPtr = prefixPtr + (pos4 - prefixIdx);
-                    assert(matchPtr < ip);
-                    assert(matchPtr >= prefixPtr);
-                    matchLength = LZ4_count(ip, matchPtr, matchlimit);
-                    if (matchLength >= MINMATCH) {
-                        /* short match found, let's just check ip+1 for longer */
-                        U32 const h8 = LZ4MID_hash8Ptr(ip+1);
-                        U32 const pos8 = hash8Table[h8];
-                        U32 const m2Distance = ipIndex + 1 - pos8;
-                        matchDistance = ipIndex - pos4;
-                        if ( m2Distance <= LZ4_DISTANCE_MAX
-                        && pos8 >= prefixIdx /* only search within prefix */
-                        && likely(ip < mflimit)
-                        ) {
-                            const BYTE* const m2Ptr = prefixPtr + (pos8 - prefixIdx);
-                            unsigned ml2 = LZ4_count(ip+1, m2Ptr, matchlimit);
-                            if (ml2 > matchLength) {
-                                LZ4MID_addPosition(hash8Table, h8, ipIndex+1);
-                                ip++;
-                                matchLength = ml2;
-                                matchDistance = m2Distance;
-                        }   }
-                        goto _lz4mid_encode_sequence;
-                    }
-                } else {
-                    if (pos4 >= dictIdx) {
-                        /* extDict match candidate */
-                        const BYTE* const matchPtr = dictStart + (pos4 - dictIdx);
-                        const size_t safeLen = MIN(prefixIdx - pos4, (size_t)(matchlimit - ip));
-                        matchLength = LZ4_count(ip, matchPtr, ip + safeLen);
-                        if (matchLength >= MINMATCH) {
-                            DEBUGLOG(7, "found match at ExtDict pos %u (len=%u)", pos4, matchLength);
-                            matchDistance = ipIndex - pos4;
-                            goto _lz4mid_encode_sequence;
-                        }
-                    }
-                }
-        }   }
-        /* no match found in prefix */
-        if ( (dict == usingDictCtxHc)
-          && (ipIndex - gDictEndIndex < LZ4_DISTANCE_MAX - 8) ) {
-            /* search a match into external dictionary */
-            LZ4HC_match_t dMatch = searchIntoDict(ip, ipIndex,
-                    matchlimit,
-                    ctx->dictCtx, gDictEndIndex);
-            if (dMatch.len >= MINMATCH) {
-                DEBUGLOG(7, "found Dictionary match (offset=%i)", dMatch.off);
-                assert(dMatch.back == 0);
-                matchLength = (unsigned)dMatch.len;
-                matchDistance = (unsigned)dMatch.off;
-                goto _lz4mid_encode_sequence;
-            }
-        }
-        /* no match found */
-        ip += 1 + ((ip-anchor) >> 9);  /* skip faster over incompressible data */
-        continue;
-
-_lz4mid_encode_sequence:
-        /* catch back */
-        while (((ip > anchor) & ((U32)(ip-prefixPtr) > matchDistance)) && (unlikely(ip[-1] == ip[-(int)matchDistance-1]))) {
-            ip--;  matchLength++;
-        };
-
-        /* fill table with beginning of match */
-        ADDPOS8(ip+1, ipIndex+1);
-        ADDPOS8(ip+2, ipIndex+2);
-        ADDPOS4(ip+1, ipIndex+1);
-
-        /* encode */
-        {   BYTE* const saved_op = op;
-            /* LZ4HC_encodeSequence always updates @op; on success, it updates @ip and @anchor */
-            if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
-                    (int)matchLength, (int)matchDistance,
-                    limit, oend) ) {
-                op = saved_op;  /* restore @op value before failed LZ4HC_encodeSequence */
-                goto _lz4mid_dest_overflow;
-            }
-        }
-
-        /* fill table with end of match */
-        {   U32 endMatchIdx = (U32)(ip-prefixPtr) + prefixIdx;
-            U32 pos_m2 = endMatchIdx - 2;
-            if (pos_m2 < ilimitIdx) {
-                if (likely(ip - prefixPtr > 5)) {
-                    ADDPOS8(ip-5, endMatchIdx - 5);
-                }
-                ADDPOS8(ip-3, endMatchIdx - 3);
-                ADDPOS8(ip-2, endMatchIdx - 2);
-                ADDPOS4(ip-2, endMatchIdx - 2);
-                ADDPOS4(ip-1, endMatchIdx - 1);
-            }
-        }
-    }
-
-_lz4mid_last_literals:
-    /* Encode Last Literals */
-    {   size_t lastRunSize = (size_t)(iend - anchor);  /* literals */
-        size_t llAdd = (lastRunSize + 255 - RUN_MASK) / 255;
-        size_t const totalSize = 1 + llAdd + lastRunSize;
-        if (limit == fillOutput) oend += LASTLITERALS;  /* restore correct value */
-        if (limit && (op + totalSize > oend)) {
-            if (limit == limitedOutput) return 0;  /* not enough space in @dst */
-            /* adapt lastRunSize to fill 'dest' */
-            lastRunSize  = (size_t)(oend - op) - 1 /*token*/;
-            llAdd = (lastRunSize + 256 - RUN_MASK) / 256;
-            lastRunSize -= llAdd;
-        }
-        DEBUGLOG(6, "Final literal run : %i literals", (int)lastRunSize);
-        ip = anchor + lastRunSize;  /* can be != iend if limit==fillOutput */
-
-        if (lastRunSize >= RUN_MASK) {
-            size_t accumulator = lastRunSize - RUN_MASK;
-            *op++ = (RUN_MASK << ML_BITS);
-            for(; accumulator >= 255 ; accumulator -= 255)
-                *op++ = 255;
-            *op++ = (BYTE) accumulator;
-        } else {
-            *op++ = (BYTE)(lastRunSize << ML_BITS);
-        }
-        assert(lastRunSize <= (size_t)(oend - op));
-        LZ4_memcpy(op, anchor, lastRunSize);
-        op += lastRunSize;
-    }
-
-    /* End */
-    DEBUGLOG(5, "compressed %i bytes into %i bytes", *srcSizePtr, (int)((char*)op - dst));
-    assert(ip >= (const BYTE*)src);
-    assert(ip <= iend);
-    *srcSizePtr = (int)(ip - (const BYTE*)src);
-    assert((char*)op >= dst);
-    assert(op <= oend);
-    assert((char*)op - dst < INT_MAX);
-    return (int)((char*)op - dst);
-
-_lz4mid_dest_overflow:
-    if (limit == fillOutput) {
-        /* Assumption : @ip, @anchor, @optr and @matchLength must be set correctly */
-        size_t const ll = (size_t)(ip - anchor);
-        size_t const ll_addbytes = (ll + 240) / 255;
-        size_t const ll_totalCost = 1 + ll_addbytes + ll;
-        BYTE* const maxLitPos = oend - 3; /* 2 for offset, 1 for token */
-        DEBUGLOG(6, "Last sequence is overflowing : %u literals, %u remaining space",
-                (unsigned)ll, (unsigned)(oend-op));
-        if (op + ll_totalCost <= maxLitPos) {
-            /* ll validated; now adjust match length */
-            size_t const bytesLeftForMl = (size_t)(maxLitPos - (op+ll_totalCost));
-            size_t const maxMlSize = MINMATCH + (ML_MASK-1) + (bytesLeftForMl * 255);
-            assert(maxMlSize < INT_MAX);
-            if ((size_t)matchLength > maxMlSize) matchLength= (unsigned)maxMlSize;
-            if ((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1 + matchLength >= MFLIMIT) {
-            DEBUGLOG(6, "Let's encode a last sequence (ll=%u, ml=%u)", (unsigned)ll, matchLength);
-                LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
-                        (int)matchLength, (int)matchDistance,
-                        notLimited, oend);
-        }   }
-        DEBUGLOG(6, "Let's finish with a run of literals (%u bytes left)", (unsigned)(oend-op));
-        goto _lz4mid_last_literals;
-    }
-    /* compression failed */
-    return 0;
-}
-
-
-/**************************************
-*  HC Compression - Search
-**************************************/
-
-/* Update chains up to ip (excluded) */
-LZ4_FORCE_INLINE void LZ4HC_Insert (LZ4HC_CCtx_internal* hc4, const BYTE* ip)
-{
-    U16* const chainTable = hc4->chainTable;
-    U32* const hashTable  = hc4->hashTable;
-    const BYTE* const prefixPtr = hc4->prefixStart;
-    U32 const prefixIdx = hc4->dictLimit;
-    U32 const target = (U32)(ip - prefixPtr) + prefixIdx;
-    U32 idx = hc4->nextToUpdate;
-    assert(ip >= prefixPtr);
-    assert(target >= prefixIdx);
-
-    while (idx < target) {
-        U32 const h = LZ4HC_hashPtr(prefixPtr+idx-prefixIdx);
-        size_t delta = idx - hashTable[h];
-        if (delta>LZ4_DISTANCE_MAX) delta = LZ4_DISTANCE_MAX;
-        DELTANEXTU16(chainTable, idx) = (U16)delta;
-        hashTable[h] = idx;
-        idx++;
-    }
-
-    hc4->nextToUpdate = target;
-}
-
-#if defined(_MSC_VER)
-#  define LZ4HC_rotl32(x,r) _rotl(x,r)
-#else
-#  define LZ4HC_rotl32(x,r) ((x << r) | (x >> (32 - r)))
-#endif
-
-
-static U32 LZ4HC_rotatePattern(size_t const rotate, U32 const pattern)
-{
-    size_t const bitsToRotate = (rotate & (sizeof(pattern) - 1)) << 3;
-    if (bitsToRotate == 0) return pattern;
-    return LZ4HC_rotl32(pattern, (int)bitsToRotate);
-}
-
-/* LZ4HC_countPattern() :
- * pattern32 must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!) */
-static unsigned
-LZ4HC_countPattern(const BYTE* ip, const BYTE* const iEnd, U32 const pattern32)
-{
-    const BYTE* const iStart = ip;
-    reg_t const pattern = (sizeof(pattern)==8) ?
-        (reg_t)pattern32 + (((reg_t)pattern32) << (sizeof(pattern)*4)) : pattern32;
-
-    while (likely(ip < iEnd-(sizeof(pattern)-1))) {
-        reg_t const diff = LZ4_read_ARCH(ip) ^ pattern;
-        if (!diff) { ip+=sizeof(pattern); continue; }
-        ip += LZ4_NbCommonBytes(diff);
-        return (unsigned)(ip - iStart);
-    }
-
-    if (LZ4_isLittleEndian()) {
-        reg_t patternByte = pattern;
-        while ((ip<iEnd) && (*ip == (BYTE)patternByte)) {
-            ip++; patternByte >>= 8;
-        }
-    } else {  /* big endian */
-        U32 bitOffset = (sizeof(pattern)*8) - 8;
-        while (ip < iEnd) {
-            BYTE const byte = (BYTE)(pattern >> bitOffset);
-            if (*ip != byte) break;
-            ip ++; bitOffset -= 8;
-    }   }
-
-    return (unsigned)(ip - iStart);
-}
-
-/* LZ4HC_reverseCountPattern() :
- * pattern must be a sample of repetitive pattern of length 1, 2 or 4 (but not 3!)
- * read using natural platform endianness */
-static unsigned
-LZ4HC_reverseCountPattern(const BYTE* ip, const BYTE* const iLow, U32 pattern)
-{
-    const BYTE* const iStart = ip;
-
-    while (likely(ip >= iLow+4)) {
-        if (LZ4_read32(ip-4) != pattern) break;
-        ip -= 4;
-    }
-    {   const BYTE* bytePtr = (const BYTE*)(&pattern) + 3; /* works for any endianness */
-        while (likely(ip>iLow)) {
-            if (ip[-1] != *bytePtr) break;
-            ip--; bytePtr--;
-    }   }
-    return (unsigned)(iStart - ip);
-}
-
-/* LZ4HC_protectDictEnd() :
- * Checks if the match is in the last 3 bytes of the dictionary, so reading the
- * 4 byte MINMATCH would overflow.
- * @returns true if the match index is okay.
- */
-static int LZ4HC_protectDictEnd(U32 const dictLimit, U32 const matchIndex)
-{
-    return ((U32)((dictLimit - 1) - matchIndex) >= 3);
-}
-
-typedef enum { rep_untested, rep_not, rep_confirmed } repeat_state_e;
-typedef enum { favorCompressionRatio=0, favorDecompressionSpeed } HCfavor_e;
-
-
-LZ4_FORCE_INLINE LZ4HC_match_t
-LZ4HC_InsertAndGetWiderMatch (
-        LZ4HC_CCtx_internal* const hc4,
-        const BYTE* const ip,
-        const BYTE* const iLowLimit, const BYTE* const iHighLimit,
-        int longest,
-        const int maxNbAttempts,
-        const int patternAnalysis, const int chainSwap,
-        const dictCtx_directive dict,
-        const HCfavor_e favorDecSpeed)
-{
-    U16* const chainTable = hc4->chainTable;
-    U32* const hashTable = hc4->hashTable;
-    const LZ4HC_CCtx_internal* const dictCtx = hc4->dictCtx;
-    const BYTE* const prefixPtr = hc4->prefixStart;
-    const U32 prefixIdx = hc4->dictLimit;
-    const U32 ipIndex = (U32)(ip - prefixPtr) + prefixIdx;
-    const int withinStartDistance = (hc4->lowLimit + (LZ4_DISTANCE_MAX + 1) > ipIndex);
-    const U32 lowestMatchIndex = (withinStartDistance) ? hc4->lowLimit : ipIndex - LZ4_DISTANCE_MAX;
-    const BYTE* const dictStart = hc4->dictStart;
-    const U32 dictIdx = hc4->lowLimit;
-    const BYTE* const dictEnd = dictStart + prefixIdx - dictIdx;
-    int const lookBackLength = (int)(ip-iLowLimit);
-    int nbAttempts = maxNbAttempts;
-    U32 matchChainPos = 0;
-    U32 const pattern = LZ4_read32(ip);
-    U32 matchIndex;
-    repeat_state_e repeat = rep_untested;
-    size_t srcPatternLength = 0;
-    int offset = 0, sBack = 0;
-
-    DEBUGLOG(7, "LZ4HC_InsertAndGetWiderMatch");
-    /* First Match */
-    LZ4HC_Insert(hc4, ip);  /* insert all prior positions up to ip (excluded) */
-    matchIndex = hashTable[LZ4HC_hashPtr(ip)];
-    DEBUGLOG(7, "First candidate match for pos %u found at index %u / %u (lowestMatchIndex)",
-                ipIndex, matchIndex, lowestMatchIndex);
-
-    while ((matchIndex>=lowestMatchIndex) && (nbAttempts>0)) {
-        int matchLength=0;
-        nbAttempts--;
-        assert(matchIndex < ipIndex);
-        if (favorDecSpeed && (ipIndex - matchIndex < 8)) {
-            /* do nothing:
-             * favorDecSpeed intentionally skips matches with offset < 8 */
-        } else if (matchIndex >= prefixIdx) {   /* within current Prefix */
-            const BYTE* const matchPtr = prefixPtr + (matchIndex - prefixIdx);
-            assert(matchPtr < ip);
-            assert(longest >= 1);
-            if (LZ4_read16(iLowLimit + longest - 1) == LZ4_read16(matchPtr - lookBackLength + longest - 1)) {
-                if (LZ4_read32(matchPtr) == pattern) {
-                    int const back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, prefixPtr) : 0;
-                    matchLength = MINMATCH + (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, iHighLimit);
-                    matchLength -= back;
-                    if (matchLength > longest) {
-                        longest = matchLength;
-                        offset = (int)(ipIndex - matchIndex);
-                        sBack = back;
-                        DEBUGLOG(7, "Found match of len=%i within prefix, offset=%i, back=%i", longest, offset, -back);
-            }   }   }
-        } else {   /* lowestMatchIndex <= matchIndex < dictLimit : within Ext Dict */
-            const BYTE* const matchPtr = dictStart + (matchIndex - dictIdx);
-            assert(matchIndex >= dictIdx);
-            if ( likely(matchIndex <= prefixIdx - 4)
-              && (LZ4_read32(matchPtr) == pattern) ) {
-                int back = 0;
-                const BYTE* vLimit = ip + (prefixIdx - matchIndex);
-                if (vLimit > iHighLimit) vLimit = iHighLimit;
-                matchLength = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH;
-                if ((ip+matchLength == vLimit) && (vLimit < iHighLimit))
-                    matchLength += LZ4_count(ip+matchLength, prefixPtr, iHighLimit);
-                back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictStart) : 0;
-                matchLength -= back;
-                if (matchLength > longest) {
-                    longest = matchLength;
-                    offset = (int)(ipIndex - matchIndex);
-                    sBack = back;
-                    DEBUGLOG(7, "Found match of len=%i within dict, offset=%i, back=%i", longest, offset, -back);
-        }   }   }
-
-        if (chainSwap && matchLength==longest) {   /* better match => select a better chain */
-            assert(lookBackLength==0);   /* search forward only */
-            if (matchIndex + (U32)longest <= ipIndex) {
-                int const kTrigger = 4;
-                U32 distanceToNextMatch = 1;
-                int const end = longest - MINMATCH + 1;
-                int step = 1;
-                int accel = 1 << kTrigger;
-                int pos;
-                for (pos = 0; pos < end; pos += step) {
-                    U32 const candidateDist = DELTANEXTU16(chainTable, matchIndex + (U32)pos);
-                    step = (accel++ >> kTrigger);
-                    if (candidateDist > distanceToNextMatch) {
-                        distanceToNextMatch = candidateDist;
-                        matchChainPos = (U32)pos;
-                        accel = 1 << kTrigger;
-                }   }
-                if (distanceToNextMatch > 1) {
-                    if (distanceToNextMatch > matchIndex) break;   /* avoid overflow */
-                    matchIndex -= distanceToNextMatch;
-                    continue;
-        }   }   }
-
-        {   U32 const distNextMatch = DELTANEXTU16(chainTable, matchIndex);
-            if (patternAnalysis && distNextMatch==1 && matchChainPos==0) {
-                U32 const matchCandidateIdx = matchIndex-1;
-                /* may be a repeated pattern */
-                if (repeat == rep_untested) {
-                    if ( ((pattern & 0xFFFF) == (pattern >> 16))
-                      &  ((pattern & 0xFF)   == (pattern >> 24)) ) {
-                        DEBUGLOG(7, "Repeat pattern detected, char %02X", pattern >> 24);
-                        repeat = rep_confirmed;
-                        srcPatternLength = LZ4HC_countPattern(ip+sizeof(pattern), iHighLimit, pattern) + sizeof(pattern);
-                    } else {
-                        repeat = rep_not;
-                }   }
-                if ( (repeat == rep_confirmed) && (matchCandidateIdx >= lowestMatchIndex)
-                  && LZ4HC_protectDictEnd(prefixIdx, matchCandidateIdx) ) {
-                    const int extDict = matchCandidateIdx < prefixIdx;
-                    const BYTE* const matchPtr = extDict ? dictStart + (matchCandidateIdx - dictIdx) : prefixPtr + (matchCandidateIdx - prefixIdx);
-                    if (LZ4_read32(matchPtr) == pattern) {  /* good candidate */
-                        const BYTE* const iLimit = extDict ? dictEnd : iHighLimit;
-                        size_t forwardPatternLength = LZ4HC_countPattern(matchPtr+sizeof(pattern), iLimit, pattern) + sizeof(pattern);
-                        if (extDict && matchPtr + forwardPatternLength == iLimit) {
-                            U32 const rotatedPattern = LZ4HC_rotatePattern(forwardPatternLength, pattern);
-                            forwardPatternLength += LZ4HC_countPattern(prefixPtr, iHighLimit, rotatedPattern);
-                        }
-                        {   const BYTE* const lowestMatchPtr = extDict ? dictStart : prefixPtr;
-                            size_t backLength = LZ4HC_reverseCountPattern(matchPtr, lowestMatchPtr, pattern);
-                            size_t currentSegmentLength;
-                            if (!extDict
-                              && matchPtr - backLength == prefixPtr
-                              && dictIdx < prefixIdx) {
-                                U32 const rotatedPattern = LZ4HC_rotatePattern((U32)(-(int)backLength), pattern);
-                                backLength += LZ4HC_reverseCountPattern(dictEnd, dictStart, rotatedPattern);
-                            }
-                            /* Limit backLength not go further than lowestMatchIndex */
-                            backLength = matchCandidateIdx - MAX(matchCandidateIdx - (U32)backLength, lowestMatchIndex);
-                            assert(matchCandidateIdx - backLength >= lowestMatchIndex);
-                            currentSegmentLength = backLength + forwardPatternLength;
-                            /* Adjust to end of pattern if the source pattern fits, otherwise the beginning of the pattern */
-                            if ( (currentSegmentLength >= srcPatternLength)   /* current pattern segment large enough to contain full srcPatternLength */
-                              && (forwardPatternLength <= srcPatternLength) ) { /* haven't reached this position yet */
-                                U32 const newMatchIndex = matchCandidateIdx + (U32)forwardPatternLength - (U32)srcPatternLength;  /* best position, full pattern, might be followed by more match */
-                                if (LZ4HC_protectDictEnd(prefixIdx, newMatchIndex))
-                                    matchIndex = newMatchIndex;
-                                else {
-                                    /* Can only happen if started in the prefix */
-                                    assert(newMatchIndex >= prefixIdx - 3 && newMatchIndex < prefixIdx && !extDict);
-                                    matchIndex = prefixIdx;
-                                }
-                            } else {
-                                U32 const newMatchIndex = matchCandidateIdx - (U32)backLength;   /* farthest position in current segment, will find a match of length currentSegmentLength + maybe some back */
-                                if (!LZ4HC_protectDictEnd(prefixIdx, newMatchIndex)) {
-                                    assert(newMatchIndex >= prefixIdx - 3 && newMatchIndex < prefixIdx && !extDict);
-                                    matchIndex = prefixIdx;
-                                } else {
-                                    matchIndex = newMatchIndex;
-                                    if (lookBackLength==0) {  /* no back possible */
-                                        size_t const maxML = MIN(currentSegmentLength, srcPatternLength);
-                                        if ((size_t)longest < maxML) {
-                                            assert(prefixPtr - prefixIdx + matchIndex != ip);
-                                            if ((size_t)(ip - prefixPtr) + prefixIdx - matchIndex > LZ4_DISTANCE_MAX) break;
-                                            assert(maxML < 2 GB);
-                                            longest = (int)maxML;
-                                            offset = (int)(ipIndex - matchIndex);
-                                            assert(sBack == 0);
-                                            DEBUGLOG(7, "Found repeat pattern match of len=%i, offset=%i", longest, offset);
-                                        }
-                                        {   U32 const distToNextPattern = DELTANEXTU16(chainTable, matchIndex);
-                                            if (distToNextPattern > matchIndex) break;  /* avoid overflow */
-                                            matchIndex -= distToNextPattern;
-                        }   }   }   }   }
-                        continue;
-                }   }
-        }   }   /* PA optimization */
-
-        /* follow current chain */
-        matchIndex -= DELTANEXTU16(chainTable, matchIndex + matchChainPos);
-
-    }  /* while ((matchIndex>=lowestMatchIndex) && (nbAttempts)) */
-
-    if ( dict == usingDictCtxHc
-      && nbAttempts > 0
-      && withinStartDistance) {
-        size_t const dictEndOffset = (size_t)(dictCtx->end - dictCtx->prefixStart) + dictCtx->dictLimit;
-        U32 dictMatchIndex = dictCtx->hashTable[LZ4HC_hashPtr(ip)];
-        assert(dictEndOffset <= 1 GB);
-        matchIndex = dictMatchIndex + lowestMatchIndex - (U32)dictEndOffset;
-        if (dictMatchIndex>0) DEBUGLOG(7, "dictEndOffset = %zu, dictMatchIndex = %u => relative matchIndex = %i", dictEndOffset, dictMatchIndex, (int)dictMatchIndex - (int)dictEndOffset);
-        while (ipIndex - matchIndex <= LZ4_DISTANCE_MAX && nbAttempts--) {
-            const BYTE* const matchPtr = dictCtx->prefixStart - dictCtx->dictLimit + dictMatchIndex;
-
-            if (LZ4_read32(matchPtr) == pattern) {
-                int mlt;
-                int back = 0;
-                const BYTE* vLimit = ip + (dictEndOffset - dictMatchIndex);
-                if (vLimit > iHighLimit) vLimit = iHighLimit;
-                mlt = (int)LZ4_count(ip+MINMATCH, matchPtr+MINMATCH, vLimit) + MINMATCH;
-                back = lookBackLength ? LZ4HC_countBack(ip, matchPtr, iLowLimit, dictCtx->prefixStart) : 0;
-                mlt -= back;
-                if (mlt > longest) {
-                    longest = mlt;
-                    offset = (int)(ipIndex - matchIndex);
-                    sBack = back;
-                    DEBUGLOG(7, "found match of length %i within extDictCtx", longest);
-            }   }
-
-            {   U32 const nextOffset = DELTANEXTU16(dictCtx->chainTable, dictMatchIndex);
-                dictMatchIndex -= nextOffset;
-                matchIndex -= nextOffset;
-    }   }   }
-
-    {   LZ4HC_match_t md;
-        assert(longest >= 0);
-        md.len = longest;
-        md.off = offset;
-        md.back = sBack;
-        return md;
-    }
-}
-
-LZ4_FORCE_INLINE LZ4HC_match_t
-LZ4HC_InsertAndFindBestMatch(LZ4HC_CCtx_internal* const hc4,   /* Index table will be updated */
-                       const BYTE* const ip, const BYTE* const iLimit,
-                       const int maxNbAttempts,
-                       const int patternAnalysis,
-                       const dictCtx_directive dict)
-{
-    DEBUGLOG(7, "LZ4HC_InsertAndFindBestMatch");
-    /* note : LZ4HC_InsertAndGetWiderMatch() is able to modify the starting position of a match (*startpos),
-     * but this won't be the case here, as we define iLowLimit==ip,
-     * so LZ4HC_InsertAndGetWiderMatch() won't be allowed to search past ip */
-    return LZ4HC_InsertAndGetWiderMatch(hc4, ip, ip, iLimit, MINMATCH-1, maxNbAttempts, patternAnalysis, 0 /*chainSwap*/, dict, favorCompressionRatio);
-}
-
-
-LZ4_FORCE_INLINE int LZ4HC_compress_hashChain (
-    LZ4HC_CCtx_internal* const ctx,
-    const char* const source,
-    char* const dest,
-    int* srcSizePtr,
-    int const maxOutputSize,
-    int maxNbAttempts,
-    const limitedOutput_directive limit,
-    const dictCtx_directive dict
-    )
-{
-    const int inputSize = *srcSizePtr;
-    const int patternAnalysis = (maxNbAttempts > 128);   /* levels 9+ */
-
-    const BYTE* ip = (const BYTE*) source;
-    const BYTE* anchor = ip;
-    const BYTE* const iend = ip + inputSize;
-    const BYTE* const mflimit = iend - MFLIMIT;
-    const BYTE* const matchlimit = (iend - LASTLITERALS);
-
-    BYTE* optr = (BYTE*) dest;
-    BYTE* op = (BYTE*) dest;
-    BYTE* oend = op + maxOutputSize;
-
-    const BYTE* start0;
-    const BYTE* start2 = NULL;
-    const BYTE* start3 = NULL;
-    LZ4HC_match_t m0, m1, m2, m3;
-    const LZ4HC_match_t nomatch = {0, 0, 0};
-
-    /* init */
-    DEBUGLOG(5, "LZ4HC_compress_hashChain (dict?=>%i)", dict);
-    *srcSizePtr = 0;
-    if (limit == fillOutput) oend -= LASTLITERALS;                  /* Hack for support LZ4 format restriction */
-    if (inputSize < LZ4_minLength) goto _last_literals;             /* Input too small, no compression (all literals) */
-
-    /* Main Loop */
-    while (ip <= mflimit) {
-        m1 = LZ4HC_InsertAndFindBestMatch(ctx, ip, matchlimit, maxNbAttempts, patternAnalysis, dict);
-        if (m1.len<MINMATCH) { ip++; continue; }
-
-        /* saved, in case we would skip too much */
-        start0 = ip; m0 = m1;
-
-_Search2:
-        DEBUGLOG(7, "_Search2 (currently found match of size %i)", m1.len);
-        if (ip+m1.len <= mflimit) {
-            start2 = ip + m1.len - 2;
-            m2 = LZ4HC_InsertAndGetWiderMatch(ctx,
-                            start2, ip + 0, matchlimit, m1.len,
-                            maxNbAttempts, patternAnalysis, 0, dict, favorCompressionRatio);
-            start2 += m2.back;
-        } else {
-            m2 = nomatch;  /* do not search further */
-        }
-
-        if (m2.len <= m1.len) { /* No better match => encode ML1 immediately */
-            optr = op;
-            if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
-                    m1.len, m1.off,
-                    limit, oend) )
-                goto _dest_overflow;
-            continue;
-        }
-
-        if (start0 < ip) {   /* first match was skipped at least once */
-            if (start2 < ip + m0.len) {  /* squeezing ML1 between ML0(original ML1) and ML2 */
-                ip = start0; m1 = m0;  /* restore initial Match1 */
-        }   }
-
-        /* Here, start0==ip */
-        if ((start2 - ip) < 3) {  /* First Match too small : removed */
-            ip = start2;
-            m1 = m2;
-            goto _Search2;
-        }
-
-_Search3:
-        if ((start2 - ip) < OPTIMAL_ML) {
-            int correction;
-            int new_ml = m1.len;
-            if (new_ml > OPTIMAL_ML) new_ml = OPTIMAL_ML;
-            if (ip+new_ml > start2 + m2.len - MINMATCH)
-                new_ml = (int)(start2 - ip) + m2.len - MINMATCH;
-            correction = new_ml - (int)(start2 - ip);
-            if (correction > 0) {
-                start2 += correction;
-                m2.len -= correction;
-            }
-        }
-
-        if (start2 + m2.len <= mflimit) {
-            start3 = start2 + m2.len - 3;
-            m3 = LZ4HC_InsertAndGetWiderMatch(ctx,
-                            start3, start2, matchlimit, m2.len,
-                            maxNbAttempts, patternAnalysis, 0, dict, favorCompressionRatio);
-            start3 += m3.back;
-        } else {
-            m3 = nomatch;  /* do not search further */
-        }
-
-        if (m3.len <= m2.len) {  /* No better match => encode ML1 and ML2 */
-            /* ip & ref are known; Now for ml */
-            if (start2 < ip+m1.len) m1.len = (int)(start2 - ip);
-            /* Now, encode 2 sequences */
-            optr = op;
-            if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
-                    m1.len, m1.off,
-                    limit, oend) )
-                goto _dest_overflow;
-            ip = start2;
-            optr = op;
-            if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
-                    m2.len, m2.off,
-                    limit, oend) ) {
-                m1 = m2;
-                goto _dest_overflow;
-            }
-            continue;
-        }
-
-        if (start3 < ip+m1.len+3) {  /* Not enough space for match 2 : remove it */
-            if (start3 >= (ip+m1.len)) {  /* can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 */
-                if (start2 < ip+m1.len) {
-                    int correction = (int)(ip+m1.len - start2);
-                    start2 += correction;
-                    m2.len -= correction;
-                    if (m2.len < MINMATCH) {
-                        start2 = start3;
-                        m2 = m3;
-                    }
-                }
-
-                optr = op;
-                if (LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
-                        m1.len, m1.off,
-                        limit, oend) )
-                    goto _dest_overflow;
-                ip  = start3;
-                m1 = m3;
-
-                start0 = start2;
-                m0 = m2;
-                goto _Search2;
-            }
-
-            start2 = start3;
-            m2 = m3;
-            goto _Search3;
-        }
-
-        /*
-        * OK, now we have 3 ascending matches;
-        * let's write the first one ML1.
-        * ip & ref are known; Now decide ml.
-        */
-        if (start2 < ip+m1.len) {
-            if ((start2 - ip) < OPTIMAL_ML) {
-                int correction;
-                if (m1.len > OPTIMAL_ML) m1.len = OPTIMAL_ML;
-                if (ip + m1.len > start2 + m2.len - MINMATCH)
-                    m1.len = (int)(start2 - ip) + m2.len - MINMATCH;
-                correction = m1.len - (int)(start2 - ip);
-                if (correction > 0) {
-                    start2 += correction;
-                    m2.len -= correction;
-                }
-            } else {
-                m1.len = (int)(start2 - ip);
-            }
-        }
-        optr = op;
-        if ( LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor),
-                m1.len, m1.off,
-                limit, oend) )
-            goto _dest_overflow;
-
-        /* ML2 becomes ML1 */
-        ip = start2; m1 = m2;
-
-        /* ML3 becomes ML2 */
-        start2 = start3; m2 = m3;
-
-        /* let's find a new ML3 */
-        goto _Search3;
-    }
-
-_last_literals:
-    /* Encode Last Literals */
-    {   size_t lastRunSize = (size_t)(iend - anchor);  /* literals */
-        size_t llAdd = (lastRunSize + 255 - RUN_MASK) / 255;
-        size_t const totalSize = 1 + llAdd + lastRunSize;
-        if (limit == fillOutput) oend += LASTLITERALS;  /* restore correct value */
-        if (limit && (op + totalSize > oend)) {
-            if (limit == limitedOutput) return 0;
-            /* adapt lastRunSize to fill 'dest' */
-            lastRunSize  = (size_t)(oend - op) - 1 /*token*/;
-            llAdd = (lastRunSize + 256 - RUN_MASK) / 256;
-            lastRunSize -= llAdd;
-        }
-        DEBUGLOG(6, "Final literal run : %i literals", (int)lastRunSize);
-        ip = anchor + lastRunSize;  /* can be != iend if limit==fillOutput */
-
-        if (lastRunSize >= RUN_MASK) {
-            size_t accumulator = lastRunSize - RUN_MASK;
-            *op++ = (RUN_MASK << ML_BITS);
-            for(; accumulator >= 255 ; accumulator -= 255) *op++ = 255;
-            *op++ = (BYTE) accumulator;
-        } else {
-            *op++ = (BYTE)(lastRunSize << ML_BITS);
-        }
-        LZ4_memcpy(op, anchor, lastRunSize);
-        op += lastRunSize;
-    }
-
-    /* End */
-    *srcSizePtr = (int) (((const char*)ip) - source);
-    return (int) (((char*)op)-dest);
-
-_dest_overflow:
-    if (limit == fillOutput) {
-        /* Assumption : @ip, @anchor, @optr and @m1 must be set correctly */
-        size_t const ll = (size_t)(ip - anchor);
-        size_t const ll_addbytes = (ll + 240) / 255;
-        size_t const ll_totalCost = 1 + ll_addbytes + ll;
-        BYTE* const maxLitPos = oend - 3; /* 2 for offset, 1 for token */
-        DEBUGLOG(6, "Last sequence overflowing");
-        op = optr;  /* restore correct out pointer */
-        if (op + ll_totalCost <= maxLitPos) {
-            /* ll validated; now adjust match length */
-            size_t const bytesLeftForMl = (size_t)(maxLitPos - (op+ll_totalCost));
-            size_t const maxMlSize = MINMATCH + (ML_MASK-1) + (bytesLeftForMl * 255);
-            assert(maxMlSize < INT_MAX); assert(m1.len >= 0);
-            if ((size_t)m1.len > maxMlSize) m1.len = (int)maxMlSize;
-            if ((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1 + m1.len >= MFLIMIT) {
-                LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), m1.len, m1.off, notLimited, oend);
-        }   }
-        goto _last_literals;
-    }
-    /* compression failed */
-    return 0;
-}
-
-
-static int LZ4HC_compress_optimal( LZ4HC_CCtx_internal* ctx,
-    const char* const source, char* dst,
-    int* srcSizePtr, int dstCapacity,
-    int const nbSearches, size_t sufficient_len,
-    const limitedOutput_directive limit, int const fullUpdate,
-    const dictCtx_directive dict,
-    const HCfavor_e favorDecSpeed);
-
-LZ4_FORCE_INLINE int
-LZ4HC_compress_generic_internal (
-            LZ4HC_CCtx_internal* const ctx,
-            const char* const src,
-            char* const dst,
-            int* const srcSizePtr,
-            int const dstCapacity,
-            int cLevel,
-            const limitedOutput_directive limit,
-            const dictCtx_directive dict
-            )
-{
-    DEBUGLOG(5, "LZ4HC_compress_generic_internal(src=%p, srcSize=%d)",
-                src, *srcSizePtr);
-
-    if (limit == fillOutput && dstCapacity < 1) return 0;   /* Impossible to store anything */
-    if ((U32)*srcSizePtr > (U32)LZ4_MAX_INPUT_SIZE) return 0;  /* Unsupported input size (too large or negative) */
-
-    ctx->end += *srcSizePtr;
-    {   cParams_t const cParam = LZ4HC_getCLevelParams(cLevel);
-        HCfavor_e const favor = ctx->favorDecSpeed ? favorDecompressionSpeed : favorCompressionRatio;
-        int result;
-
-        if (cParam.strat == lz4mid) {
-            result = LZ4MID_compress(ctx,
-                                src, dst, srcSizePtr, dstCapacity,
-                                limit, dict);
-        } else if (cParam.strat == lz4hc) {
-            result = LZ4HC_compress_hashChain(ctx,
-                                src, dst, srcSizePtr, dstCapacity,
-                                cParam.nbSearches, limit, dict);
-        } else {
-            assert(cParam.strat == lz4opt);
-            result = LZ4HC_compress_optimal(ctx,
-                                src, dst, srcSizePtr, dstCapacity,
-                                cParam.nbSearches, cParam.targetLength, limit,
-                                cLevel >= LZ4HC_CLEVEL_MAX,   /* ultra mode */
-                                dict, favor);
-        }
-        if (result <= 0) ctx->dirty = 1;
-        return result;
-    }
-}
-
-static void LZ4HC_setExternalDict(LZ4HC_CCtx_internal* ctxPtr, const BYTE* newBlock);
-
-static int
-LZ4HC_compress_generic_noDictCtx (
-        LZ4HC_CCtx_internal* const ctx,
-        const char* const src,
-        char* const dst,
-        int* const srcSizePtr,
-        int const dstCapacity,
-        int cLevel,
-        limitedOutput_directive limit
-        )
-{
-    assert(ctx->dictCtx == NULL);
-    return LZ4HC_compress_generic_internal(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit, noDictCtx);
-}
-
-static int isStateCompatible(const LZ4HC_CCtx_internal* ctx1, const LZ4HC_CCtx_internal* ctx2)
-{
-    int const isMid1 = LZ4HC_getCLevelParams(ctx1->compressionLevel).strat == lz4mid;
-    int const isMid2 = LZ4HC_getCLevelParams(ctx2->compressionLevel).strat == lz4mid;
-    return !(isMid1 ^ isMid2);
-}
-
-static int
-LZ4HC_compress_generic_dictCtx (
-        LZ4HC_CCtx_internal* const ctx,
-        const char* const src,
-        char* const dst,
-        int* const srcSizePtr,
-        int const dstCapacity,
-        int cLevel,
-        limitedOutput_directive limit
-        )
-{
-    const size_t position = (size_t)(ctx->end - ctx->prefixStart) + (ctx->dictLimit - ctx->lowLimit);
-    assert(ctx->dictCtx != NULL);
-    if (position >= 64 KB) {
-        ctx->dictCtx = NULL;
-        return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);
-    } else if (position == 0 && *srcSizePtr > 4 KB && isStateCompatible(ctx, ctx->dictCtx)) {
-        LZ4_memcpy(ctx, ctx->dictCtx, sizeof(LZ4HC_CCtx_internal));
-        LZ4HC_setExternalDict(ctx, (const BYTE *)src);
-        ctx->compressionLevel = (short)cLevel;
-        return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);
-    } else {
-        return LZ4HC_compress_generic_internal(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit, usingDictCtxHc);
-    }
-}
-
-static int
-LZ4HC_compress_generic (
-        LZ4HC_CCtx_internal* const ctx,
-        const char* const src,
-        char* const dst,
-        int* const srcSizePtr,
-        int const dstCapacity,
-        int cLevel,
-        limitedOutput_directive limit
-        )
-{
-    if (ctx->dictCtx == NULL) {
-        return LZ4HC_compress_generic_noDictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);
-    } else {
-        return LZ4HC_compress_generic_dictCtx(ctx, src, dst, srcSizePtr, dstCapacity, cLevel, limit);
-    }
-}
-
-
-int LZ4_sizeofStateHC(void) { return (int)sizeof(LZ4_streamHC_t); }
-
-static size_t LZ4_streamHC_t_alignment(void)
-{
-#if LZ4_ALIGN_TEST
-    typedef struct { char c; LZ4_streamHC_t t; } t_a;
-    return sizeof(t_a) - sizeof(LZ4_streamHC_t);
-#else
-    return 1;  /* effectively disabled */
-#endif
-}
-
-/* state is presumed correctly initialized,
- * in which case its size and alignment have already been validate */
-int LZ4_compress_HC_extStateHC_fastReset (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
-{
-    LZ4HC_CCtx_internal* const ctx = &((LZ4_streamHC_t*)state)->internal_donotuse;
-    if (!LZ4_isAligned(state, LZ4_streamHC_t_alignment())) return 0;
-    LZ4_resetStreamHC_fast((LZ4_streamHC_t*)state, compressionLevel);
-    LZ4HC_init_internal (ctx, (const BYTE*)src);
-    if (dstCapacity < LZ4_compressBound(srcSize))
-        return LZ4HC_compress_generic (ctx, src, dst, &srcSize, dstCapacity, compressionLevel, limitedOutput);
-    else
-        return LZ4HC_compress_generic (ctx, src, dst, &srcSize, dstCapacity, compressionLevel, notLimited);
-}
-
-int LZ4_compress_HC_extStateHC (void* state, const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
-{
-    LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx));
-    if (ctx==NULL) return 0;   /* init failure */
-    return LZ4_compress_HC_extStateHC_fastReset(state, src, dst, srcSize, dstCapacity, compressionLevel);
-}
-
-int LZ4_compress_HC(const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel)
-{
-    int cSize;
-#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
-    LZ4_streamHC_t* const statePtr = (LZ4_streamHC_t*)ALLOC(sizeof(LZ4_streamHC_t));
-    if (statePtr==NULL) return 0;
-#else
-    LZ4_streamHC_t state;
-    LZ4_streamHC_t* const statePtr = &state;
-#endif
-    DEBUGLOG(5, "LZ4_compress_HC")
-    cSize = LZ4_compress_HC_extStateHC(statePtr, src, dst, srcSize, dstCapacity, compressionLevel);
-#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
-    FREEMEM(statePtr);
-#endif
-    return cSize;
-}
-
-/* state is presumed sized correctly (>= sizeof(LZ4_streamHC_t)) */
-int LZ4_compress_HC_destSize(void* state, const char* source, char* dest, int* sourceSizePtr, int targetDestSize, int cLevel)
-{
-    LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx));
-    if (ctx==NULL) return 0;   /* init failure */
-    LZ4HC_init_internal(&ctx->internal_donotuse, (const BYTE*) source);
-    LZ4_setCompressionLevel(ctx, cLevel);
-    return LZ4HC_compress_generic(&ctx->internal_donotuse, source, dest, sourceSizePtr, targetDestSize, cLevel, fillOutput);
-}
-
-
-
-/**************************************
-*  Streaming Functions
-**************************************/
-/* allocation */
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-LZ4_streamHC_t* LZ4_createStreamHC(void)
-{
-    LZ4_streamHC_t* const state =
-        (LZ4_streamHC_t*)ALLOC_AND_ZERO(sizeof(LZ4_streamHC_t));
-    if (state == NULL) return NULL;
-    LZ4_setCompressionLevel(state, LZ4HC_CLEVEL_DEFAULT);
-    return state;
-}
-
-int LZ4_freeStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr)
-{
-    DEBUGLOG(4, "LZ4_freeStreamHC(%p)", LZ4_streamHCPtr);
-    if (!LZ4_streamHCPtr) return 0;  /* support free on NULL */
-    FREEMEM(LZ4_streamHCPtr);
-    return 0;
-}
-#endif
-
-
-LZ4_streamHC_t* LZ4_initStreamHC (void* buffer, size_t size)
-{
-    LZ4_streamHC_t* const LZ4_streamHCPtr = (LZ4_streamHC_t*)buffer;
-    DEBUGLOG(4, "LZ4_initStreamHC(%p, %u)", buffer, (unsigned)size);
-    /* check conditions */
-    if (buffer == NULL) return NULL;
-    if (size < sizeof(LZ4_streamHC_t)) return NULL;
-    if (!LZ4_isAligned(buffer, LZ4_streamHC_t_alignment())) return NULL;
-    /* init */
-    { LZ4HC_CCtx_internal* const hcstate = &(LZ4_streamHCPtr->internal_donotuse);
-      MEM_INIT(hcstate, 0, sizeof(*hcstate)); }
-    LZ4_setCompressionLevel(LZ4_streamHCPtr, LZ4HC_CLEVEL_DEFAULT);
-    return LZ4_streamHCPtr;
-}
-
-/* just a stub */
-void LZ4_resetStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
-{
-    LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
-    LZ4_setCompressionLevel(LZ4_streamHCPtr, compressionLevel);
-}
-
-void LZ4_resetStreamHC_fast (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
-{
-    LZ4HC_CCtx_internal* const s = &LZ4_streamHCPtr->internal_donotuse;
-    DEBUGLOG(5, "LZ4_resetStreamHC_fast(%p, %d)", LZ4_streamHCPtr, compressionLevel);
-    if (s->dirty) {
-        LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
-    } else {
-        assert(s->end >= s->prefixStart);
-        s->dictLimit += (U32)(s->end - s->prefixStart);
-        s->prefixStart = NULL;
-        s->end = NULL;
-        s->dictCtx = NULL;
-    }
-    LZ4_setCompressionLevel(LZ4_streamHCPtr, compressionLevel);
-}
-
-void LZ4_setCompressionLevel(LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
-{
-    DEBUGLOG(5, "LZ4_setCompressionLevel(%p, %d)", LZ4_streamHCPtr, compressionLevel);
-    if (compressionLevel < 1) compressionLevel = LZ4HC_CLEVEL_DEFAULT;
-    if (compressionLevel > LZ4HC_CLEVEL_MAX) compressionLevel = LZ4HC_CLEVEL_MAX;
-    LZ4_streamHCPtr->internal_donotuse.compressionLevel = (short)compressionLevel;
-}
-
-void LZ4_favorDecompressionSpeed(LZ4_streamHC_t* LZ4_streamHCPtr, int favor)
-{
-    LZ4_streamHCPtr->internal_donotuse.favorDecSpeed = (favor!=0);
-}
-
-/* LZ4_loadDictHC() :
- * LZ4_streamHCPtr is presumed properly initialized */
-int LZ4_loadDictHC (LZ4_streamHC_t* LZ4_streamHCPtr,
-              const char* dictionary, int dictSize)
-{
-    LZ4HC_CCtx_internal* const ctxPtr = &LZ4_streamHCPtr->internal_donotuse;
-    cParams_t cp;
-    DEBUGLOG(4, "LZ4_loadDictHC(ctx:%p, dict:%p, dictSize:%d, clevel=%d)", LZ4_streamHCPtr, dictionary, dictSize, ctxPtr->compressionLevel);
-    assert(dictSize >= 0);
-    assert(LZ4_streamHCPtr != NULL);
-    if (dictSize > 64 KB) {
-        dictionary += (size_t)dictSize - 64 KB;
-        dictSize = 64 KB;
-    }
-    /* need a full initialization, there are bad side-effects when using resetFast() */
-    {   int const cLevel = ctxPtr->compressionLevel;
-        LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
-        LZ4_setCompressionLevel(LZ4_streamHCPtr, cLevel);
-        cp = LZ4HC_getCLevelParams(cLevel);
-    }
-    LZ4HC_init_internal (ctxPtr, (const BYTE*)dictionary);
-    ctxPtr->end = (const BYTE*)dictionary + dictSize;
-    if (cp.strat == lz4mid) {
-        LZ4MID_fillHTable (ctxPtr, dictionary, (size_t)dictSize);
-    } else {
-        if (dictSize >= LZ4HC_HASHSIZE) LZ4HC_Insert (ctxPtr, ctxPtr->end-3);
-    }
-    return dictSize;
-}
-
-void LZ4_attach_HC_dictionary(LZ4_streamHC_t *working_stream, const LZ4_streamHC_t *dictionary_stream) {
-    working_stream->internal_donotuse.dictCtx = dictionary_stream != NULL ? &(dictionary_stream->internal_donotuse) : NULL;
-}
-
-/* compression */
-
-static void LZ4HC_setExternalDict(LZ4HC_CCtx_internal* ctxPtr, const BYTE* newBlock)
-{
-    DEBUGLOG(4, "LZ4HC_setExternalDict(%p, %p)", ctxPtr, newBlock);
-    if ( (ctxPtr->end >= ctxPtr->prefixStart + 4)
-      && (LZ4HC_getCLevelParams(ctxPtr->compressionLevel).strat != lz4mid) ) {
-        LZ4HC_Insert (ctxPtr, ctxPtr->end-3);  /* Referencing remaining dictionary content */
-    }
-
-    /* Only one memory segment for extDict, so any previous extDict is lost at this stage */
-    ctxPtr->lowLimit  = ctxPtr->dictLimit;
-    ctxPtr->dictStart  = ctxPtr->prefixStart;
-    ctxPtr->dictLimit += (U32)(ctxPtr->end - ctxPtr->prefixStart);
-    ctxPtr->prefixStart = newBlock;
-    ctxPtr->end  = newBlock;
-    ctxPtr->nextToUpdate = ctxPtr->dictLimit;   /* match referencing will resume from there */
-
-    /* cannot reference an extDict and a dictCtx at the same time */
-    ctxPtr->dictCtx = NULL;
-}
-
-static int
-LZ4_compressHC_continue_generic (LZ4_streamHC_t* LZ4_streamHCPtr,
-                                 const char* src, char* dst,
-                                 int* srcSizePtr, int dstCapacity,
-                                 limitedOutput_directive limit)
-{
-    LZ4HC_CCtx_internal* const ctxPtr = &LZ4_streamHCPtr->internal_donotuse;
-    DEBUGLOG(5, "LZ4_compressHC_continue_generic(ctx=%p, src=%p, srcSize=%d, limit=%d)",
-                LZ4_streamHCPtr, src, *srcSizePtr, limit);
-    assert(ctxPtr != NULL);
-    /* auto-init if forgotten */
-    if (ctxPtr->prefixStart == NULL)
-        LZ4HC_init_internal (ctxPtr, (const BYTE*) src);
-
-    /* Check overflow */
-    if ((size_t)(ctxPtr->end - ctxPtr->prefixStart) + ctxPtr->dictLimit > 2 GB) {
-        size_t dictSize = (size_t)(ctxPtr->end - ctxPtr->prefixStart);
-        if (dictSize > 64 KB) dictSize = 64 KB;
-        LZ4_loadDictHC(LZ4_streamHCPtr, (const char*)(ctxPtr->end) - dictSize, (int)dictSize);
-    }
-
-    /* Check if blocks follow each other */
-    if ((const BYTE*)src != ctxPtr->end)
-        LZ4HC_setExternalDict(ctxPtr, (const BYTE*)src);
-
-    /* Check overlapping input/dictionary space */
-    {   const BYTE* sourceEnd = (const BYTE*) src + *srcSizePtr;
-        const BYTE* const dictBegin = ctxPtr->dictStart;
-        const BYTE* const dictEnd   = ctxPtr->dictStart + (ctxPtr->dictLimit - ctxPtr->lowLimit);
-        if ((sourceEnd > dictBegin) && ((const BYTE*)src < dictEnd)) {
-            if (sourceEnd > dictEnd) sourceEnd = dictEnd;
-            ctxPtr->lowLimit += (U32)(sourceEnd - ctxPtr->dictStart);
-            ctxPtr->dictStart += (U32)(sourceEnd - ctxPtr->dictStart);
-            /* invalidate dictionary is it's too small */
-            if (ctxPtr->dictLimit - ctxPtr->lowLimit < LZ4HC_HASHSIZE) {
-                ctxPtr->lowLimit = ctxPtr->dictLimit;
-                ctxPtr->dictStart = ctxPtr->prefixStart;
-    }   }   }
-
-    return LZ4HC_compress_generic (ctxPtr, src, dst, srcSizePtr, dstCapacity, ctxPtr->compressionLevel, limit);
-}
-
-int LZ4_compress_HC_continue (LZ4_streamHC_t* LZ4_streamHCPtr, const char* src, char* dst, int srcSize, int dstCapacity)
-{
-    DEBUGLOG(5, "LZ4_compress_HC_continue");
-    if (dstCapacity < LZ4_compressBound(srcSize))
-        return LZ4_compressHC_continue_generic (LZ4_streamHCPtr, src, dst, &srcSize, dstCapacity, limitedOutput);
-    else
-        return LZ4_compressHC_continue_generic (LZ4_streamHCPtr, src, dst, &srcSize, dstCapacity, notLimited);
-}
-
-int LZ4_compress_HC_continue_destSize (LZ4_streamHC_t* LZ4_streamHCPtr, const char* src, char* dst, int* srcSizePtr, int targetDestSize)
-{
-    return LZ4_compressHC_continue_generic(LZ4_streamHCPtr, src, dst, srcSizePtr, targetDestSize, fillOutput);
-}
-
-
-/* LZ4_saveDictHC :
- * save history content
- * into a user-provided buffer
- * which is then used to continue compression
- */
-int LZ4_saveDictHC (LZ4_streamHC_t* LZ4_streamHCPtr, char* safeBuffer, int dictSize)
-{
-    LZ4HC_CCtx_internal* const streamPtr = &LZ4_streamHCPtr->internal_donotuse;
-    int const prefixSize = (int)(streamPtr->end - streamPtr->prefixStart);
-    DEBUGLOG(5, "LZ4_saveDictHC(%p, %p, %d)", LZ4_streamHCPtr, safeBuffer, dictSize);
-    assert(prefixSize >= 0);
-    if (dictSize > 64 KB) dictSize = 64 KB;
-    if (dictSize < 4) dictSize = 0;
-    if (dictSize > prefixSize) dictSize = prefixSize;
-    if (safeBuffer == NULL) assert(dictSize == 0);
-    if (dictSize > 0)
-        LZ4_memmove(safeBuffer, streamPtr->end - dictSize, (size_t)dictSize);
-    {   U32 const endIndex = (U32)(streamPtr->end - streamPtr->prefixStart) + streamPtr->dictLimit;
-        streamPtr->end = (safeBuffer == NULL) ? NULL : (const BYTE*)safeBuffer + dictSize;
-        streamPtr->prefixStart = (const BYTE*)safeBuffer;
-        streamPtr->dictLimit = endIndex - (U32)dictSize;
-        streamPtr->lowLimit = endIndex - (U32)dictSize;
-        streamPtr->dictStart = streamPtr->prefixStart;
-        if (streamPtr->nextToUpdate < streamPtr->dictLimit)
-            streamPtr->nextToUpdate = streamPtr->dictLimit;
-    }
-    return dictSize;
-}
-
-
-/* ================================================
- *  LZ4 Optimal parser (levels [LZ4HC_CLEVEL_OPT_MIN - LZ4HC_CLEVEL_MAX])
- * ===============================================*/
-typedef struct {
-    int price;
-    int off;
-    int mlen;
-    int litlen;
-} LZ4HC_optimal_t;
-
-/* price in bytes */
-LZ4_FORCE_INLINE int LZ4HC_literalsPrice(int const litlen)
-{
-    int price = litlen;
-    assert(litlen >= 0);
-    if (litlen >= (int)RUN_MASK)
-        price += 1 + ((litlen-(int)RUN_MASK) / 255);
-    return price;
-}
-
-/* requires mlen >= MINMATCH */
-LZ4_FORCE_INLINE int LZ4HC_sequencePrice(int litlen, int mlen)
-{
-    int price = 1 + 2 ; /* token + 16-bit offset */
-    assert(litlen >= 0);
-    assert(mlen >= MINMATCH);
-
-    price += LZ4HC_literalsPrice(litlen);
-
-    if (mlen >= (int)(ML_MASK+MINMATCH))
-        price += 1 + ((mlen-(int)(ML_MASK+MINMATCH)) / 255);
-
-    return price;
-}
-
-LZ4_FORCE_INLINE LZ4HC_match_t
-LZ4HC_FindLongerMatch(LZ4HC_CCtx_internal* const ctx,
-                      const BYTE* ip, const BYTE* const iHighLimit,
-                      int minLen, int nbSearches,
-                      const dictCtx_directive dict,
-                      const HCfavor_e favorDecSpeed)
-{
-    LZ4HC_match_t const match0 = { 0 , 0, 0 };
-    /* note : LZ4HC_InsertAndGetWiderMatch() is able to modify the starting position of a match (*startpos),
-     * but this won't be the case here, as we define iLowLimit==ip,
-    ** so LZ4HC_InsertAndGetWiderMatch() won't be allowed to search past ip */
-    LZ4HC_match_t md = LZ4HC_InsertAndGetWiderMatch(ctx, ip, ip, iHighLimit, minLen, nbSearches, 1 /*patternAnalysis*/, 1 /*chainSwap*/, dict, favorDecSpeed);
-    assert(md.back == 0);
-    if (md.len <= minLen) return match0;
-    if (favorDecSpeed) {
-        if ((md.len>18) & (md.len<=36)) md.len=18;   /* favor dec.speed (shortcut) */
-    }
-    return md;
-}
-
-
-static int LZ4HC_compress_optimal ( LZ4HC_CCtx_internal* ctx,
-                                    const char* const source,
-                                    char* dst,
-                                    int* srcSizePtr,
-                                    int dstCapacity,
-                                    int const nbSearches,
-                                    size_t sufficient_len,
-                                    const limitedOutput_directive limit,
-                                    int const fullUpdate,
-                                    const dictCtx_directive dict,
-                                    const HCfavor_e favorDecSpeed)
-{
-    int retval = 0;
-#define TRAILING_LITERALS 3
-#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
-    LZ4HC_optimal_t* const opt = (LZ4HC_optimal_t*)ALLOC(sizeof(LZ4HC_optimal_t) * (LZ4_OPT_NUM + TRAILING_LITERALS));
-#else
-    LZ4HC_optimal_t opt[LZ4_OPT_NUM + TRAILING_LITERALS];   /* ~64 KB, which is a bit large for stack... */
-#endif
-
-    const BYTE* ip = (const BYTE*) source;
-    const BYTE* anchor = ip;
-    const BYTE* const iend = ip + *srcSizePtr;
-    const BYTE* const mflimit = iend - MFLIMIT;
-    const BYTE* const matchlimit = iend - LASTLITERALS;
-    BYTE* op = (BYTE*) dst;
-    BYTE* opSaved = (BYTE*) dst;
-    BYTE* oend = op + dstCapacity;
-    int ovml = MINMATCH;  /* overflow - last sequence */
-    int ovoff = 0;
-
-    /* init */
-#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
-    if (opt == NULL) goto _return_label;
-#endif
-    DEBUGLOG(5, "LZ4HC_compress_optimal(dst=%p, dstCapa=%u)", dst, (unsigned)dstCapacity);
-    *srcSizePtr = 0;
-    if (limit == fillOutput) oend -= LASTLITERALS;   /* Hack for support LZ4 format restriction */
-    if (sufficient_len >= LZ4_OPT_NUM) sufficient_len = LZ4_OPT_NUM-1;
-
-    /* Main Loop */
-    while (ip <= mflimit) {
-         int const llen = (int)(ip - anchor);
-         int best_mlen, best_off;
-         int cur, last_match_pos = 0;
-
-         LZ4HC_match_t const firstMatch = LZ4HC_FindLongerMatch(ctx, ip, matchlimit, MINMATCH-1, nbSearches, dict, favorDecSpeed);
-         if (firstMatch.len==0) { ip++; continue; }
-
-         if ((size_t)firstMatch.len > sufficient_len) {
-             /* good enough solution : immediate encoding */
-             int const firstML = firstMatch.len;
-             opSaved = op;
-             if ( LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), firstML, firstMatch.off, limit, oend) ) {  /* updates ip, op and anchor */
-                 ovml = firstML;
-                 ovoff = firstMatch.off;
-                 goto _dest_overflow;
-             }
-             continue;
-         }
-
-         /* set prices for first positions (literals) */
-         {   int rPos;
-             for (rPos = 0 ; rPos < MINMATCH ; rPos++) {
-                 int const cost = LZ4HC_literalsPrice(llen + rPos);
-                 opt[rPos].mlen = 1;
-                 opt[rPos].off = 0;
-                 opt[rPos].litlen = llen + rPos;
-                 opt[rPos].price = cost;
-                 DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i) -- initial setup",
-                             rPos, cost, opt[rPos].litlen);
-         }   }
-         /* set prices using initial match */
-         {   int const matchML = firstMatch.len;   /* necessarily < sufficient_len < LZ4_OPT_NUM */
-             int const offset = firstMatch.off;
-             int mlen;
-             assert(matchML < LZ4_OPT_NUM);
-             for (mlen = MINMATCH ; mlen <= matchML ; mlen++) {
-                 int const cost = LZ4HC_sequencePrice(llen, mlen);
-                 opt[mlen].mlen = mlen;
-                 opt[mlen].off = offset;
-                 opt[mlen].litlen = llen;
-                 opt[mlen].price = cost;
-                 DEBUGLOG(7, "rPos:%3i => price:%3i (matchlen=%i) -- initial setup",
-                             mlen, cost, mlen);
-         }   }
-         last_match_pos = firstMatch.len;
-         {   int addLit;
-             for (addLit = 1; addLit <= TRAILING_LITERALS; addLit ++) {
-                 opt[last_match_pos+addLit].mlen = 1; /* literal */
-                 opt[last_match_pos+addLit].off = 0;
-                 opt[last_match_pos+addLit].litlen = addLit;
-                 opt[last_match_pos+addLit].price = opt[last_match_pos].price + LZ4HC_literalsPrice(addLit);
-                 DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i) -- initial setup",
-                             last_match_pos+addLit, opt[last_match_pos+addLit].price, addLit);
-         }   }
-
-         /* check further positions */
-         for (cur = 1; cur < last_match_pos; cur++) {
-             const BYTE* const curPtr = ip + cur;
-             LZ4HC_match_t newMatch;
-
-             if (curPtr > mflimit) break;
-             DEBUGLOG(7, "rPos:%u[%u] vs [%u]%u",
-                     cur, opt[cur].price, opt[cur+1].price, cur+1);
-             if (fullUpdate) {
-                 /* not useful to search here if next position has same (or lower) cost */
-                 if ( (opt[cur+1].price <= opt[cur].price)
-                   /* in some cases, next position has same cost, but cost rises sharply after, so a small match would still be beneficial */
-                   && (opt[cur+MINMATCH].price < opt[cur].price + 3/*min seq price*/) )
-                     continue;
-             } else {
-                 /* not useful to search here if next position has same (or lower) cost */
-                 if (opt[cur+1].price <= opt[cur].price) continue;
-             }
-
-             DEBUGLOG(7, "search at rPos:%u", cur);
-             if (fullUpdate)
-                 newMatch = LZ4HC_FindLongerMatch(ctx, curPtr, matchlimit, MINMATCH-1, nbSearches, dict, favorDecSpeed);
-             else
-                 /* only test matches of minimum length; slightly faster, but misses a few bytes */
-                 newMatch = LZ4HC_FindLongerMatch(ctx, curPtr, matchlimit, last_match_pos - cur, nbSearches, dict, favorDecSpeed);
-             if (!newMatch.len) continue;
-
-             if ( ((size_t)newMatch.len > sufficient_len)
-               || (newMatch.len + cur >= LZ4_OPT_NUM) ) {
-                 /* immediate encoding */
-                 best_mlen = newMatch.len;
-                 best_off = newMatch.off;
-                 last_match_pos = cur + 1;
-                 goto encode;
-             }
-
-             /* before match : set price with literals at beginning */
-             {   int const baseLitlen = opt[cur].litlen;
-                 int litlen;
-                 for (litlen = 1; litlen < MINMATCH; litlen++) {
-                     int const price = opt[cur].price - LZ4HC_literalsPrice(baseLitlen) + LZ4HC_literalsPrice(baseLitlen+litlen);
-                     int const pos = cur + litlen;
-                     if (price < opt[pos].price) {
-                         opt[pos].mlen = 1; /* literal */
-                         opt[pos].off = 0;
-                         opt[pos].litlen = baseLitlen+litlen;
-                         opt[pos].price = price;
-                         DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i)",
-                                     pos, price, opt[pos].litlen);
-             }   }   }
-
-             /* set prices using match at position = cur */
-             {   int const matchML = newMatch.len;
-                 int ml = MINMATCH;
-
-                 assert(cur + newMatch.len < LZ4_OPT_NUM);
-                 for ( ; ml <= matchML ; ml++) {
-                     int const pos = cur + ml;
-                     int const offset = newMatch.off;
-                     int price;
-                     int ll;
-                     DEBUGLOG(7, "testing price rPos %i (last_match_pos=%i)",
-                                 pos, last_match_pos);
-                     if (opt[cur].mlen == 1) {
-                         ll = opt[cur].litlen;
-                         price = ((cur > ll) ? opt[cur - ll].price : 0)
-                               + LZ4HC_sequencePrice(ll, ml);
-                     } else {
-                         ll = 0;
-                         price = opt[cur].price + LZ4HC_sequencePrice(0, ml);
-                     }
-
-                    assert((U32)favorDecSpeed <= 1);
-                     if (pos > last_match_pos+TRAILING_LITERALS
-                      || price <= opt[pos].price - (int)favorDecSpeed) {
-                         DEBUGLOG(7, "rPos:%3i => price:%3i (matchlen=%i)",
-                                     pos, price, ml);
-                         assert(pos < LZ4_OPT_NUM);
-                         if ( (ml == matchML)  /* last pos of last match */
-                           && (last_match_pos < pos) )
-                             last_match_pos = pos;
-                         opt[pos].mlen = ml;
-                         opt[pos].off = offset;
-                         opt[pos].litlen = ll;
-                         opt[pos].price = price;
-             }   }   }
-             /* complete following positions with literals */
-             {   int addLit;
-                 for (addLit = 1; addLit <= TRAILING_LITERALS; addLit ++) {
-                     opt[last_match_pos+addLit].mlen = 1; /* literal */
-                     opt[last_match_pos+addLit].off = 0;
-                     opt[last_match_pos+addLit].litlen = addLit;
-                     opt[last_match_pos+addLit].price = opt[last_match_pos].price + LZ4HC_literalsPrice(addLit);
-                     DEBUGLOG(7, "rPos:%3i => price:%3i (litlen=%i)", last_match_pos+addLit, opt[last_match_pos+addLit].price, addLit);
-             }   }
-         }  /* for (cur = 1; cur <= last_match_pos; cur++) */
-
-         assert(last_match_pos < LZ4_OPT_NUM + TRAILING_LITERALS);
-         best_mlen = opt[last_match_pos].mlen;
-         best_off = opt[last_match_pos].off;
-         cur = last_match_pos - best_mlen;
-
-encode: /* cur, last_match_pos, best_mlen, best_off must be set */
-         assert(cur < LZ4_OPT_NUM);
-         assert(last_match_pos >= 1);  /* == 1 when only one candidate */
-         DEBUGLOG(6, "reverse traversal, looking for shortest path (last_match_pos=%i)", last_match_pos);
-         {   int candidate_pos = cur;
-             int selected_matchLength = best_mlen;
-             int selected_offset = best_off;
-             while (1) {  /* from end to beginning */
-                 int const next_matchLength = opt[candidate_pos].mlen;  /* can be 1, means literal */
-                 int const next_offset = opt[candidate_pos].off;
-                 DEBUGLOG(7, "pos %i: sequence length %i", candidate_pos, selected_matchLength);
-                 opt[candidate_pos].mlen = selected_matchLength;
-                 opt[candidate_pos].off = selected_offset;
-                 selected_matchLength = next_matchLength;
-                 selected_offset = next_offset;
-                 if (next_matchLength > candidate_pos) break; /* last match elected, first match to encode */
-                 assert(next_matchLength > 0);  /* can be 1, means literal */
-                 candidate_pos -= next_matchLength;
-         }   }
-
-         /* encode all recorded sequences in order */
-         {   int rPos = 0;  /* relative position (to ip) */
-             while (rPos < last_match_pos) {
-                 int const ml = opt[rPos].mlen;
-                 int const offset = opt[rPos].off;
-                 if (ml == 1) { ip++; rPos++; continue; }  /* literal; note: can end up with several literals, in which case, skip them */
-                 rPos += ml;
-                 assert(ml >= MINMATCH);
-                 assert((offset >= 1) && (offset <= LZ4_DISTANCE_MAX));
-                 opSaved = op;
-                 if ( LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ml, offset, limit, oend) ) {  /* updates ip, op and anchor */
-                     ovml = ml;
-                     ovoff = offset;
-                     goto _dest_overflow;
-         }   }   }
-     }  /* while (ip <= mflimit) */
-
-_last_literals:
-     /* Encode Last Literals */
-     {   size_t lastRunSize = (size_t)(iend - anchor);  /* literals */
-         size_t llAdd = (lastRunSize + 255 - RUN_MASK) / 255;
-         size_t const totalSize = 1 + llAdd + lastRunSize;
-         if (limit == fillOutput) oend += LASTLITERALS;  /* restore correct value */
-         if (limit && (op + totalSize > oend)) {
-             if (limit == limitedOutput) { /* Check output limit */
-                retval = 0;
-                goto _return_label;
-             }
-             /* adapt lastRunSize to fill 'dst' */
-             lastRunSize  = (size_t)(oend - op) - 1 /*token*/;
-             llAdd = (lastRunSize + 256 - RUN_MASK) / 256;
-             lastRunSize -= llAdd;
-         }
-         DEBUGLOG(6, "Final literal run : %i literals", (int)lastRunSize);
-         ip = anchor + lastRunSize; /* can be != iend if limit==fillOutput */
-
-         if (lastRunSize >= RUN_MASK) {
-             size_t accumulator = lastRunSize - RUN_MASK;
-             *op++ = (RUN_MASK << ML_BITS);
-             for(; accumulator >= 255 ; accumulator -= 255) *op++ = 255;
-             *op++ = (BYTE) accumulator;
-         } else {
-             *op++ = (BYTE)(lastRunSize << ML_BITS);
-         }
-         LZ4_memcpy(op, anchor, lastRunSize);
-         op += lastRunSize;
-     }
-
-     /* End */
-     *srcSizePtr = (int) (((const char*)ip) - source);
-     retval = (int) ((char*)op-dst);
-     goto _return_label;
-
-_dest_overflow:
-if (limit == fillOutput) {
-     /* Assumption : ip, anchor, ovml and ovref must be set correctly */
-     size_t const ll = (size_t)(ip - anchor);
-     size_t const ll_addbytes = (ll + 240) / 255;
-     size_t const ll_totalCost = 1 + ll_addbytes + ll;
-     BYTE* const maxLitPos = oend - 3; /* 2 for offset, 1 for token */
-     DEBUGLOG(6, "Last sequence overflowing (only %i bytes remaining)", (int)(oend-1-opSaved));
-     op = opSaved;  /* restore correct out pointer */
-     if (op + ll_totalCost <= maxLitPos) {
-         /* ll validated; now adjust match length */
-         size_t const bytesLeftForMl = (size_t)(maxLitPos - (op+ll_totalCost));
-         size_t const maxMlSize = MINMATCH + (ML_MASK-1) + (bytesLeftForMl * 255);
-         assert(maxMlSize < INT_MAX); assert(ovml >= 0);
-         if ((size_t)ovml > maxMlSize) ovml = (int)maxMlSize;
-         if ((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1 + ovml >= MFLIMIT) {
-             DEBUGLOG(6, "Space to end : %i + ml (%i)", (int)((oend + LASTLITERALS) - (op + ll_totalCost + 2) - 1), ovml);
-             DEBUGLOG(6, "Before : ip = %p, anchor = %p", ip, anchor);
-             LZ4HC_encodeSequence(UPDATABLE(ip, op, anchor), ovml, ovoff, notLimited, oend);
-             DEBUGLOG(6, "After : ip = %p, anchor = %p", ip, anchor);
-     }   }
-     goto _last_literals;
-}
-_return_label:
-#if defined(LZ4HC_HEAPMODE) && LZ4HC_HEAPMODE==1
-     if (opt) FREEMEM(opt);
-#endif
-     return retval;
-}
-
-
-/***************************************************
-*  Deprecated Functions
-***************************************************/
-
-/* These functions currently generate deprecation warnings */
-
-/* Wrappers for deprecated compression functions */
-int LZ4_compressHC(const char* src, char* dst, int srcSize) { return LZ4_compress_HC (src, dst, srcSize, LZ4_compressBound(srcSize), 0); }
-int LZ4_compressHC_limitedOutput(const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_HC(src, dst, srcSize, maxDstSize, 0); }
-int LZ4_compressHC2(const char* src, char* dst, int srcSize, int cLevel) { return LZ4_compress_HC (src, dst, srcSize, LZ4_compressBound(srcSize), cLevel); }
-int LZ4_compressHC2_limitedOutput(const char* src, char* dst, int srcSize, int maxDstSize, int cLevel) { return LZ4_compress_HC(src, dst, srcSize, maxDstSize, cLevel); }
-int LZ4_compressHC_withStateHC (void* state, const char* src, char* dst, int srcSize) { return LZ4_compress_HC_extStateHC (state, src, dst, srcSize, LZ4_compressBound(srcSize), 0); }
-int LZ4_compressHC_limitedOutput_withStateHC (void* state, const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_HC_extStateHC (state, src, dst, srcSize, maxDstSize, 0); }
-int LZ4_compressHC2_withStateHC (void* state, const char* src, char* dst, int srcSize, int cLevel) { return LZ4_compress_HC_extStateHC(state, src, dst, srcSize, LZ4_compressBound(srcSize), cLevel); }
-int LZ4_compressHC2_limitedOutput_withStateHC (void* state, const char* src, char* dst, int srcSize, int maxDstSize, int cLevel) { return LZ4_compress_HC_extStateHC(state, src, dst, srcSize, maxDstSize, cLevel); }
-int LZ4_compressHC_continue (LZ4_streamHC_t* ctx, const char* src, char* dst, int srcSize) { return LZ4_compress_HC_continue (ctx, src, dst, srcSize, LZ4_compressBound(srcSize)); }
-int LZ4_compressHC_limitedOutput_continue (LZ4_streamHC_t* ctx, const char* src, char* dst, int srcSize, int maxDstSize) { return LZ4_compress_HC_continue (ctx, src, dst, srcSize, maxDstSize); }
-
-
-/* Deprecated streaming functions */
-int LZ4_sizeofStreamStateHC(void) { return sizeof(LZ4_streamHC_t); }
-
-/* state is presumed correctly sized, aka >= sizeof(LZ4_streamHC_t)
- * @return : 0 on success, !=0 if error */
-int LZ4_resetStreamStateHC(void* state, char* inputBuffer)
-{
-    LZ4_streamHC_t* const hc4 = LZ4_initStreamHC(state, sizeof(*hc4));
-    if (hc4 == NULL) return 1;   /* init failed */
-    LZ4HC_init_internal (&hc4->internal_donotuse, (const BYTE*)inputBuffer);
-    return 0;
-}
-
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-void* LZ4_createHC (const char* inputBuffer)
-{
-    LZ4_streamHC_t* const hc4 = LZ4_createStreamHC();
-    if (hc4 == NULL) return NULL;   /* not enough memory */
-    LZ4HC_init_internal (&hc4->internal_donotuse, (const BYTE*)inputBuffer);
-    return hc4;
-}
-
-int LZ4_freeHC (void* LZ4HC_Data)
-{
-    if (!LZ4HC_Data) return 0;  /* support free on NULL */
-    FREEMEM(LZ4HC_Data);
-    return 0;
-}
-#endif
-
-int LZ4_compressHC2_continue (void* LZ4HC_Data, const char* src, char* dst, int srcSize, int cLevel)
-{
-    return LZ4HC_compress_generic (&((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse, src, dst, &srcSize, 0, cLevel, notLimited);
-}
-
-int LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* src, char* dst, int srcSize, int dstCapacity, int cLevel)
-{
-    return LZ4HC_compress_generic (&((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse, src, dst, &srcSize, dstCapacity, cLevel, limitedOutput);
-}
-
-char* LZ4_slideInputBufferHC(void* LZ4HC_Data)
-{
-    LZ4HC_CCtx_internal* const s = &((LZ4_streamHC_t*)LZ4HC_Data)->internal_donotuse;
-    const BYTE* const bufferStart = s->prefixStart - s->dictLimit + s->lowLimit;
-    LZ4_resetStreamHC_fast((LZ4_streamHC_t*)LZ4HC_Data, s->compressionLevel);
-    /* ugly conversion trick, required to evade (const char*) -> (char*) cast-qual warning :( */
-    return (char*)(uptrval)bufferStart;
-}
diff --git a/native/lz4/vendor/lib/lz4hc.h b/native/lz4/vendor/lib/lz4hc.h
deleted file mode 100644
index 992bc8c..0000000
--- a/native/lz4/vendor/lib/lz4hc.h
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
-   LZ4 HC - High Compression Mode of LZ4
-   Header File
-   Copyright (C) 2011-2020, Yann Collet.
-   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions are
-   met:
-
-       * Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-       * Redistributions in binary form must reproduce the above
-   copyright notice, this list of conditions and the following disclaimer
-   in the documentation and/or other materials provided with the
-   distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-   You can contact the author at :
-   - LZ4 source repository : https://github.com/lz4/lz4
-   - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c
-*/
-#ifndef LZ4_HC_H_19834876238432
-#define LZ4_HC_H_19834876238432
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/* --- Dependency --- */
-/* note : lz4hc requires lz4.h/lz4.c for compilation */
-#include "lz4.h"   /* stddef, LZ4LIB_API, LZ4_DEPRECATED */
-
-
-/* --- Useful constants --- */
-#define LZ4HC_CLEVEL_MIN         2
-#define LZ4HC_CLEVEL_DEFAULT     9
-#define LZ4HC_CLEVEL_OPT_MIN    10
-#define LZ4HC_CLEVEL_MAX        12
-
-
-/*-************************************
- *  Block Compression
- **************************************/
-/*! LZ4_compress_HC() :
- *  Compress data from `src` into `dst`, using the powerful but slower "HC" algorithm.
- * `dst` must be already allocated.
- *  Compression is guaranteed to succeed if `dstCapacity >= LZ4_compressBound(srcSize)` (see "lz4.h")
- *  Max supported `srcSize` value is LZ4_MAX_INPUT_SIZE (see "lz4.h")
- * `compressionLevel` : any value between 1 and LZ4HC_CLEVEL_MAX will work.
- *                      Values > LZ4HC_CLEVEL_MAX behave the same as LZ4HC_CLEVEL_MAX.
- * @return : the number of bytes written into 'dst'
- *           or 0 if compression fails.
- */
-LZ4LIB_API int LZ4_compress_HC (const char* src, char* dst, int srcSize, int dstCapacity, int compressionLevel);
-
-
-/* Note :
- *   Decompression functions are provided within "lz4.h" (BSD license)
- */
-
-
-/*! LZ4_compress_HC_extStateHC() :
- *  Same as LZ4_compress_HC(), but using an externally allocated memory segment for `state`.
- * `state` size is provided by LZ4_sizeofStateHC().
- *  Memory segment must be aligned on 8-bytes boundaries (which a normal malloc() should do properly).
- */
-LZ4LIB_API int LZ4_sizeofStateHC(void);
-LZ4LIB_API int LZ4_compress_HC_extStateHC(void* stateHC, const char* src, char* dst, int srcSize, int maxDstSize, int compressionLevel);
-
-
-/*! LZ4_compress_HC_destSize() : v1.9.0+
- *  Will compress as much data as possible from `src`
- *  to fit into `targetDstSize` budget.
- *  Result is provided in 2 parts :
- * @return : the number of bytes written into 'dst' (necessarily <= targetDstSize)
- *           or 0 if compression fails.
- * `srcSizePtr` : on success, *srcSizePtr is updated to indicate how much bytes were read from `src`
- */
-LZ4LIB_API int LZ4_compress_HC_destSize(void* stateHC,
-                                  const char* src, char* dst,
-                                        int* srcSizePtr, int targetDstSize,
-                                        int compressionLevel);
-
-
-/*-************************************
- *  Streaming Compression
- *  Bufferless synchronous API
- **************************************/
- typedef union LZ4_streamHC_u LZ4_streamHC_t;   /* incomplete type (defined later) */
-
-/*! LZ4_createStreamHC() and LZ4_freeStreamHC() :
- *  These functions create and release memory for LZ4 HC streaming state.
- *  Newly created states are automatically initialized.
- *  A same state can be used multiple times consecutively,
- *  starting with LZ4_resetStreamHC_fast() to start a new stream of blocks.
- */
-LZ4LIB_API LZ4_streamHC_t* LZ4_createStreamHC(void);
-LZ4LIB_API int             LZ4_freeStreamHC (LZ4_streamHC_t* streamHCPtr);
-
-/*
-  These functions compress data in successive blocks of any size,
-  using previous blocks as dictionary, to improve compression ratio.
-  One key assumption is that previous blocks (up to 64 KB) remain read-accessible while compressing next blocks.
-  There is an exception for ring buffers, which can be smaller than 64 KB.
-  Ring-buffer scenario is automatically detected and handled within LZ4_compress_HC_continue().
-
-  Before starting compression, state must be allocated and properly initialized.
-  LZ4_createStreamHC() does both, though compression level is set to LZ4HC_CLEVEL_DEFAULT.
-
-  Selecting the compression level can be done with LZ4_resetStreamHC_fast() (starts a new stream)
-  or LZ4_setCompressionLevel() (anytime, between blocks in the same stream) (experimental).
-  LZ4_resetStreamHC_fast() only works on states which have been properly initialized at least once,
-  which is automatically the case when state is created using LZ4_createStreamHC().
-
-  After reset, a first "fictional block" can be designated as initial dictionary,
-  using LZ4_loadDictHC() (Optional).
-  Note: In order for LZ4_loadDictHC() to create the correct data structure,
-  it is essential to set the compression level _before_ loading the dictionary.
-
-  Invoke LZ4_compress_HC_continue() to compress each successive block.
-  The number of blocks is unlimited.
-  Previous input blocks, including initial dictionary when present,
-  must remain accessible and unmodified during compression.
-
-  It's allowed to update compression level anytime between blocks,
-  using LZ4_setCompressionLevel() (experimental).
-
- @dst buffer should be sized to handle worst case scenarios
-  (see LZ4_compressBound(), it ensures compression success).
-  In case of failure, the API does not guarantee recovery,
-  so the state _must_ be reset.
-  To ensure compression success
-  whenever @dst buffer size cannot be made >= LZ4_compressBound(),
-  consider using LZ4_compress_HC_continue_destSize().
-
-  Whenever previous input blocks can't be preserved unmodified in-place during compression of next blocks,
-  it's possible to copy the last blocks into a more stable memory space, using LZ4_saveDictHC().
-  Return value of LZ4_saveDictHC() is the size of dictionary effectively saved into 'safeBuffer' (<= 64 KB)
-
-  After completing a streaming compression,
-  it's possible to start a new stream of blocks, using the same LZ4_streamHC_t state,
-  just by resetting it, using LZ4_resetStreamHC_fast().
-*/
-
-LZ4LIB_API void LZ4_resetStreamHC_fast(LZ4_streamHC_t* streamHCPtr, int compressionLevel);   /* v1.9.0+ */
-LZ4LIB_API int  LZ4_loadDictHC (LZ4_streamHC_t* streamHCPtr, const char* dictionary, int dictSize);
-
-LZ4LIB_API int LZ4_compress_HC_continue (LZ4_streamHC_t* streamHCPtr,
-                                   const char* src, char* dst,
-                                         int srcSize, int maxDstSize);
-
-/*! LZ4_compress_HC_continue_destSize() : v1.9.0+
- *  Similar to LZ4_compress_HC_continue(),
- *  but will read as much data as possible from `src`
- *  to fit into `targetDstSize` budget.
- *  Result is provided into 2 parts :
- * @return : the number of bytes written into 'dst' (necessarily <= targetDstSize)
- *           or 0 if compression fails.
- * `srcSizePtr` : on success, *srcSizePtr will be updated to indicate how much bytes were read from `src`.
- *           Note that this function may not consume the entire input.
- */
-LZ4LIB_API int LZ4_compress_HC_continue_destSize(LZ4_streamHC_t* LZ4_streamHCPtr,
-                                           const char* src, char* dst,
-                                                 int* srcSizePtr, int targetDstSize);
-
-LZ4LIB_API int LZ4_saveDictHC (LZ4_streamHC_t* streamHCPtr, char* safeBuffer, int maxDictSize);
-
-
-/*! LZ4_attach_HC_dictionary() : stable since v1.10.0
- *  This API allows for the efficient re-use of a static dictionary many times.
- *
- *  Rather than re-loading the dictionary buffer into a working context before
- *  each compression, or copying a pre-loaded dictionary's LZ4_streamHC_t into a
- *  working LZ4_streamHC_t, this function introduces a no-copy setup mechanism,
- *  in which the working stream references the dictionary stream in-place.
- *
- *  Several assumptions are made about the state of the dictionary stream.
- *  Currently, only streams which have been prepared by LZ4_loadDictHC() should
- *  be expected to work.
- *
- *  Alternatively, the provided dictionary stream pointer may be NULL, in which
- *  case any existing dictionary stream is unset.
- *
- *  A dictionary should only be attached to a stream without any history (i.e.,
- *  a stream that has just been reset).
- *
- *  The dictionary will remain attached to the working stream only for the
- *  current stream session. Calls to LZ4_resetStreamHC(_fast) will remove the
- *  dictionary context association from the working stream. The dictionary
- *  stream (and source buffer) must remain in-place / accessible / unchanged
- *  through the lifetime of the stream session.
- */
-LZ4LIB_API void
-LZ4_attach_HC_dictionary(LZ4_streamHC_t* working_stream,
-                   const LZ4_streamHC_t* dictionary_stream);
-
-
-/*^**********************************************
- * !!!!!!   STATIC LINKING ONLY   !!!!!!
- ***********************************************/
-
-/*-******************************************************************
- * PRIVATE DEFINITIONS :
- * Do not use these definitions directly.
- * They are merely exposed to allow static allocation of `LZ4_streamHC_t`.
- * Declare an `LZ4_streamHC_t` directly, rather than any type below.
- * Even then, only do so in the context of static linking, as definitions may change between versions.
- ********************************************************************/
-
-#define LZ4HC_DICTIONARY_LOGSIZE 16
-#define LZ4HC_MAXD (1<<LZ4HC_DICTIONARY_LOGSIZE)
-#define LZ4HC_MAXD_MASK (LZ4HC_MAXD - 1)
-
-#define LZ4HC_HASH_LOG 15
-#define LZ4HC_HASHTABLESIZE (1 << LZ4HC_HASH_LOG)
-#define LZ4HC_HASH_MASK (LZ4HC_HASHTABLESIZE - 1)
-
-
-/* Never ever use these definitions directly !
- * Declare or allocate an LZ4_streamHC_t instead.
-**/
-typedef struct LZ4HC_CCtx_internal LZ4HC_CCtx_internal;
-struct LZ4HC_CCtx_internal
-{
-    LZ4_u32 hashTable[LZ4HC_HASHTABLESIZE];
-    LZ4_u16 chainTable[LZ4HC_MAXD];
-    const LZ4_byte* end;     /* next block here to continue on current prefix */
-    const LZ4_byte* prefixStart;  /* Indexes relative to this position */
-    const LZ4_byte* dictStart; /* alternate reference for extDict */
-    LZ4_u32 dictLimit;       /* below that point, need extDict */
-    LZ4_u32 lowLimit;        /* below that point, no more history */
-    LZ4_u32 nextToUpdate;    /* index from which to continue dictionary update */
-    short   compressionLevel;
-    LZ4_i8  favorDecSpeed;   /* favor decompression speed if this flag set,
-                                otherwise, favor compression ratio */
-    LZ4_i8  dirty;           /* stream has to be fully reset if this flag is set */
-    const LZ4HC_CCtx_internal* dictCtx;
-};
-
-#define LZ4_STREAMHC_MINSIZE  262200  /* static size, for inter-version compatibility */
-union LZ4_streamHC_u {
-    char minStateSize[LZ4_STREAMHC_MINSIZE];
-    LZ4HC_CCtx_internal internal_donotuse;
-}; /* previously typedef'd to LZ4_streamHC_t */
-
-/* LZ4_streamHC_t :
- * This structure allows static allocation of LZ4 HC streaming state.
- * This can be used to allocate statically on stack, or as part of a larger structure.
- *
- * Such state **must** be initialized using LZ4_initStreamHC() before first use.
- *
- * Note that invoking LZ4_initStreamHC() is not required when
- * the state was created using LZ4_createStreamHC() (which is recommended).
- * Using the normal builder, a newly created state is automatically initialized.
- *
- * Static allocation shall only be used in combination with static linking.
- */
-
-/* LZ4_initStreamHC() : v1.9.0+
- * Required before first use of a statically allocated LZ4_streamHC_t.
- * Before v1.9.0 : use LZ4_resetStreamHC() instead
- */
-LZ4LIB_API LZ4_streamHC_t* LZ4_initStreamHC(void* buffer, size_t size);
-
-
-/*-************************************
-*  Deprecated Functions
-**************************************/
-/* see lz4.h LZ4_DISABLE_DEPRECATE_WARNINGS to turn off deprecation warnings */
-
-/* deprecated compression functions */
-LZ4_DEPRECATED("use LZ4_compress_HC() instead") LZ4LIB_API int LZ4_compressHC               (const char* source, char* dest, int inputSize);
-LZ4_DEPRECATED("use LZ4_compress_HC() instead") LZ4LIB_API int LZ4_compressHC_limitedOutput (const char* source, char* dest, int inputSize, int maxOutputSize);
-LZ4_DEPRECATED("use LZ4_compress_HC() instead") LZ4LIB_API int LZ4_compressHC2              (const char* source, char* dest, int inputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_compress_HC() instead") LZ4LIB_API int LZ4_compressHC2_limitedOutput(const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") LZ4LIB_API int LZ4_compressHC_withStateHC               (void* state, const char* source, char* dest, int inputSize);
-LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") LZ4LIB_API int LZ4_compressHC_limitedOutput_withStateHC (void* state, const char* source, char* dest, int inputSize, int maxOutputSize);
-LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") LZ4LIB_API int LZ4_compressHC2_withStateHC              (void* state, const char* source, char* dest, int inputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_compress_HC_extStateHC() instead") LZ4LIB_API int LZ4_compressHC2_limitedOutput_withStateHC(void* state, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") LZ4LIB_API int LZ4_compressHC_continue               (LZ4_streamHC_t* LZ4_streamHCPtr, const char* source, char* dest, int inputSize);
-LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") LZ4LIB_API int LZ4_compressHC_limitedOutput_continue (LZ4_streamHC_t* LZ4_streamHCPtr, const char* source, char* dest, int inputSize, int maxOutputSize);
-
-/* Obsolete streaming functions; degraded functionality; do not use!
- *
- * In order to perform streaming compression, these functions depended on data
- * that is no longer tracked in the state. They have been preserved as well as
- * possible: using them will still produce a correct output. However, use of
- * LZ4_slideInputBufferHC() will truncate the history of the stream, rather
- * than preserve a window-sized chunk of history.
- */
-#if !defined(LZ4_STATIC_LINKING_ONLY_DISABLE_MEMORY_ALLOCATION)
-LZ4_DEPRECATED("use LZ4_createStreamHC() instead") LZ4LIB_API void* LZ4_createHC (const char* inputBuffer);
-LZ4_DEPRECATED("use LZ4_freeStreamHC() instead") LZ4LIB_API   int   LZ4_freeHC (void* LZ4HC_Data);
-#endif
-LZ4_DEPRECATED("use LZ4_saveDictHC() instead") LZ4LIB_API     char* LZ4_slideInputBufferHC (void* LZ4HC_Data);
-LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") LZ4LIB_API int LZ4_compressHC2_continue               (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_compress_HC_continue() instead") LZ4LIB_API int LZ4_compressHC2_limitedOutput_continue (void* LZ4HC_Data, const char* source, char* dest, int inputSize, int maxOutputSize, int compressionLevel);
-LZ4_DEPRECATED("use LZ4_createStreamHC() instead") LZ4LIB_API int   LZ4_sizeofStreamStateHC(void);
-LZ4_DEPRECATED("use LZ4_initStreamHC() instead") LZ4LIB_API  int   LZ4_resetStreamStateHC(void* state, char* inputBuffer);
-
-
-/* LZ4_resetStreamHC() is now replaced by LZ4_initStreamHC().
- * The intention is to emphasize the difference with LZ4_resetStreamHC_fast(),
- * which is now the recommended function to start a new stream of blocks,
- * but cannot be used to initialize a memory segment containing arbitrary garbage data.
- *
- * It is recommended to switch to LZ4_initStreamHC().
- * LZ4_resetStreamHC() will generate deprecation warnings in a future version.
- */
-LZ4LIB_API void LZ4_resetStreamHC (LZ4_streamHC_t* streamHCPtr, int compressionLevel);
-
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif /* LZ4_HC_H_19834876238432 */
-
-
-/*-**************************************************
- * !!!!!     STATIC LINKING ONLY     !!!!!
- * Following definitions are considered experimental.
- * They should not be linked from DLL,
- * as there is no guarantee of API stability yet.
- * Prototypes will be promoted to "stable" status
- * after successful usage in real-life scenarios.
- ***************************************************/
-#ifdef LZ4_HC_STATIC_LINKING_ONLY   /* protection macro */
-#ifndef LZ4_HC_SLO_098092834
-#define LZ4_HC_SLO_098092834
-
-#define LZ4_STATIC_LINKING_ONLY   /* LZ4LIB_STATIC_API */
-#include "lz4.h"
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-/*! LZ4_setCompressionLevel() : v1.8.0+ (experimental)
- *  It's possible to change compression level
- *  between successive invocations of LZ4_compress_HC_continue*()
- *  for dynamic adaptation.
- */
-LZ4LIB_STATIC_API void LZ4_setCompressionLevel(
-    LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel);
-
-/*! LZ4_favorDecompressionSpeed() : v1.8.2+ (experimental)
- *  Opt. Parser will favor decompression speed over compression ratio.
- *  Only applicable to levels >= LZ4HC_CLEVEL_OPT_MIN.
- */
-LZ4LIB_STATIC_API void LZ4_favorDecompressionSpeed(
-    LZ4_streamHC_t* LZ4_streamHCPtr, int favor);
-
-/*! LZ4_resetStreamHC_fast() : v1.9.0+
- *  When an LZ4_streamHC_t is known to be in a internally coherent state,
- *  it can often be prepared for a new compression with almost no work, only
- *  sometimes falling back to the full, expensive reset that is always required
- *  when the stream is in an indeterminate state (i.e., the reset performed by
- *  LZ4_resetStreamHC()).
- *
- *  LZ4_streamHCs are guaranteed to be in a valid state when:
- *  - returned from LZ4_createStreamHC()
- *  - reset by LZ4_resetStreamHC()
- *  - memset(stream, 0, sizeof(LZ4_streamHC_t))
- *  - the stream was in a valid state and was reset by LZ4_resetStreamHC_fast()
- *  - the stream was in a valid state and was then used in any compression call
- *    that returned success
- *  - the stream was in an indeterminate state and was used in a compression
- *    call that fully reset the state (LZ4_compress_HC_extStateHC()) and that
- *    returned success
- *
- *  Note:
- *  A stream that was last used in a compression call that returned an error
- *  may be passed to this function. However, it will be fully reset, which will
- *  clear any existing history and settings from the context.
- */
-LZ4LIB_STATIC_API void LZ4_resetStreamHC_fast(
-    LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel);
-
-/*! LZ4_compress_HC_extStateHC_fastReset() :
- *  A variant of LZ4_compress_HC_extStateHC().
- *
- *  Using this variant avoids an expensive initialization step. It is only safe
- *  to call if the state buffer is known to be correctly initialized already
- *  (see above comment on LZ4_resetStreamHC_fast() for a definition of
- *  "correctly initialized"). From a high level, the difference is that this
- *  function initializes the provided state with a call to
- *  LZ4_resetStreamHC_fast() while LZ4_compress_HC_extStateHC() starts with a
- *  call to LZ4_resetStreamHC().
- */
-LZ4LIB_STATIC_API int LZ4_compress_HC_extStateHC_fastReset (
-    void* state,
-    const char* src, char* dst,
-    int srcSize, int dstCapacity,
-    int compressionLevel);
-
-#if defined (__cplusplus)
-}
-#endif
-
-#endif   /* LZ4_HC_SLO_098092834 */
-#endif   /* LZ4_HC_STATIC_LINKING_ONLY */
diff --git a/pyproject.toml b/pyproject.toml
index 16a8a17..9fda8fb 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -12,7 +12,7 @@ license = "MIT"
 license-files = [
     "LICENSE",
     "src/puffin/LICENSE",
-    "native/lz4/LICENSE",
+    "licenses/LICENSE.lz4",
 ]
 authors = [
     { name = "Kartik Sharma", email = "kartik.sharma522@gmail.com" },
diff --git a/src/lz4.rs b/src/lz4.rs
index 785ea0c..6075365 100644
--- a/src/lz4.rs
+++ b/src/lz4.rs
@@ -1,4 +1,16 @@
+//! LZ4 block operations for Android `lz4diff`, backed by the pinned `lz4-sys`
+//! crate. The crate bundles liblz4 1.10.0 C sources that are byte-identical
+//! (SHA-256 verified) to AOSP `platform/external/lz4` commit
+//! `734e07032602e9a72fcc9701028b0aee45147fcd`, so compressed output matches
+//! the AOSP reference byte for byte. See `licenses/README.md`.
+
+// Force the pinned `lz4-sys` crate into the crate graph: its rlib carries the
+// `cargo:rustc-link-lib=static=lz4` metadata that links the bundled liblz4
+// archive, which the direct extern declarations below resolve against.
+use lz4_sys as _;
+
 use std::error;
+use std::ffi::{c_char, c_int, c_void};
 use std::fmt;
 
 const MAX_INPUT_SIZE: usize = 0x7e00_0000;
@@ -12,8 +24,6 @@ pub enum Status {
     DecompressionFailed,
     AllocationFailure,
     CompressionDivergence,
-    UnsupportedTarget,
-    Unknown(i32),
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -40,7 +50,6 @@ pub type Result<T> = std::result::Result<T, Error>;
 
 /// Decompresses one LZ4 block into a newly allocated, exact-size buffer.
 pub fn decompress_safe_partial(input: &[u8], output_size: usize) -> Result<Vec<u8>> {
-    ensure_supported()?;
     validate_sizes(input.len(), output_size)?;
     if input.len() >= output_size {
         return Err(invalid_argument("stored LZ4 block must be smaller than its raw block"));
@@ -112,7 +121,6 @@ fn compress(
     zero_padding: bool,
     compression_level: Option<i32>,
 ) -> Result<Vec<u8>> {
-    ensure_supported()?;
     validate_sizes(input.len(), output_size)?;
     if let Some(expected) = expected_source_size {
         if expected == 0 || expected > input.len() {
@@ -197,157 +205,105 @@ struct NativeResult {
     output_size: usize,
 }
 
-#[cfg(otadump_lz4)]
 fn decompress_native(input: &[u8], output: &mut [u8]) -> Result<NativeResult> {
-    native_call(input, output, None, true)
-}
-
-#[cfg(not(otadump_lz4))]
-fn decompress_native(_input: &[u8], _output: &mut [u8]) -> Result<NativeResult> {
-    Err(unsupported_target())
-}
-
-#[cfg(otadump_lz4)]
-fn compress_native(
-    input: &[u8],
-    output: &mut [u8],
-    compression_level: Option<i32>,
-) -> Result<NativeResult> {
-    native_call(input, output, compression_level, false)
-}
-
-#[cfg(not(otadump_lz4))]
-fn compress_native(
-    _input: &[u8],
-    _output: &mut [u8],
-    _compression_level: Option<i32>,
-) -> Result<NativeResult> {
-    Err(unsupported_target())
-}
-
-#[cfg(not(otadump_lz4))]
-fn ensure_supported() -> Result<()> {
-    Err(unsupported_target())
-}
-
-#[cfg(otadump_lz4)]
-fn ensure_supported() -> Result<()> {
-    Ok(())
-}
-
-#[allow(dead_code)]
-fn unsupported_target() -> Error {
-    Error {
-        status: Status::UnsupportedTarget,
-        message: "LZ4 block operations are supported only on Linux x86_64 GNU hosts".into(),
+    // SAFETY: The immutable input and mutable output slices cannot alias. They
+    // remain alive for the call, and their checked lengths match the pointers.
+    let written = unsafe {
+        LZ4_decompress_safe_partial(
+            input.as_ptr().cast::<c_char>(),
+            output.as_mut_ptr().cast::<c_char>(),
+            to_c_int(input.len())?,
+            to_c_int(output.len())?,
+            to_c_int(output.len())?,
+        )
+    };
+    if written < 0 {
+        return Err(Error {
+            status: Status::DecompressionFailed,
+            message: "LZ4 decompression failed".into(),
+        });
     }
+    Ok(NativeResult { source_size: input.len(), output_size: written as usize })
 }
 
-#[cfg(otadump_lz4)]
-fn native_call(
+fn compress_native(
     input: &[u8],
     output: &mut [u8],
     compression_level: Option<i32>,
-    decompress: bool,
 ) -> Result<NativeResult> {
-    use std::ffi::c_int;
-
-    #[repr(C)]
-    struct FfiResult {
-        status: c_int,
-        source_size: c_int,
-        output_size: c_int,
-    }
-
-    unsafe extern "C" {
-        fn otadump_lz4_decompress_safe_partial(
-            source: *const u8,
-            source_size: c_int,
-            output: *mut u8,
-            output_capacity: c_int,
-            target_output_size: c_int,
-        ) -> FfiResult;
-        fn otadump_lz4_compress_dest_size(
-            source: *const u8,
-            source_size: c_int,
-            output: *mut u8,
-            output_capacity: c_int,
-        ) -> FfiResult;
-        fn otadump_lz4_compress_hc_dest_size(
-            source: *const u8,
-            source_size: c_int,
-            output: *mut u8,
-            output_capacity: c_int,
-            compression_level: c_int,
-        ) -> FfiResult;
-    }
-
-    let source_size =
-        i32::try_from(input.len()).map_err(|_| invalid_argument("LZ4 input size exceeds int"))?;
-    let output_size =
-        i32::try_from(output.len()).map_err(|_| invalid_argument("LZ4 output size exceeds int"))?;
+    let mut consumed = to_c_int(input.len())?;
+    let capacity = to_c_int(output.len())?;
     // SAFETY: The immutable input and mutable output slices cannot alias. They
     // remain alive for the call, and their checked lengths match the pointers.
-    let result = unsafe {
-        if decompress {
-            otadump_lz4_decompress_safe_partial(
-                input.as_ptr(),
-                source_size,
-                output.as_mut_ptr(),
-                output_size,
-                output_size,
-            )
-        } else if let Some(level) = compression_level {
-            otadump_lz4_compress_hc_dest_size(
-                input.as_ptr(),
-                source_size,
-                output.as_mut_ptr(),
-                output_size,
+    // `consumed` is a valid in-out parameter initialized to the input length.
+    let written = unsafe {
+        if let Some(level) = compression_level {
+            let stream = LZ4_createStreamHC();
+            if stream.is_null() {
+                return Err(Error {
+                    status: Status::AllocationFailure,
+                    message: "unable to allocate the LZ4HC stream state".into(),
+                });
+            }
+            let written = LZ4_compress_HC_destSize(
+                stream,
+                input.as_ptr().cast::<c_char>(),
+                output.as_mut_ptr().cast::<c_char>(),
+                &mut consumed,
+                capacity,
                 level,
-            )
+            );
+            LZ4_freeStreamHC(stream);
+            written
         } else {
-            otadump_lz4_compress_dest_size(
-                input.as_ptr(),
-                source_size,
-                output.as_mut_ptr(),
-                output_size,
+            LZ4_compress_destSize(
+                input.as_ptr().cast::<c_char>(),
+                output.as_mut_ptr().cast::<c_char>(),
+                &mut consumed,
+                capacity,
             )
         }
     };
-    if result.status != 0 {
+    if written <= 0 {
         return Err(Error {
-            status: native_status(result.status),
-            message: native_message(result.status).into(),
+            status: Status::CompressionFailed,
+            message: "LZ4 compression failed".into(),
         });
     }
-    Ok(NativeResult {
-        source_size: usize::try_from(result.source_size)
-            .map_err(|_| invalid_argument("native LZ4 returned a negative source size"))?,
-        output_size: usize::try_from(result.output_size)
-            .map_err(|_| invalid_argument("native LZ4 returned a negative output size"))?,
-    })
+    Ok(NativeResult { source_size: consumed as usize, output_size: written as usize })
 }
 
-#[cfg(otadump_lz4)]
-fn native_status(status: i32) -> Status {
-    match status {
-        1 => Status::InvalidArgument,
-        2 => Status::CompressionFailed,
-        3 => Status::DecompressionFailed,
-        4 => Status::AllocationFailure,
-        status => Status::Unknown(status),
-    }
+fn to_c_int(size: usize) -> Result<c_int> {
+    c_int::try_from(size).map_err(|_| invalid_argument("LZ4 size exceeds int"))
 }
 
-#[cfg(otadump_lz4)]
-fn native_message(status: i32) -> &'static str {
-    match status {
-        1 => "native LZ4 rejected an argument",
-        2 => "native LZ4 compression failed",
-        3 => "native LZ4 decompression failed",
-        4 => "native LZ4 allocation failed",
-        _ => "native LZ4 failed with an unknown status",
-    }
+// Direct declarations for the liblz4 block API: the pinned `lz4-sys` crate
+// statically links the bundled liblz4 archive but its bindings omit these
+// symbols. Signatures match `lz4.h`/`lz4hc.h` 1.10.0.
+unsafe extern "C" {
+    fn LZ4_decompress_safe_partial(
+        source: *const c_char,
+        dest: *mut c_char,
+        compressed_size: c_int,
+        target_output_size: c_int,
+        max_decompressed_size: c_int,
+    ) -> c_int;
+    fn LZ4_compress_destSize(
+        source: *const c_char,
+        dest: *mut c_char,
+        source_size: *mut c_int,
+        target_dest_size: c_int,
+    ) -> c_int;
+    fn LZ4_createStreamHC() -> *mut c_void;
+    fn LZ4_freeStreamHC(stream: *mut c_void) -> c_int;
+    fn LZ4_compress_HC_destSize(
+        stream: *mut c_void,
+        source: *const c_char,
+        dest: *mut c_char,
+        source_size: *mut c_int,
+        target_dest_size: c_int,
+        compression_level: c_int,
+    ) -> c_int;
 }
 
 #[cfg(test)]

From cd3debaa5839ba5b94a48692fc7e248b6407ebc7 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 21:05:00 +0530
Subject: [PATCH 36/42] tests: shrink fixture fanout with runtime builders

---
 tests/delta_extraction.rs                     | 110 ++++++++++++++----
 tests/fixtures/lz4diff/README.md              |   7 +-
 tests/fixtures/lz4diff/SHA256SUMS             |   8 --
 tests/fixtures/lz4diff/lz4-bsdiff/source.bin  | Bin 768 -> 0 bytes
 tests/fixtures/lz4diff/lz4-bsdiff/target.bin  | Bin 768 -> 0 bytes
 .../fixtures/lz4diff/lz4hc9-bsdiff/source.bin | Bin 1152 -> 0 bytes
 .../fixtures/lz4diff/lz4hc9-bsdiff/target.bin | Bin 1152 -> 0 bytes
 .../lz4diff/postfix-bsdiff/source.bin         | Bin 768 -> 0 bytes
 .../lz4diff/postfix-bsdiff/target.bin         | Bin 768 -> 0 bytes
 .../lz4diff/zero-padding-bsdiff/source.bin    | Bin 608 -> 0 bytes
 .../lz4diff/zero-padding-bsdiff/target.bin    | Bin 608 -> 0 bytes
 tests/fixtures/zucchini/README.md             |  10 +-
 tests/fixtures/zucchini/SHA256SUMS            |   8 --
 tests/fixtures/zucchini/dex.zuc.br            | Bin 146 -> 0 bytes
 tests/fixtures/zucchini/elf-arm32.zuc.br      | Bin 72 -> 0 bytes
 tests/fixtures/zucchini/elf-arm64.zuc.br      | Bin 74 -> 0 bytes
 tests/fixtures/zucchini/elf-x86.zuc.br        | Bin 73 -> 0 bytes
 tests/fixtures/zucchini/elf.zuc.br            | Bin 91 -> 0 bytes
 .../fixtures/zucchini/malformed-brotli.zuc.br |   1 -
 .../zucchini/malformed-zucchini.zuc.br        |   1 -
 tests/fixtures/zucchini/noop.zuc.br           | Bin 78 -> 0 bytes
 21 files changed, 97 insertions(+), 48 deletions(-)
 delete mode 100644 tests/fixtures/lz4diff/lz4-bsdiff/source.bin
 delete mode 100644 tests/fixtures/lz4diff/lz4-bsdiff/target.bin
 delete mode 100644 tests/fixtures/lz4diff/lz4hc9-bsdiff/source.bin
 delete mode 100644 tests/fixtures/lz4diff/lz4hc9-bsdiff/target.bin
 delete mode 100644 tests/fixtures/lz4diff/postfix-bsdiff/source.bin
 delete mode 100644 tests/fixtures/lz4diff/postfix-bsdiff/target.bin
 delete mode 100644 tests/fixtures/lz4diff/zero-padding-bsdiff/source.bin
 delete mode 100644 tests/fixtures/lz4diff/zero-padding-bsdiff/target.bin
 delete mode 100644 tests/fixtures/zucchini/dex.zuc.br
 delete mode 100644 tests/fixtures/zucchini/elf-arm32.zuc.br
 delete mode 100644 tests/fixtures/zucchini/elf-arm64.zuc.br
 delete mode 100644 tests/fixtures/zucchini/elf-x86.zuc.br
 delete mode 100644 tests/fixtures/zucchini/elf.zuc.br
 delete mode 100644 tests/fixtures/zucchini/malformed-brotli.zuc.br
 delete mode 100644 tests/fixtures/zucchini/malformed-zucchini.zuc.br
 delete mode 100644 tests/fixtures/zucchini/noop.zuc.br

diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index 3e1e857..bdcb3f2 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -1,4 +1,6 @@
 use std::fs;
+#[cfg(otadump_zucchini)]
+use std::io::Write;
 use std::path::Path;
 use std::sync::atomic::{AtomicBool, Ordering};
 
@@ -148,8 +150,79 @@ const BROTLI_INVALID_HEADER_PATCH: &[u8] = &[
 ];
 
 const PUFFIN_FIXTURES: &str = "tests/fixtures/puffin";
+const LZ4_FIXTURES: &str = "tests/fixtures/lz4";
 const LZ4DIFF_FIXTURES: &str = "tests/fixtures/lz4diff";
 
+#[cfg(otadump_zucchini)]
+fn brotli_compress(bytes: &[u8]) -> Vec<u8> {
+    let mut compressed = Vec::new();
+    {
+        let mut writer = brotli::CompressorWriter::new(&mut compressed, 4096, 9, 20);
+        writer.write_all(bytes).unwrap();
+    }
+    compressed
+}
+
+#[cfg(otadump_zucchini)]
+fn zucchini_brotli_patch(name: &str) -> Vec<u8> {
+    let patch = fs::read(Path::new(ZUCCHINI_FIXTURES).join(format!("{name}.zuc"))).unwrap();
+    brotli_compress(&patch)
+}
+
+#[cfg(otadump_zucchini)]
+fn malformed_brotli_stream() -> Vec<u8> {
+    b"not a Brotli stream\n".to_vec()
+}
+
+#[cfg(otadump_zucchini)]
+fn malformed_inner_zucchini_patch() -> Vec<u8> {
+    brotli_compress(b"not a zucchini patch")
+}
+
+#[cfg(otadump_zucchini)]
+fn truncated_zucchini_patch(name: &str) -> Vec<u8> {
+    let mut patch = zucchini_brotli_patch(name);
+    patch.truncate(patch.len() - 1);
+    patch
+}
+
+fn lz4_reference(name: &str) -> Vec<u8> {
+    fs::read(Path::new(LZ4_FIXTURES).join(name)).unwrap()
+}
+
+fn lz4diff_fixture_case(name: &str) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
+    let patch = fs::read(Path::new(LZ4DIFF_FIXTURES).join(name).join("patch.lz4diff")).unwrap();
+    let (source, target) = match name {
+        "lz4-bsdiff" => {
+            let block = lz4_reference("lz4-no-postfix.lz4");
+            (block.clone(), block)
+        }
+        "lz4hc9-bsdiff" => {
+            let block = lz4_reference("lz4hc9-no-postfix.lz4");
+            (block.clone(), block)
+        }
+        "zero-padding-bsdiff" => {
+            let block = lz4_reference("zero-padding-layout.lz4");
+            (block.clone(), block)
+        }
+        "postfix-bsdiff" => {
+            let source = lz4_reference("lz4-no-postfix.lz4");
+            let mut target = source.clone();
+            target[23] ^= 0x5a;
+            (source, target)
+        }
+        "raw-puffdiff" => {
+            let fixtures = Path::new(LZ4DIFF_FIXTURES).join(name);
+            (
+                fs::read(fixtures.join("source.bin")).unwrap(),
+                fs::read(fixtures.join("target.bin")).unwrap(),
+            )
+        }
+        _ => panic!("unknown LZ4DIFF fixture {name}"),
+    };
+    (source, target, patch)
+}
+
 fn run_lz4diff_bytes(
     source: &[u8],
     target: &[u8],
@@ -202,10 +275,7 @@ fn run_lz4diff_bytes(
 }
 
 fn run_lz4diff_extraction(name: &str, operation_type: i32) -> Result<Vec<u8>, String> {
-    let fixtures = Path::new(LZ4DIFF_FIXTURES).join(name);
-    let source = fs::read(fixtures.join("source.bin")).unwrap();
-    let target = fs::read(fixtures.join("target.bin")).unwrap();
-    let patch = fs::read(fixtures.join("patch.lz4diff")).unwrap();
+    let (source, target, patch) = lz4diff_fixture_case(name);
     run_lz4diff_bytes(&source, &target, &patch, operation_type)
 }
 
@@ -233,7 +303,7 @@ fn lz4diff_operations_reconstruct_frozen_targets() {
         ("postfix-bsdiff", 12),
         ("raw-puffdiff", 13),
     ] {
-        let expected = fs::read(Path::new(LZ4DIFF_FIXTURES).join(name).join("target.bin")).unwrap();
+        let (_, expected, _) = lz4diff_fixture_case(name);
         let output = run_lz4diff_extraction(name, operation_type).unwrap();
         assert_eq!(output, expected, "fixture {name}");
     }
@@ -241,10 +311,7 @@ fn lz4diff_operations_reconstruct_frozen_targets() {
 
 #[test]
 fn malformed_lz4diff_data_fails_without_publication_or_process_failure() {
-    let fixtures = Path::new(LZ4DIFF_FIXTURES).join("postfix-bsdiff");
-    let source = fs::read(fixtures.join("source.bin")).unwrap();
-    let target = fs::read(fixtures.join("target.bin")).unwrap();
-    let valid = fs::read(fixtures.join("patch.lz4diff")).unwrap();
+    let (source, target, valid) = lz4diff_fixture_case("postfix-bsdiff");
 
     let mut bad_magic = valid.clone();
     bad_magic[0] = b'X';
@@ -489,8 +556,7 @@ fn malformed_puffdiff_zucchini_fails_without_publication_or_process_failure() {
     let source = puffin_fixture("deflates-sample1.bin");
     let target = puffin_fixture("deflates-sample2.bin");
     let valid_patch = puffin_fixture("patch-1-to-2-zucchini.puf");
-    let malformed_zucchini =
-        fs::read(Path::new("tests/fixtures/zucchini/malformed-zucchini.zuc.br")).unwrap();
+    let malformed_zucchini = malformed_inner_zucchini_patch();
 
     for (patch, expected_error) in [
         (
@@ -525,7 +591,7 @@ fn assert_zucchini_extraction(name: &str, extension: &str) {
     let fixtures = Path::new(ZUCCHINI_FIXTURES);
     let old = fs::read(fixtures.join(format!("{name}-old{extension}"))).unwrap();
     let target = fs::read(fixtures.join(format!("{name}-new{extension}"))).unwrap();
-    let patch = fs::read(fixtures.join(format!("{name}.zuc.br"))).unwrap();
+    let patch = zucchini_brotli_patch(name);
     let temporary = TempDir::new().unwrap();
     let source_dir = temporary.path().join("source");
     let output_dir = temporary.path().join("output");
@@ -585,8 +651,7 @@ fn assert_zucchini_extraction(name: &str, extension: &str) {
 }
 
 #[cfg(otadump_zucchini)]
-fn assert_zucchini_extraction_fails(patch_name: &str, expected_error: &str) {
-    let patch = fs::read(Path::new(ZUCCHINI_FIXTURES).join(patch_name)).unwrap();
+fn assert_zucchini_extraction_fails(patch: &[u8], expected_error: &str) {
     let temporary = TempDir::new().unwrap();
     let source_dir = temporary.path().join("source");
     let output_dir = temporary.path().join("output");
@@ -608,14 +673,14 @@ fn assert_zucchini_extraction_fails(patch_name: &str, expected_error: &str) {
                 src_length: Some(source.len() as u64),
                 dst_extents: vec![extent(0, source.len() as u64)],
                 dst_length: Some(source.len() as u64),
-                data_sha256_hash: Some(sha256(&patch)),
+                data_sha256_hash: Some(sha256(patch)),
                 src_sha256_hash: Some(sha256(source)),
             }],
             ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, &patch);
+    write_payload(&payload, manifest, patch);
 
     let error = ExtractOptions::new()
         .source_dir(&source_dir)
@@ -659,19 +724,16 @@ fn zucchini_operations_reconstruct_android_formats_exactly() {
 #[test]
 #[cfg(otadump_zucchini)]
 fn zucchini_operation_rejects_malformed_outer_brotli_without_publication() {
-    assert_zucchini_extraction_fails(
-        "malformed-brotli.zuc.br",
-        "Unable to decode ZUCCHINI Brotli patch",
-    );
+    for patch in [malformed_brotli_stream(), truncated_zucchini_patch("noop")] {
+        assert_zucchini_extraction_fails(&patch, "Unable to decode ZUCCHINI Brotli patch");
+    }
 }
 
 #[test]
 #[cfg(otadump_zucchini)]
 fn zucchini_operation_rejects_malformed_inner_patch_without_publication() {
-    assert_zucchini_extraction_fails(
-        "malformed-zucchini.zuc.br",
-        "ZUCCHINI apply failed: invalid ensemble patch",
-    );
+    let malformed = malformed_inner_zucchini_patch();
+    assert_zucchini_extraction_fails(&malformed, "ZUCCHINI apply failed: invalid ensemble patch");
 }
 
 #[test]
diff --git a/tests/fixtures/lz4diff/README.md b/tests/fixtures/lz4diff/README.md
index ef9bace..d6dbb09 100644
--- a/tests/fixtures/lz4diff/README.md
+++ b/tests/fixtures/lz4diff/README.md
@@ -1,7 +1,9 @@
 # Frozen LZ4DIFF operation fixtures
 
 These static fixtures exercise complete version-1 `LZ4DIFF` operation data.
-Each case contains the physical source bytes, the independently frozen physical target bytes, and the complete container patch.
+Each case keeps its complete container patch. Tests deterministically build the
+small physical source/target blocks from canonical fixtures when those bytes are
+derivable from pinned upstream references.
 
 The LZ4, LZ4HC9, and zero-padding source and target bytes come unchanged from the Milestone 6a reference proof.
 That proof pins AOSP `platform/external/lz4` commit `734e07032602e9a72fcc9701028b0aee45147fcd` and `platform/system/update_engine` commit `dc84c2552b2d4cf00d2a843cb1c091d99d0499f1`.
@@ -23,4 +25,5 @@ The extractor does not generate expected target bytes.
 
 The LZ4-derived bytes retain the BSD-2-Clause license in `LICENSE.lz4`.
 The Puffin-derived bytes retain the BSD-3-Clause license in `LICENSE.puffin`.
-Run `sha256sum -c SHA256SUMS` from this directory to verify every frozen file.
+Run `sha256sum -c SHA256SUMS` from this directory to verify every retained
+frozen file.
diff --git a/tests/fixtures/lz4diff/SHA256SUMS b/tests/fixtures/lz4diff/SHA256SUMS
index b9b674a..86bda4f 100644
--- a/tests/fixtures/lz4diff/SHA256SUMS
+++ b/tests/fixtures/lz4diff/SHA256SUMS
@@ -1,15 +1,7 @@
 4cd1380f674ea78e86276bc9ce39ab88b45bbbccb96c611e18bdd7108c738cfa  lz4-bsdiff/patch.lz4diff
-6ea395fcef53c8e4de2fc708f4c8e1db7de05b53e48a891c77cbebee4e914e65  lz4-bsdiff/source.bin
-6ea395fcef53c8e4de2fc708f4c8e1db7de05b53e48a891c77cbebee4e914e65  lz4-bsdiff/target.bin
 43efe58bdcd3552ffcda9608aa72a9f8189984af9cecd3143d468021e3b54c2d  lz4hc9-bsdiff/patch.lz4diff
-12a28b1f3d4cc5f8b0bfa534f062abae2b9bdbcd886fa2d657cf81e10b2e273e  lz4hc9-bsdiff/source.bin
-12a28b1f3d4cc5f8b0bfa534f062abae2b9bdbcd886fa2d657cf81e10b2e273e  lz4hc9-bsdiff/target.bin
 08fe5ecea8e3f48ec17665d50807516d63b17dcb729baa540566679a261228d4  postfix-bsdiff/patch.lz4diff
-6ea395fcef53c8e4de2fc708f4c8e1db7de05b53e48a891c77cbebee4e914e65  postfix-bsdiff/source.bin
-061f6d1ae1218e7280373e8f0d6791836ef1a6c4c1ffcc8f5beedef56c4f20b7  postfix-bsdiff/target.bin
 4b9ce7db27ac550c6d7fd1e7f18a535c3a4616c8702fe9655a1d10839c681846  raw-puffdiff/patch.lz4diff
 de0527c0d2d27f378cb79aec447172e0efcfff9cc45d0be05c313a87a2069280  raw-puffdiff/source.bin
 649b17ae72a6d503a1176604d876923270cd467ae1d458a54e58575eda98766e  raw-puffdiff/target.bin
 3c5f3a2fa1bbf4dd938eb05dfb76cf53d4a95b70cb06e35faed6c560a7077260  zero-padding-bsdiff/patch.lz4diff
-1e5b41d7f2e7c5d541a65b683be0c357da12241a036509853962e8888e900c87  zero-padding-bsdiff/source.bin
-1e5b41d7f2e7c5d541a65b683be0c357da12241a036509853962e8888e900c87  zero-padding-bsdiff/target.bin
diff --git a/tests/fixtures/lz4diff/lz4-bsdiff/source.bin b/tests/fixtures/lz4diff/lz4-bsdiff/source.bin
deleted file mode 100644
index c635da170bdc86177413483ad902b18646ae61cf..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 768
zcmew_k(a7#mZ<9!WulvsT9R6no0*qcT#}iro0eHoQd*R%@0*#ET3nK^&LHuA;=0o>
zSe5K!DyMC}@RrMuL6?6H1H=2i)hC`Z$=gJhP2O<!75f|pDSkf&2L4w-neG)wAN`lH
z3@e_n_SAD0K}J2kQik^(OAp=uBWV^~(7WpR6UKN(X+A#&{<Vw@?^_q`zw=YfI3Txc
z`H_eJt}yEJ0#!H7-*fYuuz_z@`;vqAek(D_@B&r00ae$}*?H}=fUZ}1%ffxPe@tgG
z-~p<xnYr!q2VO1rl*W0xZ+v~qB+CO)&BVamukMmqH+#p`Pf^T<+@%a45f#U{>KR)v
Sy<fpBmjDR?hEXuWLI3~)c5lD{

diff --git a/tests/fixtures/lz4diff/lz4-bsdiff/target.bin b/tests/fixtures/lz4diff/lz4-bsdiff/target.bin
deleted file mode 100644
index c635da170bdc86177413483ad902b18646ae61cf..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 768
zcmew_k(a7#mZ<9!WulvsT9R6no0*qcT#}iro0eHoQd*R%@0*#ET3nK^&LHuA;=0o>
zSe5K!DyMC}@RrMuL6?6H1H=2i)hC`Z$=gJhP2O<!75f|pDSkf&2L4w-neG)wAN`lH
z3@e_n_SAD0K}J2kQik^(OAp=uBWV^~(7WpR6UKN(X+A#&{<Vw@?^_q`zw=YfI3Txc
z`H_eJt}yEJ0#!H7-*fYuuz_z@`;vqAek(D_@B&r00ae$}*?H}=fUZ}1%ffxPe@tgG
z-~p<xnYr!q2VO1rl*W0xZ+v~qB+CO)&BVamukMmqH+#p`Pf^T<+@%a45f#U{>KR)v
Sy<fpBmjDR?hEXuWLI3~)c5lD{

diff --git a/tests/fixtures/lz4diff/lz4hc9-bsdiff/source.bin b/tests/fixtures/lz4diff/lz4hc9-bsdiff/source.bin
deleted file mode 100644
index 6c24b45279e4b9fbe194b34726148821e3c52d04..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1152
zcmew_5oMyAl3J2ll$)8CSzMBtteciuQBqozs_&bblUiJopO>m@mZ<Ba&LIAN_l>VY
z`aYR$ix1rWC2r!!pv$k$!0>Lz)ld97o@vbs_TKs~V(7=ff0#k<Kf~5b?|C%ck{jmk
zy8cB_Pxml`{eOl{=ihLuIVaT4+J5CDpSBrTZ2g&+Y|0L?Rnxaze8;Vk3>I5+@)@&&
zZB+S`jptr-s6zCvJocDD)+)SY;=0o>Sd}ut>XsdT@K?$_q_A)GiKk5RsX#F%2Il#J
zdEG0HKKd_H0_FQ<cPu@0|BqxIl<%F<x@iBMpJK&OzDH`){5?0n3Fkxku1WQCc3%4|
t0I~yQo>P3y%x#xH@WRZqkExut`NCT+pm|mS;4ott1*0J_8Uo~m005r}iYEX7

diff --git a/tests/fixtures/lz4diff/lz4hc9-bsdiff/target.bin b/tests/fixtures/lz4diff/lz4hc9-bsdiff/target.bin
deleted file mode 100644
index 6c24b45279e4b9fbe194b34726148821e3c52d04..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1152
zcmew_5oMyAl3J2ll$)8CSzMBtteciuQBqozs_&bblUiJopO>m@mZ<Ba&LIAN_l>VY
z`aYR$ix1rWC2r!!pv$k$!0>Lz)ld97o@vbs_TKs~V(7=ff0#k<Kf~5b?|C%ck{jmk
zy8cB_Pxml`{eOl{=ihLuIVaT4+J5CDpSBrTZ2g&+Y|0L?Rnxaze8;Vk3>I5+@)@&&
zZB+S`jptr-s6zCvJocDD)+)SY;=0o>Sd}ut>XsdT@K?$_q_A)GiKk5RsX#F%2Il#J
zdEG0HKKd_H0_FQ<cPu@0|BqxIl<%F<x@iBMpJK&OzDH`){5?0n3Fkxku1WQCc3%4|
t0I~yQo>P3y%x#xH@WRZqkExut`NCT+pm|mS;4ott1*0J_8Uo~m005r}iYEX7

diff --git a/tests/fixtures/lz4diff/postfix-bsdiff/source.bin b/tests/fixtures/lz4diff/postfix-bsdiff/source.bin
deleted file mode 100644
index c635da170bdc86177413483ad902b18646ae61cf..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 768
zcmew_k(a7#mZ<9!WulvsT9R6no0*qcT#}iro0eHoQd*R%@0*#ET3nK^&LHuA;=0o>
zSe5K!DyMC}@RrMuL6?6H1H=2i)hC`Z$=gJhP2O<!75f|pDSkf&2L4w-neG)wAN`lH
z3@e_n_SAD0K}J2kQik^(OAp=uBWV^~(7WpR6UKN(X+A#&{<Vw@?^_q`zw=YfI3Txc
z`H_eJt}yEJ0#!H7-*fYuuz_z@`;vqAek(D_@B&r00ae$}*?H}=fUZ}1%ffxPe@tgG
z-~p<xnYr!q2VO1rl*W0xZ+v~qB+CO)&BVamukMmqH+#p`Pf^T<+@%a45f#U{>KR)v
Sy<fpBmjDR?hEXuWLI3~)c5lD{

diff --git a/tests/fixtures/lz4diff/postfix-bsdiff/target.bin b/tests/fixtures/lz4diff/postfix-bsdiff/target.bin
deleted file mode 100644
index 8f0e10814e164cc4e087dc31b44d8e3a5977b40b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 768
zcmew_k(a7#mZ<9!WulvsT9R6no0*qcTw<K8o0eHoQd*R%@0*#ET3nK^&LHuA;=0o>
zSe5K!DyMC}@RrMuL6?6H1H=2i)hC`Z$=gJhP2O<!75f|pDSkf&2L4w-neG)wAN`lH
z3@e_n_SAD0K}J2kQik^(OAp=uBWV^~(7WpR6UKN(X+A#&{<Vw@?^_q`zw=YfI3Txc
z`H_eJt}yEJ0#!H7-*fYuuz_z@`;vqAek(D_@B&r00ae$}*?H}=fUZ}1%ffxPe@tgG
z-~p<xnYr!q2VO1rl*W0xZ+v~qB+CO)&BVamukMmqH+#p`Pf^T<+@%a45f#U{>KR)v
Sy<fpBmjDR?hEXuWLI40|L2rrx

diff --git a/tests/fixtures/lz4diff/zero-padding-bsdiff/source.bin b/tests/fixtures/lz4diff/zero-padding-bsdiff/source.bin
deleted file mode 100644
index 8185bd833dcc04217a9fbcaba60b9fb963e79db8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 608
zcmXTQ&CJUzF3C*RP0Oq(DJ@FX_sz^nEiTE=OVu??)b(K)1=I_HuM$xvx+$q8sYL`r
zU7g|mQzm(v$g;^B&c0$-ag0-EVB_~=5aCy6V0i!Nzl>#A@r1Rfp0g<0MbBZ70?IJ(
z9|p?Y|08J@T+qAf_!CAs>xfqj>_8b|ehWs1_ji7Z83*KcEkE+`pR`42Jfk#!DTC1a
zo8N>De6!k@9K82i!Zc_tBL`5u5ZI1up9OTi(pwhpyZuAd$X|&`2B==}{pAn5TJ9;0
u^LF3(Dx~jIz{CkuFUa4<$nf;STP}5%#Jbr#u72Xz@!ZG6>BkTNPD=pD31yi8

diff --git a/tests/fixtures/lz4diff/zero-padding-bsdiff/target.bin b/tests/fixtures/lz4diff/zero-padding-bsdiff/target.bin
deleted file mode 100644
index 8185bd833dcc04217a9fbcaba60b9fb963e79db8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 608
zcmXTQ&CJUzF3C*RP0Oq(DJ@FX_sz^nEiTE=OVu??)b(K)1=I_HuM$xvx+$q8sYL`r
zU7g|mQzm(v$g;^B&c0$-ag0-EVB_~=5aCy6V0i!Nzl>#A@r1Rfp0g<0MbBZ70?IJ(
z9|p?Y|08J@T+qAf_!CAs>xfqj>_8b|ehWs1_ji7Z83*KcEkE+`pR`42Jfk#!DTC1a
zo8N>De6!k@9K82i!Zc_tBL`5u5ZI1up9OTi(pwhpyZuAd$X|&`2B==}{pAn5TJ9;0
u^LF3(Dx~jIz{CkuFUa4<$nf;STP}5%#Jbr#u72Xz@!ZG6>BkTNPD=pD31yi8

diff --git a/tests/fixtures/zucchini/README.md b/tests/fixtures/zucchini/README.md
index 65b768f..439b58b 100644
--- a/tests/fixtures/zucchini/README.md
+++ b/tests/fixtures/zucchini/README.md
@@ -21,15 +21,17 @@ The target changes one same-length string while preserving both code references.
 This resolves the 16-bit writer to the existing jumbo target at index 65,536 and must fail in preflight.
 The expected bytes are stored independently and are not constructed by the adapter tests.
 
-The `*.zuc.br` files wrap the matching serialized patches with Brotli.
-They were created offline with the independent Brotli 1.2.0 command-line compressor:
+Integration tests wrap canonical `*.zuc` patches with Brotli at runtime.
+They use quality 9 and lgwin 20 to match the original fixture-generation settings:
 
 ```sh
 brotli --quality=9 --lgwin=20 --stdout input.zuc > input.zuc.br
 ```
 
-`malformed-zucchini.zuc.br` is the same Brotli encoding of the ASCII bytes `not a zucchini patch`.
-`malformed-brotli.zuc.br` contains the ASCII bytes `not a Brotli stream` followed by a newline and is intentionally not a Brotli stream.
+Malformed wrapper cases are synthesized in test code from two deterministic inputs:
+
+- raw bytes `not a Brotli stream\n` (intentionally not Brotli), and
+- Brotli-compressed bytes of `not a zucchini patch` (valid Brotli, invalid inner patch).
 
 ## Realistic DEX differential fixture
 
diff --git a/tests/fixtures/zucchini/SHA256SUMS b/tests/fixtures/zucchini/SHA256SUMS
index e65d434..5dfdc11 100644
--- a/tests/fixtures/zucchini/SHA256SUMS
+++ b/tests/fixtures/zucchini/SHA256SUMS
@@ -8,26 +8,18 @@ fef404d99db5d6e9570f6673a78a5a4d4dcf23616648812debd66d65947b5afc  dex-large.zuc
 63e76d95aaaa6bdcedf79b2a8f3b55736fb5e9899e021a6be5190fba2d820080  dex-new.dex
 3b06060663ae19133d71d72a1f3b40d9bf4716fb4d6fc83d7ae039d01e80e945  dex-old.dex
 88f7512d4fb07ef897804d370ab1db699104c8b72be3be36e29adb5970fed8d5  dex.zuc
-91dd18f228539cc9fa8b6094a503c58f2a0ed4ffd038e8a0efea9ddd3859e3e8  dex.zuc.br
 2664d1c48bf0a2a2e7b3f8b1a9bd38e08055580adf42f2d53ef6abd7dcc65f30  elf-arm32-new
 a5a51e66fb5f923113eeb1f5df5c020c715df6a16d691c5a6030e36d920c625c  elf-arm32-old
 852f01e48651fbcd093f6eb2f075fc59feb470413e79e6f9ddc16b9f2cdcec4c  elf-arm32.zuc
-5d22c4011510d42f2db22958ab8fef24df44130806c5c873b77dcb872d798358  elf-arm32.zuc.br
 5125780242c5b230291ba47102734e422e09255e66e6b711a0657aca8098b8b6  elf-arm64-new
 d101a04d15a4b975f01d179fbf8b98771acdb31edb71dca4d8de40fa88189ecb  elf-arm64-old
 0b6c484b0b8cfc2c22ff0257a1e3677e36948bb2f8062a099e88fa4cc4ddf9d7  elf-arm64.zuc
-d60e4cf4ebcc47178e4f299d04ed7ea4dceb485d2fe2b05b2ef4de3458ca0b2d  elf-arm64.zuc.br
 1e2080509d361c7e87f3434a3ed2f7a9be1b6972fcfb48fb531f0311e5820d7c  elf-new
 32ae88b0151c4afff7b9a88524a554ce517055257ebdd17329fb23fefde75c55  elf-old
 9d5187d155ff0acbb22118ade13032b20d6efc1ebfaf95c970e83d8d2f33b9cd  elf-x86-new
 7eb3c69419c3221a489fa0ba12bfeb94d258f14212a8e108ee130a31c83dda3b  elf-x86-old
 3bd7d0fc9454f38707d6af56ba9d1382d8a700e7dbda0f4955dcffc748b93915  elf-x86.zuc
-05230ea7dc74f03cd8e5c5bb39c79bea750d0f61de56ae32070f88025c607c43  elf-x86.zuc.br
 7015ce4ab2589a48815f734366f01fa9c7553f06480274fd43e9ed85311afeaa  elf.zuc
-fc8ad67255a38ea5153b7e020ef279e80a07235f69710712eeac82587bcf6f5e  elf.zuc.br
-fd4675a50b0ebdbff64c2f7dfa62fb8d33aaea4cea5358ffb004d3e25634ae8f  malformed-brotli.zuc.br
-2c02a903730016cd9cd79728af16068da480c0770ca55c8d9a82037d5da698a0  malformed-zucchini.zuc.br
 ff55ebfb1b1889f3d0544b00dfabed96de8e4e4234e857043dba47a7a210d019  noop-new.bin
 88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589  noop-old.bin
 dec6c4f3e44a1ae18c48efb1c25e59288ecaad04997b8668ce2de0abcf3342d9  noop.zuc
-d58e45c97d88ea4f5836c687fa15c668c4df5655d445eeca6867d0526a750a70  noop.zuc.br
diff --git a/tests/fixtures/zucchini/dex.zuc.br b/tests/fixtures/zucchini/dex.zuc.br
deleted file mode 100644
index a8e52517c24916a74fd6df2049757f7b1f7c889e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 146
zcmV;D0B!#l-T(l^hrj0gx4vr~eP0DPXlj%f4S3T?iV_+{*=$rnBgmbfP(b``wY3EW
z)WX0bjxD#-Y%{hy--%)}NdVM*n-DzaHr5a3eFs-;g~Bn4h~}$78KfUW@tsOnSi8%E
zi1}Pt%%7rnulz6Eu-h19miJS2bUjx@_#z5gCGy8mOsEEG8d^Gf1}qLwAd-#@09Bbm
Ar~m)}

diff --git a/tests/fixtures/zucchini/elf-arm32.zuc.br b/tests/fixtures/zucchini/elf-arm32.zuc.br
deleted file mode 100644
index 7c2709b8b4cd3e8e9e580e9ccef7fe396859b182..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 72
zcmV-O0Jr}aW&i-ha(90(@>}z~fPye?OJCE7i{Ek^8~dvS1>JUdUhCy{ifo>(zw5XQ
e0F&eXNar-B-?#<0w_3npCGj6I&_ng~h^;mSU?nC1

diff --git a/tests/fixtures/zucchini/elf-arm64.zuc.br b/tests/fixtures/zucchini/elf-arm64.zuc.br
deleted file mode 100644
index 19c4fbb3f82e8625d39dca9207c893e0823d9e28..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 74
zcmV-Q0JZ-YX8-^M{&V;40!uh-c@R*Re&D=$KyA%q%57}yuhIx2XsqzO&dco-$s41;
gV@d`rImL6!U$5uIEx4_g44RYfA6V%2RFBYX11V`G9smFU

diff --git a/tests/fixtures/zucchini/elf-x86.zuc.br b/tests/fixtures/zucchini/elf-x86.zuc.br
deleted file mode 100644
index 0fa377813edba5d096c3090fdcda9ed4ca3626d1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 73
zcmV-P0Ji@ZW&i-hZ1?+#jHnAF?YwY0?Mg80B1t{Bv9Z5OP|$6M=e1sLr^x2n`rC%P
f05Ey~9_jk-^c%O}mX#A2tR(&+270KT9<fybg0m(l

diff --git a/tests/fixtures/zucchini/elf.zuc.br b/tests/fixtures/zucchini/elf.zuc.br
deleted file mode 100644
index 632ef91d2b85c8ae6848c0362696d6cc3a2e2359..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 91
zcmV-h0HpsHZvX&f>gI3z4Ke}$!fXMjPYqolAqSdB;zhZQZO?10FBAlwpdU8Y$!&=0
x;}@}?VJ!s$0D1#0qkls6%-?x|ookz;%A{EU^_@B}JKY6A4*s7#8VpjrBmm>%CSm{p

diff --git a/tests/fixtures/zucchini/malformed-brotli.zuc.br b/tests/fixtures/zucchini/malformed-brotli.zuc.br
deleted file mode 100644
index d41f431..0000000
--- a/tests/fixtures/zucchini/malformed-brotli.zuc.br
+++ /dev/null
@@ -1 +0,0 @@
-not a Brotli stream
diff --git a/tests/fixtures/zucchini/malformed-zucchini.zuc.br b/tests/fixtures/zucchini/malformed-zucchini.zuc.br
deleted file mode 100644
index b16e974..0000000
--- a/tests/fixtures/zucchini/malformed-zucchini.zuc.br
+++ /dev/null
@@ -1 +0,0 @@
-‡	€not a zucchini patch
\ No newline at end of file
diff --git a/tests/fixtures/zucchini/noop.zuc.br b/tests/fixtures/zucchini/noop.zuc.br
deleted file mode 100644
index 9477010179a4633daacba607a83db298cad15122..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 78
zcmV-U0I~lUR{#JUsZn3d?!Y0p15g5=mjp7ow*``>&^%8)!ayQSYk-0XK~R(P6ME5H
kKWJ-vkt~m~EW?pV%`1Su?We9M@55#@6wR6wPzuRk7UZ5GQ~&?~


From faf0f66c152a7eae87a95cd04c7150584fb93a49 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 21:20:51 +0530
Subject: [PATCH 37/42] chore: trim stale build/docs and dead zucchini keepers

Signed-off-by: Akhil Narang <me@akhilnarang.dev>
---
 .github/workflows/release.yaml | 16 ----------------
 README.md                      |  7 +++----
 docs/zucchini-rust-port.md     |  5 ++---
 src/zucchini_pure/dex.rs       |  3 +--
 src/zucchini_pure/elf.rs       | 14 ++------------
 src/zucchini_pure/engine.rs    |  8 --------
 6 files changed, 8 insertions(+), 45 deletions(-)

diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 44fa5bb..4a9de04 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -70,16 +70,6 @@ jobs:
         with:
           key: ${{ matrix.target }}
 
-      - name: Install build deps (macOS)
-        if: runner.os == 'macOS'
-        run: brew install protobuf
-
-      - name: Install build deps (Linux)
-        if: runner.os == 'Linux'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y protobuf-compiler
-
       - name: Install zig
         if: runner.os == 'Linux' && !contains(matrix.target, 'android')
         uses: mlugg/setup-zig@v2
@@ -103,12 +93,6 @@ jobs:
           ndk-version: r23
           local-cache: true
 
-      - name: Install protoc (Windows)
-        if: runner.os == 'Windows'
-        uses: arduino/setup-protoc@v1
-        with:
-          version: "3.x"
-
       - name: Build binary (Linux)
         if: runner.os == 'Linux' && !contains(matrix.target, 'android')
         run: |
diff --git a/README.md b/README.md
index b741767..a1fd6fb 100644
--- a/README.md
+++ b/README.md
@@ -59,9 +59,9 @@ curl -sS https://raw.githubusercontent.com/crazystylus/otadump/mainline/install.
 Otherwise, using Cargo:
 
 ```sh
-# Needs LZMA, Protobuf and pkg-config libraries installed.
-# - On macOS: brew install protobuf xz pkg-config
-# - On Debian / Ubuntu: apt install liblzma-dev protobuf-compiler pkg-config
+# Needs LZMA and pkg-config libraries installed.
+# - On macOS: brew install xz pkg-config
+# - On Debian / Ubuntu: apt install liblzma-dev pkg-config
 cargo install --locked otadump
 ```
 
@@ -84,7 +84,6 @@ otadump payload.bin
 # Apply a SOURCE_COPY, SOURCE_BSDIFF, BROTLI_BSDIFF, PUFFDIFF (inner BSDIFF or
 # ZUCCHINI), standalone ZUCCHINI, or LZ4DIFF (inner BSDIFF or PUFFDIFF) delta
 # payload with matching base images.
-# ZUCCHINI requires Linux x86-64 GNU.
 otadump delta.zip --output-dir output --source-dir source-images
 ```
 
diff --git a/docs/zucchini-rust-port.md b/docs/zucchini-rust-port.md
index b0de882..f40e3fa 100644
--- a/docs/zucchini-rust-port.md
+++ b/docs/zucchini-rust-port.md
@@ -1,8 +1,7 @@
 # Pure-Rust Zucchini apply port
 
 Status: implemented and verified byte-exact against every committed Zucchini
-fixture. This is now the only apply path; the vendored C++/libchrome build is
-opt-in for differential testing.
+fixture. This is now the only apply path.
 Scope: **apply only**, Android delta OTA element formats (`NoOp`, ELF
 x86/x86-64/AArch32/AArch64, DEX).
 
@@ -25,7 +24,7 @@ all of that surface was unnecessary. The apply path is now safe Rust under
 | ELF parse, address translation, reloc/abs32, Intel + ARM rel32 finders | `disassembler_elf.cc`, `address_translator.cc`, `reloc_elf.cc`, `abs32_utils.cc`, `rel32_utils.cc`, `rel32_finder.cc` | `elf.rs` |
 | AArch32/AArch64 and THUMB2 instruction codecs | `arm_utils.cc` | `arm.rs` |
 | DEX header/map/code-item/item-list parsing and all 42 reference groups | `disassembler_dex.cc`, `type_dex.h` | `dex.rs` |
-| Android preflight hardening | `native/zucchini/src/zucchini_ffi.cc` | `engine.rs` |
+| Android preflight hardening | legacy native FFI preflight behavior | `engine.rs` |
 | Little-endian helpers and bit fields | `buffer_view.h`, `algorithm.h` | `bytes.rs` |
 
 `Disassembler` (in `mod.rs`) is the only abstraction the engine needs: size,
diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
index 27bdc2f..071b400 100644
--- a/src/zucchini_pure/dex.rs
+++ b/src/zucchini_pure/dex.rs
@@ -421,11 +421,10 @@ fn parse_annotations_directory_items(
             return None;
         }
         directory_offsets.push(pos as u32);
-        let class_annotations_off = read_u32(image, pos)?;
+        let _class_annotations_off = read_u32(image, pos)?;
         let fields_size = read_u32(image, pos + 4)?;
         let methods_size = read_u32(image, pos + 8)?;
         let parameters_size = read_u32(image, pos + 12)?;
-        let _ = class_annotations_off;
         pos += 16;
         parse_list(&mut pos, fields_size, 8, &mut field_offsets)?;
         parse_list(&mut pos, methods_size, 8, &mut method_offsets)?;
diff --git a/src/zucchini_pure/elf.rs b/src/zucchini_pure/elf.rs
index ba0c9fa..7aff2be 100644
--- a/src/zucchini_pure/elf.rs
+++ b/src/zucchini_pure/elf.rs
@@ -4,11 +4,9 @@
 use super::arm;
 use super::bytes::{
     align_ceil, increment_for_align_ceil2, increment_for_align_ceil4, range_covers,
-    range_is_bounded, read_i32, read_u16, read_u32, read_u64, write_u16, write_u32, write_u64,
-};
-use super::{
-    Disassembler, GroupTraits, K_INVALID_OFFSET, K_INVALID_RVA, OFFSET_BOUND, Reference, Result,
+    range_is_bounded, read_i32, read_u16, read_u32, read_u64, write_u32, write_u64,
 };
+use super::{Disassembler, GroupTraits, K_INVALID_RVA, Reference, Result};
 
 const K_RVA_BOUND: u32 = 0x7FFF_FFFF;
 const K_SIZE_BOUND: u64 = 0x7FFF_0000;
@@ -1272,14 +1270,6 @@ fn write_aarch64(
     }
 }
 
-#[allow(dead_code)]
-fn _keep_helpers() {
-    let _ = write_u16;
-    let _ = range_is_bounded;
-    let _ = K_INVALID_OFFSET;
-    let _ = OFFSET_BOUND;
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/zucchini_pure/engine.rs b/src/zucchini_pure/engine.rs
index 3c4de71..3e188a5 100644
--- a/src/zucchini_pure/engine.rs
+++ b/src/zucchini_pure/engine.rs
@@ -3,7 +3,6 @@
 
 use std::collections::BTreeMap;
 
-use super::bytes::{range_covers, range_is_bounded};
 use super::dex;
 use super::patch::{
     EXE_TYPE_DEX, EXE_TYPE_ELF_AARCH32, EXE_TYPE_ELF_AARCH64, EXE_TYPE_ELF_X64, EXE_TYPE_ELF_X86,
@@ -900,13 +899,6 @@ impl TargetPool {
     }
 }
 
-/// Keeps the range helpers referenced for later DEX validation code.
-#[allow(dead_code)]
-fn _range_helpers() {
-    let _ = range_covers;
-    let _ = range_is_bounded;
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

From bb45b2c0e9fcfb7e658034386e64bfea621824a1 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 22:24:12 +0530
Subject: [PATCH 38/42] zucchini: switch to pinned native artifact fetch

Signed-off-by: Akhil Narang <me@akhilnarang.dev>
---
 build.rs                                  |   71 +
 native/zucchini/ARTIFACT_BUNDLE_LOCK.json |    7 +
 native/zucchini/ARTIFACT_LOCK.sha256      |    4 +
 scripts/fetch-native-artifact.py          |  135 ++
 src/lib.rs                                |    1 -
 src/zucchini.rs                           |  128 +-
 src/zucchini_pure/arm.rs                  |  497 -------
 src/zucchini_pure/bytes.rs                |  100 --
 src/zucchini_pure/crc32.rs                |   70 -
 src/zucchini_pure/dex.rs                  | 1456 ---------------------
 src/zucchini_pure/elf.rs                  | 1324 -------------------
 src/zucchini_pure/engine.rs               | 1061 ---------------
 src/zucchini_pure/mod.rs                  |  244 ----
 src/zucchini_pure/patch.rs                |  508 -------
 tests/zucchini_pure.rs                    |  271 ----
 15 files changed, 338 insertions(+), 5539 deletions(-)
 create mode 100644 native/zucchini/ARTIFACT_BUNDLE_LOCK.json
 create mode 100644 native/zucchini/ARTIFACT_LOCK.sha256
 create mode 100755 scripts/fetch-native-artifact.py
 delete mode 100644 src/zucchini_pure/arm.rs
 delete mode 100644 src/zucchini_pure/bytes.rs
 delete mode 100644 src/zucchini_pure/crc32.rs
 delete mode 100644 src/zucchini_pure/dex.rs
 delete mode 100644 src/zucchini_pure/elf.rs
 delete mode 100644 src/zucchini_pure/engine.rs
 delete mode 100644 src/zucchini_pure/mod.rs
 delete mode 100644 src/zucchini_pure/patch.rs
 delete mode 100644 tests/zucchini_pure.rs

diff --git a/build.rs b/build.rs
index 153312d..edd5a24 100644
--- a/build.rs
+++ b/build.rs
@@ -1,6 +1,77 @@
 fn main() {
     println!("cargo:rustc-check-cfg=cfg(otadump_zucchini)");
     println!("cargo:rerun-if-changed=src/protos/chromeos_update_engine/update_metadata.proto");
+    println!("cargo:rerun-if-changed=native/zucchini/ARTIFACT_BUNDLE_LOCK.json");
+    println!("cargo:rerun-if-changed=native/zucchini/ARTIFACT_LOCK.sha256");
+    println!("cargo:rerun-if-changed=scripts/fetch-native-artifact.py");
+
+    println!("cargo:rerun-if-env-changed=OTADUMP_NATIVE_DIR");
+    println!("cargo:rerun-if-env-changed=OTADUMP_NATIVE_OFFLINE");
+    println!("cargo:rerun-if-env-changed=OTADUMP_NATIVE_CACHE");
+    println!("cargo:rerun-if-env-changed=OTADUMP_NATIVE_PRESEED");
+    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("linux")
+        && std::env::var("CARGO_CFG_TARGET_ARCH").as_deref() == Ok("x86_64")
+        && std::env::var("CARGO_CFG_TARGET_ENV").as_deref() == Ok("gnu")
+    {
+        let manifest_dir = std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap());
+        let bundle_lock = manifest_dir.join("native/zucchini/ARTIFACT_BUNDLE_LOCK.json");
+        let checksum_lock = manifest_dir.join("native/zucchini/ARTIFACT_LOCK.sha256");
+        let root = if let Some(path) = std::env::var_os("OTADUMP_NATIVE_DIR") {
+            std::path::PathBuf::from(path)
+        } else {
+            let out = std::path::PathBuf::from(std::env::var_os("OUT_DIR").unwrap());
+            let artifact = out.join("otadump-native/linux-x86_64-gnu");
+            let cache = std::env::var_os("OTADUMP_NATIVE_CACHE")
+                .map(std::path::PathBuf::from)
+                .unwrap_or_else(|| out.join("cache/otadump-native"));
+            let mut command = std::process::Command::new("python3");
+            command
+                .arg(manifest_dir.join("scripts/fetch-native-artifact.py"))
+                .arg("--bundle-lock")
+                .arg(&bundle_lock)
+                .arg("--checksum-lock")
+                .arg(&checksum_lock)
+                .arg("--out")
+                .arg(&artifact)
+                .arg("--cache")
+                .arg(cache);
+            let status = command.status().expect("unable to run native artifact fetch helper");
+            assert!(status.success(), "native artifact fetch helper failed");
+            artifact
+        };
+        let include = root.join("include");
+        let archive = root.join("lib/libotadump_zucchini.a");
+        assert!(
+            include.join("zucchini_ffi.h").is_file(),
+            "missing Zucchini artifact header: {}",
+            include.display()
+        );
+        assert!(archive.is_file(), "missing Zucchini artifact archive: {}", archive.display());
+        let status = std::process::Command::new("sha256sum")
+            .arg("-c")
+            .arg(&checksum_lock)
+            .current_dir(&root)
+            .status()
+            .expect("unable to verify Zucchini artifact checksum lock");
+        assert!(
+            status.success(),
+            "Zucchini artifact checksum lock failed: {}",
+            checksum_lock.display()
+        );
+        println!("cargo:rustc-link-search=native={}", root.join("lib").display());
+        println!("cargo:rustc-link-lib=static=otadump_zucchini");
+        let cxx_archive = std::process::Command::new("g++")
+            .args(["-print-file-name=libstdc++.a"])
+            .output()
+            .expect("unable to locate the C++ runtime")
+            .stdout;
+        let cxx_archive = std::path::PathBuf::from(String::from_utf8(cxx_archive).unwrap().trim());
+        assert!(cxx_archive.is_file(), "static libstdc++ is required: {}", cxx_archive.display());
+        println!("cargo:rustc-link-search=native={}", cxx_archive.parent().unwrap().display());
+        println!("cargo:rustc-link-lib=static=stdc++");
+        println!("cargo:rustc-link-arg=-static-libgcc");
+        println!("cargo:rustc-cfg=otadump_zucchini");
+    }
 
     let protoc = protoc_bin_vendored::protoc_bin_path().expect("unable to find vendored protoc");
     let mut config = prost_build::Config::new();
diff --git a/native/zucchini/ARTIFACT_BUNDLE_LOCK.json b/native/zucchini/ARTIFACT_BUNDLE_LOCK.json
new file mode 100644
index 0000000..5daebd7
--- /dev/null
+++ b/native/zucchini/ARTIFACT_BUNDLE_LOCK.json
@@ -0,0 +1,7 @@
+{
+  "schema": 1,
+  "commit": "9534f6e24296b1682d53cdac19da0b81fc97fcbc",
+  "url": "https://raw.githubusercontent.com/AndroidDumps/otadump/9534f6e24296b1682d53cdac19da0b81fc97fcbc/native/artifacts/zucchini/zucchini-linux-x86_64-gnu.tar.gz",
+  "sha256": "70655ef27c2327291071590ee726f13cde1abd6f9ed0c3c4dae32103834ef16f",
+  "extract_root": "linux-x86_64-gnu"
+}
diff --git a/native/zucchini/ARTIFACT_LOCK.sha256 b/native/zucchini/ARTIFACT_LOCK.sha256
new file mode 100644
index 0000000..cea32a8
--- /dev/null
+++ b/native/zucchini/ARTIFACT_LOCK.sha256
@@ -0,0 +1,4 @@
+2f7138dd9ff6b0d4cb081536b3a8a16cb5c3ff09ee96d73f6351e8cae0d6a99c  lib/libotadump_zucchini.a
+11696b3b8d3dc920e2375d98fd95028cd32c6c1ea86b082d6f800e00fb357703  include/zucchini_ffi.h
+845022e0c1db1abb41a6ba4cd3c4b674ec290f3359d9d3c78ae558d4c0ed9308  licenses/LICENSE.zucchini
+a0a33d4ad9d6a62311eae87175db1bad4686a8d6a0edd47ac1584be7569d67e4  provenance.txt
diff --git a/scripts/fetch-native-artifact.py b/scripts/fetch-native-artifact.py
new file mode 100755
index 0000000..8712557
--- /dev/null
+++ b/scripts/fetch-native-artifact.py
@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+import argparse
+import hashlib
+import json
+import os
+import pathlib
+import shutil
+import sys
+import tarfile
+import tempfile
+import urllib.request
+
+
+def sha256_file(path: pathlib.Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def parse_sha256_lock(path: pathlib.Path) -> dict[str, str]:
+    checksums = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        digest, relpath = line.split(maxsplit=1)
+        checksums[relpath.strip()] = digest
+    return checksums
+
+
+def verify_tree(root: pathlib.Path, checksums: dict[str, str]) -> None:
+    for relpath, expected in checksums.items():
+        target = root / relpath
+        if not target.is_file():
+            raise RuntimeError(f"missing native artifact file: {target}")
+        actual = sha256_file(target)
+        if actual != expected:
+            raise RuntimeError(
+                f"native artifact checksum mismatch for {relpath}: expected {expected}, got {actual}"
+            )
+
+
+def safe_extract(archive: pathlib.Path, destination: pathlib.Path) -> None:
+    with tarfile.open(archive, "r:gz") as tar:
+        for member in tar.getmembers():
+            name = pathlib.PurePosixPath(member.name)
+            if name.is_absolute() or ".." in name.parts:
+                raise RuntimeError(f"unsafe entry in native artifact archive: {member.name}")
+            if member.issym() or member.islnk():
+                raise RuntimeError(f"links are not allowed in native artifact archive: {member.name}")
+            if not (member.isfile() or member.isdir()):
+                raise RuntimeError(f"unsupported tar entry in native artifact archive: {member.name}")
+        tar.extractall(destination)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--bundle-lock", required=True)
+    parser.add_argument("--checksum-lock", required=True)
+    parser.add_argument("--out", required=True)
+    parser.add_argument("--cache", required=True)
+    args = parser.parse_args()
+
+    bundle_lock = json.loads(pathlib.Path(args.bundle_lock).read_text(encoding="utf-8"))
+    checksums = parse_sha256_lock(pathlib.Path(args.checksum_lock))
+    out_dir = pathlib.Path(args.out)
+
+    if out_dir.is_dir():
+        verify_tree(out_dir, checksums)
+        return 0
+
+    cache_root = pathlib.Path(args.cache)
+    cache_root.mkdir(parents=True, exist_ok=True)
+    archive_path = cache_root / f"{bundle_lock['sha256']}.tar.gz"
+
+    preseed = os.environ.get("OTADUMP_NATIVE_PRESEED")
+    offline = os.environ.get("OTADUMP_NATIVE_OFFLINE")
+
+    if preseed:
+        preseed_path = pathlib.Path(preseed)
+        if preseed_path.is_dir():
+            verify_tree(preseed_path, checksums)
+            out_dir.parent.mkdir(parents=True, exist_ok=True)
+            if out_dir.exists():
+                shutil.rmtree(out_dir)
+            shutil.copytree(preseed_path, out_dir)
+            return 0
+        if not preseed_path.is_file():
+            raise RuntimeError(f"OTADUMP_NATIVE_PRESEED path does not exist: {preseed_path}")
+        shutil.copy2(preseed_path, archive_path)
+
+    if not archive_path.is_file():
+        if offline:
+            raise RuntimeError(
+                "offline native artifact mode is enabled but cache is empty; "
+                "set OTADUMP_NATIVE_PRESEED or unset OTADUMP_NATIVE_OFFLINE"
+            )
+        with urllib.request.urlopen(bundle_lock["url"]) as response:
+            with tempfile.NamedTemporaryFile(delete=False, dir=cache_root) as handle:
+                handle.write(response.read())
+                temp_name = handle.name
+        pathlib.Path(temp_name).replace(archive_path)
+
+    archive_digest = sha256_file(archive_path)
+    if archive_digest != bundle_lock["sha256"]:
+        raise RuntimeError(
+            f"native artifact archive checksum mismatch: expected {bundle_lock['sha256']}, got {archive_digest}"
+        )
+
+    with tempfile.TemporaryDirectory(dir=cache_root) as temp:
+        temp_root = pathlib.Path(temp)
+        safe_extract(archive_path, temp_root)
+        extracted = temp_root / bundle_lock["extract_root"]
+        if not extracted.is_dir():
+            raise RuntimeError(f"missing artifact root after extraction: {bundle_lock['extract_root']}")
+        verify_tree(extracted, checksums)
+
+        out_dir.parent.mkdir(parents=True, exist_ok=True)
+        staging = out_dir.with_name(out_dir.name + ".tmp")
+        if staging.exists():
+            shutil.rmtree(staging)
+        shutil.copytree(extracted, staging)
+        os.replace(staging, out_dir)
+
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except Exception as error:
+        print(f"otadump native artifact fetch failed: {error}", file=sys.stderr)
+        raise SystemExit(2)
diff --git a/src/lib.rs b/src/lib.rs
index 29b66b1..8fd1d8d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -12,7 +12,6 @@ mod puffin;
 mod python;
 mod verity;
 pub mod zucchini;
-pub mod zucchini_pure;
 
 use std::cmp::Reverse;
 use std::collections::HashSet;
diff --git a/src/zucchini.rs b/src/zucchini.rs
index 59fac48..929b2bb 100644
--- a/src/zucchini.rs
+++ b/src/zucchini.rs
@@ -1,26 +1,140 @@
-use crate::zucchini_pure;
+use std::error;
+use std::fmt;
 
-pub use crate::zucchini_pure::{Error, Result, Status};
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Status {
+    InvalidArgument,
+    InvalidPatch,
+    UnsupportedElement,
+    WrongOutputSize,
+    ApplyError,
+    Cancelled,
+    AllocationFailure,
+    UnsupportedTarget,
+    Unknown(i32),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct Error {
+    status: Status,
+    message: String,
+}
+
+impl Error {
+    pub fn status(&self) -> Status {
+        self.status
+    }
+}
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.message)
+    }
+}
+impl error::Error for Error {}
+pub type Result<T> = std::result::Result<T, Error>;
 
 /// Exclusive upper bound for buffers represented by Zucchini offsets.
-pub const OFFSET_BOUND: usize = zucchini_pure::OFFSET_BOUND;
+pub const OFFSET_BOUND: usize = (u32::MAX / 2) as usize;
 
 /// Applies a Zucchini patch into a newly allocated, exact-size output buffer.
 ///
-/// This is now backed entirely by the pure-Rust implementation in
-/// `zucchini_pure`; the vendored C++ Zucchini is no longer required.
 pub fn apply(old: &[u8], patch: &[u8], output_size: usize) -> Result<Vec<u8>> {
-    zucchini_pure::apply(old, patch, output_size)
+    if old.len() >= OFFSET_BOUND || patch.len() >= OFFSET_BOUND || output_size >= OFFSET_BOUND {
+        return Err(Error {
+            status: Status::InvalidArgument,
+            message: "image exceeds Zucchini offset bound".into(),
+        });
+    }
+    let mut output = Vec::new();
+    output.try_reserve_exact(output_size).map_err(|e| Error {
+        status: Status::AllocationFailure,
+        message: format!("unable to allocate Zucchini output: {e}"),
+    })?;
+    output.resize(output_size, 0);
+    #[cfg(otadump_zucchini)]
+    {
+        use std::ffi::{CStr, c_char};
+        #[repr(C)]
+        struct NativeResult {
+            status: i32,
+            error: *const c_char,
+        }
+        unsafe extern "C" {
+            fn otadump_zucchini_apply(
+                old: *const u8,
+                old_len: usize,
+                patch: *const u8,
+                patch_len: usize,
+                new: *mut u8,
+                new_len: usize,
+            ) -> NativeResult;
+        }
+        // SAFETY: all slices remain alive and output is a distinct allocation for the call.
+        let result = unsafe {
+            otadump_zucchini_apply(
+                old.as_ptr(),
+                old.len(),
+                patch.as_ptr(),
+                patch.len(),
+                output.as_mut_ptr(),
+                output.len(),
+            )
+        };
+        if result.status == 0 {
+            return Ok(output);
+        }
+        let message = if result.error.is_null() {
+            format!("Zucchini failed with status {}", result.status)
+        } else {
+            unsafe { CStr::from_ptr(result.error) }.to_string_lossy().into_owned()
+        };
+        Err(Error {
+            status: match result.status {
+                1 => Status::InvalidArgument,
+                2 => Status::InvalidPatch,
+                3 => Status::UnsupportedElement,
+                4 => Status::WrongOutputSize,
+                5 => Status::ApplyError,
+                n => Status::Unknown(n),
+            },
+            message,
+        })
+    }
+    #[cfg(not(otadump_zucchini))]
+    {
+        let _ = (old, patch, output);
+        Err(Error {
+            status: Status::UnsupportedTarget,
+            message: "Zucchini is supported only on Linux x86_64 GNU hosts".into(),
+        })
+    }
 }
 
 /// Same as [`apply`], but cooperatively stops when `cancelled` returns true.
+/// Native Zucchini is one non-interruptible operation; cancellation is checked
+/// immediately before and after that call.
 pub fn apply_with_cancel<F: Fn() -> bool>(
     old: &[u8],
     patch: &[u8],
     output_size: usize,
     cancelled: F,
 ) -> Result<Vec<u8>> {
-    zucchini_pure::apply_with_cancel(old, patch, output_size, cancelled)
+    if cancelled() {
+        return Err(Error {
+            status: Status::Cancelled,
+            message: "Zucchini operation cancelled".into(),
+        });
+    }
+    // ponytail: the upstream apply loop has no safe cancellation seam; the
+    // operation boundary is the deliberate cancellation ceiling.
+    let result = apply(old, patch, output_size);
+    if cancelled() {
+        return Err(Error {
+            status: Status::Cancelled,
+            message: "Zucchini operation cancelled".into(),
+        });
+    }
+    result
 }
 
 #[cfg(test)]
diff --git a/src/zucchini_pure/arm.rs b/src/zucchini_pure/arm.rs
deleted file mode 100644
index b2b6c70..0000000
--- a/src/zucchini_pure/arm.rs
+++ /dev/null
@@ -1,497 +0,0 @@
-//! Ports of `arm_utils.cc`: AArch32 (ARM/THUMB2) and AArch64 rel32 codecs.
-
-use super::bytes::sign_extend_u32;
-use super::bytes::{get_signed_bits_u32, get_unsigned_bits_u32, signed_fit};
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum ArmAlign {
-    Fail = 0,
-    Align2 = 2,
-    Align4 = 4,
-}
-
-#[inline]
-fn bit(value: u32, pos: u32) -> u32 {
-    (value >> pos) & 1
-}
-
-#[inline]
-fn unsigned_bits(value: u32, lo: u32, hi: u32) -> u32 {
-    get_unsigned_bits_u32(value, lo, hi)
-}
-
-#[inline]
-fn signed_bits(value: u32, lo: u32, hi: u32) -> i32 {
-    get_signed_bits_u32(value, lo, hi)
-}
-
-#[inline]
-fn signed_bits_u16(value: u16, lo: u32, hi: u32) -> i32 {
-    // `GetSignedBits` on a 16-bit value.
-    let num_bits = 16i32;
-    let shift = num_bits - 1 - hi as i32;
-    (i32::from(value) << shift) >> (shift + lo as i32)
-}
-
-#[inline]
-fn is_misaligned(rva: u32, align: ArmAlign) -> bool {
-    (rva & (align as u32 - 1)) != 0
-}
-
-pub fn fetch_arm_code32(image: &[u8], offset: u32) -> u32 {
-    super::bytes::read_u32(image, offset as usize).unwrap_or(0)
-}
-
-pub fn fetch_thumb2_code16(image: &[u8], offset: u32) -> u16 {
-    super::bytes::read_u16(image, offset as usize).unwrap_or(0)
-}
-
-pub fn fetch_thumb2_code32(image: &[u8], offset: u32) -> u32 {
-    let hi = super::bytes::read_u16(image, offset as usize).unwrap_or(0) as u32;
-    let lo = super::bytes::read_u16(image, offset as usize + 2).unwrap_or(0) as u32;
-    (hi << 16) | lo
-}
-
-pub fn store_arm_code32(image: &mut [u8], offset: u32, code: u32) {
-    let _ = super::bytes::write_u32(image, offset as usize, code);
-}
-
-pub fn store_thumb2_code16(image: &mut [u8], offset: u32, code: u16) {
-    let _ = super::bytes::write_u16(image, offset as usize, code);
-}
-
-pub fn store_thumb2_code32(image: &mut [u8], offset: u32, code: u32) {
-    let _ = super::bytes::write_u16(image, offset as usize, (code >> 16) as u16);
-    let _ = super::bytes::write_u16(image, offset as usize + 2, (code & 0xFFFF) as u16);
-}
-
-pub fn get_thumb2_instruction_size(code16: u16) -> u32 {
-    if (code16 & 0xF000) == 0xF000 || (code16 & 0xF800) == 0xE800 { 4 } else { 2 }
-}
-
-/// Mirrors `AArch32Rel32Translator::DecodeA24`.
-pub fn decode_a24(code32: u32) -> (ArmAlign, i32) {
-    let bits = unsigned_bits(code32, 24, 27);
-    if bits == 0xA || bits == 0xB {
-        let mut disp = signed_bits(code32, 0, 23) << 2;
-        let cond = unsigned_bits(code32, 28, 31);
-        if cond == 0xF {
-            let h = bit(code32, 24);
-            disp |= (h << 1) as i32;
-            return (ArmAlign::Align2, disp);
-        }
-        return (ArmAlign::Align4, disp);
-    }
-    (ArmAlign::Fail, 0)
-}
-
-/// Mirrors `AArch32Rel32Translator::EncodeA24`.
-pub fn encode_a24(disp: i32, code32: &mut u32) -> bool {
-    let mut t = *code32;
-    let bits = unsigned_bits(t, 24, 27);
-    if bits == 0xA || bits == 0xB {
-        if !signed_fit(disp, 26) {
-            return false;
-        }
-        let cond = unsigned_bits(t, 28, 31);
-        if cond == 0xF {
-            if disp % 2 != 0 {
-                return false;
-            }
-            let h = bit(disp as u32, 1);
-            t = (t & 0xFEFF_FFFF) | (h << 24);
-        } else if disp % 4 != 0 {
-            return false;
-        }
-        t = (t & 0xFF00_0000) | (((disp >> 2) as u32) & 0x00FF_FFFF);
-        *code32 = t;
-        return true;
-    }
-    false
-}
-
-fn get_arm_target_rva_from_disp(instr_rva: u32, disp: i32, align: ArmAlign) -> u32 {
-    let ret = instr_rva.wrapping_add(8).wrapping_add(disp as u32);
-    ret - (ret & (align as u32 - 1))
-}
-
-fn get_thumb2_target_rva_from_disp(instr_rva: u32, disp: i32, align: ArmAlign) -> u32 {
-    let ret = instr_rva.wrapping_add(4).wrapping_add(disp as u32);
-    ret - (ret & (align as u32 - 1))
-}
-
-fn get_arm_disp_from_target_rva(instr_rva: u32, target_rva: u32, align: ArmAlign) -> i32 {
-    let ret = target_rva as i32 - instr_rva.wrapping_add(8) as i32;
-    ret + ((-ret) & (align as i32 - 1))
-}
-
-fn get_thumb2_disp_from_target_rva(instr_rva: u32, target_rva: u32, align: ArmAlign) -> i32 {
-    let ret = target_rva as i32 - instr_rva.wrapping_add(4) as i32;
-    ret + ((-ret) & (align as i32 - 1))
-}
-
-pub fn read_a24(instr_rva: u32, code32: u32) -> Option<u32> {
-    if is_misaligned(instr_rva, ArmAlign::Align4) {
-        return None;
-    }
-    let (align, disp) = decode_a24(code32);
-    if align == ArmAlign::Fail {
-        return None;
-    }
-    Some(get_arm_target_rva_from_disp(instr_rva, disp, align))
-}
-
-pub fn write_a24(instr_rva: u32, target_rva: u32, code32: &mut u32) -> bool {
-    if is_misaligned(instr_rva, ArmAlign::Align4) {
-        return false;
-    }
-    let (align, _) = decode_a24(*code32);
-    if align == ArmAlign::Fail || is_misaligned(target_rva, align) {
-        return false;
-    }
-    let disp = get_arm_disp_from_target_rva(instr_rva, target_rva, align);
-    encode_a24(disp, code32)
-}
-
-pub fn decode_t8(code16: u16) -> (ArmAlign, i32) {
-    if (code16 & 0xF000) == 0xD000 && (code16 & 0x0F00) != 0x0F00 {
-        return (ArmAlign::Align2, signed_bits_u16(code16, 0, 7) << 1);
-    }
-    (ArmAlign::Fail, 0)
-}
-
-pub fn encode_t8(disp: i32, code16: &mut u16) -> bool {
-    let mut t = *code16;
-    if (t & 0xF000) == 0xD000 && (t & 0x0F00) != 0x0F00 {
-        if disp % 2 != 0 || !signed_fit(disp, 9) {
-            return false;
-        }
-        t = (t & 0xFF00) | (((disp >> 1) as u16) & 0x00FF);
-        *code16 = t;
-        return true;
-    }
-    false
-}
-
-pub fn read_t8(instr_rva: u32, code16: u16) -> Option<u32> {
-    if is_misaligned(instr_rva, ArmAlign::Align2) {
-        return None;
-    }
-    let (align, disp) = decode_t8(code16);
-    if align == ArmAlign::Fail {
-        return None;
-    }
-    Some(get_thumb2_target_rva_from_disp(instr_rva, disp, align))
-}
-
-pub fn write_t8(instr_rva: u32, target_rva: u32, code16: &mut u16) -> bool {
-    if is_misaligned(instr_rva, ArmAlign::Align2) || is_misaligned(target_rva, ArmAlign::Align2) {
-        return false;
-    }
-    let disp = get_thumb2_disp_from_target_rva(instr_rva, target_rva, ArmAlign::Align2);
-    encode_t8(disp, code16)
-}
-
-pub fn decode_t11(code16: u16) -> (ArmAlign, i32) {
-    if (code16 & 0xF800) == 0xE000 {
-        return (ArmAlign::Align2, signed_bits_u16(code16, 0, 10) << 1);
-    }
-    (ArmAlign::Fail, 0)
-}
-
-pub fn encode_t11(disp: i32, code16: &mut u16) -> bool {
-    let mut t = *code16;
-    if (t & 0xF800) == 0xE000 {
-        if disp % 2 != 0 || !signed_fit(disp, 12) {
-            return false;
-        }
-        t = (t & 0xF800) | (((disp >> 1) as u16) & 0x07FF);
-        *code16 = t;
-        return true;
-    }
-    false
-}
-
-pub fn read_t11(instr_rva: u32, code16: u16) -> Option<u32> {
-    if is_misaligned(instr_rva, ArmAlign::Align2) {
-        return None;
-    }
-    let (align, disp) = decode_t11(code16);
-    if align == ArmAlign::Fail {
-        return None;
-    }
-    Some(get_thumb2_target_rva_from_disp(instr_rva, disp, align))
-}
-
-pub fn write_t11(instr_rva: u32, target_rva: u32, code16: &mut u16) -> bool {
-    if is_misaligned(instr_rva, ArmAlign::Align2) || is_misaligned(target_rva, ArmAlign::Align2) {
-        return false;
-    }
-    let disp = get_thumb2_disp_from_target_rva(instr_rva, target_rva, ArmAlign::Align2);
-    encode_t11(disp, code16)
-}
-
-pub fn decode_t20(code32: u32) -> (ArmAlign, i32) {
-    if (code32 & 0xF800_D000) == 0xF000_8000 && (code32 & 0x03C0_0000) != 0x03C0_0000 {
-        let imm11 = unsigned_bits(code32, 0, 10);
-        let j2 = bit(code32, 11);
-        let j1 = bit(code32, 13);
-        let imm6 = unsigned_bits(code32, 16, 21);
-        let s = bit(code32, 26);
-        let mut t = (imm6 << 12) | (imm11 << 1);
-        t |= (s << 20) | (j2 << 19) | (j1 << 18);
-        return (ArmAlign::Align2, sign_extend_u32(t, 20));
-    }
-    (ArmAlign::Fail, 0)
-}
-
-pub fn encode_t20(disp: i32, code32: &mut u32) -> bool {
-    let mut t = *code32;
-    if (t & 0xF800_D000) == 0xF000_8000 && (t & 0x03C0_0000) != 0x03C0_0000 {
-        if disp % 2 != 0 || !signed_fit(disp, 21) {
-            return false;
-        }
-        let s = bit(disp as u32, 20);
-        let j2 = bit(disp as u32, 19);
-        let j1 = bit(disp as u32, 18);
-        let imm6 = unsigned_bits(disp as u32, 12, 17);
-        let imm11 = unsigned_bits(disp as u32, 1, 11);
-        t &= 0xFBC0_D000;
-        t |= (s << 26) | (imm6 << 16) | (j1 << 13) | (j2 << 11) | imm11;
-        *code32 = t;
-        return true;
-    }
-    false
-}
-
-pub fn read_t20(instr_rva: u32, code32: u32) -> Option<u32> {
-    if is_misaligned(instr_rva, ArmAlign::Align2) {
-        return None;
-    }
-    let (align, disp) = decode_t20(code32);
-    if align == ArmAlign::Fail {
-        return None;
-    }
-    Some(get_thumb2_target_rva_from_disp(instr_rva, disp, align))
-}
-
-pub fn write_t20(instr_rva: u32, target_rva: u32, code32: &mut u32) -> bool {
-    if is_misaligned(instr_rva, ArmAlign::Align2) || is_misaligned(target_rva, ArmAlign::Align2) {
-        return false;
-    }
-    let disp = get_thumb2_disp_from_target_rva(instr_rva, target_rva, ArmAlign::Align2);
-    encode_t20(disp, code32)
-}
-
-pub fn decode_t24(code32: u32) -> (ArmAlign, i32) {
-    let bits = code32 & 0xF800_D000;
-    if bits == 0xF000_9000 || bits == 0xF000_D000 || bits == 0xF000_C000 {
-        let imm11 = unsigned_bits(code32, 0, 10);
-        let j2 = bit(code32, 11);
-        let j1 = bit(code32, 13);
-        let imm10 = unsigned_bits(code32, 16, 25);
-        let s = bit(code32, 26);
-        let mut t = (imm10 << 12) | (imm11 << 1);
-        t |= (s << 24) | ((j1 ^ s ^ 1) << 23) | ((j2 ^ s ^ 1) << 22);
-        let disp = sign_extend_u32(t, 24);
-        let mut align = ArmAlign::Align2;
-        if bits == 0xF000_C000 {
-            if bit(code32, 0) != 0 {
-                return (ArmAlign::Fail, 0);
-            }
-            align = ArmAlign::Align4;
-        }
-        return (align, disp);
-    }
-    (ArmAlign::Fail, 0)
-}
-
-pub fn encode_t24(disp: i32, code32: &mut u32) -> bool {
-    let mut t = *code32;
-    let bits = t & 0xF800_D000;
-    if bits == 0xF000_9000 || bits == 0xF000_D000 || bits == 0xF000_C000 {
-        if disp % 2 != 0 {
-            return false;
-        }
-        if bits == 0xF000_C000 && bit(disp as u32, 1) != 0 {
-            return false;
-        }
-        if !signed_fit(disp, 25) {
-            return false;
-        }
-        let imm11 = unsigned_bits(disp as u32, 1, 11);
-        let imm10 = unsigned_bits(disp as u32, 12, 21);
-        let i2 = bit(disp as u32, 22);
-        let i1 = bit(disp as u32, 23);
-        let s = bit(disp as u32, 24);
-        t &= 0xF800_D000;
-        t |= (s << 26) | (imm10 << 16) | ((i1 ^ s ^ 1) << 13) | ((i2 ^ s ^ 1) << 11) | imm11;
-        *code32 = t;
-        return true;
-    }
-    false
-}
-
-pub fn read_t24(instr_rva: u32, code32: u32) -> Option<u32> {
-    if is_misaligned(instr_rva, ArmAlign::Align2) {
-        return None;
-    }
-    let (align, disp) = decode_t24(code32);
-    if align == ArmAlign::Fail {
-        return None;
-    }
-    Some(get_thumb2_target_rva_from_disp(instr_rva, disp, align))
-}
-
-pub fn write_t24(instr_rva: u32, target_rva: u32, code32: &mut u32) -> bool {
-    if is_misaligned(instr_rva, ArmAlign::Align2) {
-        return false;
-    }
-    let (align, _) = decode_t24(*code32);
-    if align == ArmAlign::Fail || is_misaligned(target_rva, align) {
-        return false;
-    }
-    let disp = get_thumb2_disp_from_target_rva(instr_rva, target_rva, align);
-    encode_t24(disp, code32)
-}
-
-// `AArch64Rel32Translator`.
-
-fn get_target_rva_from_disp(instr_rva: u32, disp: i32) -> u32 {
-    instr_rva.wrapping_add(disp as u32)
-}
-
-fn get_disp_from_target_rva(instr_rva: u32, target_rva: u32) -> i32 {
-    target_rva.wrapping_sub(instr_rva) as i32
-}
-
-pub fn decode_immd14(code32: u32) -> (ArmAlign, i32) {
-    let bits = code32 & 0x7F00_0000;
-    if bits == 0x3600_0000 || bits == 0x3700_0000 {
-        return (ArmAlign::Align4, signed_bits(code32, 5, 18) << 2);
-    }
-    (ArmAlign::Fail, 0)
-}
-
-pub fn encode_immd14(disp: i32, code32: &mut u32) -> bool {
-    let mut t = *code32;
-    let bits = t & 0x7F00_0000;
-    if bits == 0x3600_0000 || bits == 0x3700_0000 {
-        if disp % 4 != 0 || !signed_fit(disp, 16) {
-            return false;
-        }
-        let imm14 = unsigned_bits(disp as u32, 2, 15);
-        t &= 0xFFF8_001F;
-        t |= imm14 << 5;
-        *code32 = t;
-        return true;
-    }
-    false
-}
-
-pub fn read_immd14(instr_rva: u32, code32: u32) -> Option<u32> {
-    if is_misaligned(instr_rva, ArmAlign::Align4) {
-        return None;
-    }
-    let (align, disp) = decode_immd14(code32);
-    if align == ArmAlign::Fail {
-        return None;
-    }
-    Some(get_target_rva_from_disp(instr_rva, disp))
-}
-
-pub fn write_immd14(instr_rva: u32, target_rva: u32, code32: &mut u32) -> bool {
-    if is_misaligned(instr_rva, ArmAlign::Align4) || is_misaligned(target_rva, ArmAlign::Align4) {
-        return false;
-    }
-    let disp = get_disp_from_target_rva(instr_rva, target_rva);
-    encode_immd14(disp, code32)
-}
-
-pub fn decode_immd19(code32: u32) -> (ArmAlign, i32) {
-    let bits1 = code32 & 0xFF00_0010;
-    let bits2 = code32 & 0x7F00_0000;
-    if bits1 == 0x5400_0000 || bits2 == 0x3400_0000 || bits2 == 0x3500_0000 {
-        return (ArmAlign::Align4, signed_bits(code32, 5, 23) << 2);
-    }
-    (ArmAlign::Fail, 0)
-}
-
-pub fn encode_immd19(disp: i32, code32: &mut u32) -> bool {
-    let mut t = *code32;
-    let bits1 = t & 0xFF00_0010;
-    let bits2 = t & 0x7F00_0000;
-    if bits1 == 0x5400_0000 || bits2 == 0x3400_0000 || bits2 == 0x3500_0000 {
-        if disp % 4 != 0 || !signed_fit(disp, 21) {
-            return false;
-        }
-        let imm19 = unsigned_bits(disp as u32, 2, 20);
-        t &= 0xFF00_001F;
-        t |= imm19 << 5;
-        *code32 = t;
-        return true;
-    }
-    false
-}
-
-pub fn read_immd19(instr_rva: u32, code32: u32) -> Option<u32> {
-    if is_misaligned(instr_rva, ArmAlign::Align4) {
-        return None;
-    }
-    let (align, disp) = decode_immd19(code32);
-    if align == ArmAlign::Fail {
-        return None;
-    }
-    Some(get_target_rva_from_disp(instr_rva, disp))
-}
-
-pub fn write_immd19(instr_rva: u32, target_rva: u32, code32: &mut u32) -> bool {
-    if is_misaligned(instr_rva, ArmAlign::Align4) || is_misaligned(target_rva, ArmAlign::Align4) {
-        return false;
-    }
-    let disp = get_disp_from_target_rva(instr_rva, target_rva);
-    encode_immd19(disp, code32)
-}
-
-pub fn decode_immd26(code32: u32) -> (ArmAlign, i32) {
-    let bits = code32 & 0xFC00_0000;
-    if bits == 0x1400_0000 || bits == 0x9400_0000 {
-        return (ArmAlign::Align4, signed_bits(code32, 0, 25) << 2);
-    }
-    (ArmAlign::Fail, 0)
-}
-
-pub fn encode_immd26(disp: i32, code32: &mut u32) -> bool {
-    let mut t = *code32;
-    let bits = t & 0xFC00_0000;
-    if bits == 0x1400_0000 || bits == 0x9400_0000 {
-        if disp % 4 != 0 || !signed_fit(disp, 28) {
-            return false;
-        }
-        let imm26 = unsigned_bits(disp as u32, 2, 27);
-        t &= 0xFC00_0000;
-        t |= imm26;
-        *code32 = t;
-        return true;
-    }
-    false
-}
-
-pub fn read_immd26(instr_rva: u32, code32: u32) -> Option<u32> {
-    if is_misaligned(instr_rva, ArmAlign::Align4) {
-        return None;
-    }
-    let (align, disp) = decode_immd26(code32);
-    if align == ArmAlign::Fail {
-        return None;
-    }
-    Some(get_target_rva_from_disp(instr_rva, disp))
-}
-
-pub fn write_immd26(instr_rva: u32, target_rva: u32, code32: &mut u32) -> bool {
-    if is_misaligned(instr_rva, ArmAlign::Align4) || is_misaligned(target_rva, ArmAlign::Align4) {
-        return false;
-    }
-    let disp = get_disp_from_target_rva(instr_rva, target_rva);
-    encode_immd26(disp, code32)
-}
diff --git a/src/zucchini_pure/bytes.rs b/src/zucchini_pure/bytes.rs
deleted file mode 100644
index 10358a9..0000000
--- a/src/zucchini_pure/bytes.rs
+++ /dev/null
@@ -1,100 +0,0 @@
-//! Little-endian byte access helpers shared by the pure-Rust Zucchini port.
-
-pub fn read_u8(data: &[u8], offset: usize) -> Option<u8> {
-    data.get(offset).copied()
-}
-
-pub fn read_u16(data: &[u8], offset: usize) -> Option<u16> {
-    let bytes = data.get(offset..offset.checked_add(2)?)?;
-    Some(u16::from_le_bytes(bytes.try_into().ok()?))
-}
-
-pub fn read_i16(data: &[u8], offset: usize) -> Option<i16> {
-    Some(read_u16(data, offset)? as i16)
-}
-
-pub fn read_i8(data: &[u8], offset: usize) -> Option<i8> {
-    Some(read_u8(data, offset)? as i8)
-}
-
-pub fn read_u32(data: &[u8], offset: usize) -> Option<u32> {
-    let bytes = data.get(offset..offset.checked_add(4)?)?;
-    Some(u32::from_le_bytes(bytes.try_into().ok()?))
-}
-
-pub fn read_i32(data: &[u8], offset: usize) -> Option<i32> {
-    Some(read_u32(data, offset)? as i32)
-}
-
-pub fn read_u64(data: &[u8], offset: usize) -> Option<u64> {
-    let bytes = data.get(offset..offset.checked_add(8)?)?;
-    Some(u64::from_le_bytes(bytes.try_into().ok()?))
-}
-
-pub fn write_u16(data: &mut [u8], offset: usize, value: u16) -> Option<()> {
-    let end = offset.checked_add(2)?;
-    data.get_mut(offset..end)?.copy_from_slice(&value.to_le_bytes());
-    Some(())
-}
-
-pub fn write_u32(data: &mut [u8], offset: usize, value: u32) -> Option<()> {
-    let end = offset.checked_add(4)?;
-    data.get_mut(offset..end)?.copy_from_slice(&value.to_le_bytes());
-    Some(())
-}
-
-pub fn write_u64(data: &mut [u8], offset: usize, value: u64) -> Option<()> {
-    let end = offset.checked_add(8)?;
-    data.get_mut(offset..end)?.copy_from_slice(&value.to_le_bytes());
-    Some(())
-}
-
-/// Mirrors `zucchini::RangeIsBounded`: `begin < bound && size <= bound - begin`.
-pub fn range_is_bounded(begin: u64, size: u64, bound: u64) -> bool {
-    begin < bound && size <= bound - begin
-}
-
-/// Mirrors `zucchini::RangeCovers`: `begin <= value && value - begin < size`.
-pub fn range_covers(begin: u64, size: u64, value: u64) -> bool {
-    begin <= value && value - begin < size
-}
-
-/// Mirrors `zucchini::IncrementForAlignCeil2`.
-pub fn increment_for_align_ceil2(pos: u64) -> u64 {
-    pos & 1
-}
-
-/// Mirrors `zucchini::IncrementForAlignCeil4`.
-pub fn increment_for_align_ceil4(pos: u64) -> u64 {
-    (-(pos as i64) & 3) as u64
-}
-
-/// Mirrors `zucchini::AlignCeil`.
-pub fn align_ceil(x: u64, m: u64) -> u64 {
-    x.div_ceil(m) * m
-}
-
-/// Zero-extends bits `[lo, hi]` (inclusive) of a 32-bit value.
-pub fn get_unsigned_bits_u32(value: u32, lo: u32, hi: u32) -> u32 {
-    let num_bits = 32u32;
-    (value << (num_bits - 1 - hi)) >> (num_bits - 1 - hi + lo)
-}
-
-/// Sign-extends bits `[lo, hi]` (inclusive) of a 32-bit value.
-pub fn get_signed_bits_u32(value: u32, lo: u32, hi: u32) -> i32 {
-    let num_bits = 32i32;
-    let shift = num_bits - 1 - hi as i32;
-    ((value << shift) as i32) >> (shift + lo as i32)
-}
-
-/// Sign-extends the low `pos + 1` bits of `value`.
-pub fn sign_extend_u32(value: u32, pos: u32) -> i32 {
-    let shift = 31 - pos;
-    ((value << shift) as i32) >> shift
-}
-
-/// Mirrors `zucchini::SignedFit<digs>` for a 32-bit signed value.
-pub fn signed_fit(value: i32, digs: u32) -> bool {
-    let shift = 32 - digs;
-    (value << shift) >> shift == value
-}
diff --git a/src/zucchini_pure/crc32.rs b/src/zucchini_pure/crc32.rs
deleted file mode 100644
index 859f6fa..0000000
--- a/src/zucchini_pure/crc32.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-//! CRC-32 implementation matching `components/zucchini/crc32.cc`.
-
-fn make_crc32_table() -> [u32; 256] {
-    const POLY: u32 = 0xEDB8_8320;
-    let mut table = [0u32; 256];
-    for (i, entry) in table.iter_mut().enumerate() {
-        let mut r = i as u32;
-        for _ in 0..8 {
-            r = (r >> 1) ^ (POLY & (!((r & 1).wrapping_sub(1))));
-        }
-        *entry = r;
-    }
-    table
-}
-
-pub fn calculate_crc32(data: &[u8]) -> u32 {
-    let table = make_crc32_table();
-    let mut ret = 0xFFFF_FFFFu32;
-    for &byte in data {
-        ret = table[((ret ^ byte as u32) & 0xFF) as usize] ^ (ret >> 8);
-    }
-    ret ^ 0xFFFF_FFFF
-}
-
-/// Number of bytes between cancellation polls while hashing.
-pub const CRC_POLL_CHUNK: usize = 1 << 20;
-
-/// Same as [`calculate_crc32`], but polls `cancelled` between chunks and
-/// returns `Status::Cancelled` instead of running to completion.
-pub fn calculate_crc32_cancel(data: &[u8], cancelled: &dyn Fn() -> bool) -> super::Result<u32> {
-    if cancelled() {
-        return Err(super::Error::new(super::Status::Cancelled, "Zucchini apply cancelled"));
-    }
-    let table = make_crc32_table();
-    let mut ret = 0xFFFF_FFFFu32;
-    for chunk in data.chunks(CRC_POLL_CHUNK) {
-        if cancelled() {
-            return Err(super::Error::new(super::Status::Cancelled, "Zucchini apply cancelled"));
-        }
-        for &byte in chunk {
-            ret = table[((ret ^ byte as u32) & 0xFF) as usize] ^ (ret >> 8);
-        }
-    }
-    Ok(ret ^ 0xFFFF_FFFF)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn known_vectors() {
-        assert_eq!(calculate_crc32(b""), 0x0000_0000);
-        assert_eq!(calculate_crc32(b"123456789"), 0xCBF4_3926);
-    }
-
-    #[test]
-    fn cancellation_polls_between_chunks() {
-        let data = vec![0u8; CRC_POLL_CHUNK + 17];
-        assert_eq!(calculate_crc32_cancel(&data, &|| false).unwrap(), calculate_crc32(&data));
-
-        let calls = std::cell::Cell::new(0u32);
-        let error = calculate_crc32_cancel(&data, &|| {
-            calls.set(calls.get() + 1);
-            calls.get() >= 2
-        })
-        .unwrap_err();
-        assert_eq!(error.status(), super::super::Status::Cancelled);
-    }
-}
diff --git a/src/zucchini_pure/dex.rs b/src/zucchini_pure/dex.rs
deleted file mode 100644
index 071b400..0000000
--- a/src/zucchini_pure/dex.rs
+++ /dev/null
@@ -1,1456 +0,0 @@
-//! Pure-Rust port of `disassembler_dex.cc` for the apply path.
-
-use std::collections::BTreeMap;
-
-use super::bytes::{
-    align_ceil, read_i8, read_i16, read_i32, read_u16, read_u32, write_u16, write_u32,
-};
-use super::{Disassembler, GroupTraits, K_INVALID_OFFSET, OFFSET_BOUND, Reference, Result};
-
-const HEADER_SIZE: usize = 112;
-const CODE_ITEM_HEADER: usize = 16;
-const MAP_ITEM_SIZE: usize = 12;
-const K_MAX_ITEM_LIST_SIZE: u32 = 21;
-const K_MAX_LEB128_SIZE: usize = 5;
-const SENTINEL_OFFSET: u32 = 0;
-const SENTINEL_INDEX: u32 = 0xFFFF_FFFF;
-
-// Map item type codes.
-const T_STRING_ID: u16 = 0x0001;
-const T_TYPE_ID: u16 = 0x0002;
-const T_PROTO_ID: u16 = 0x0003;
-const T_FIELD_ID: u16 = 0x0004;
-const T_METHOD_ID: u16 = 0x0005;
-const T_CLASS_DEF: u16 = 0x0006;
-const T_CALL_SITE_ID: u16 = 0x0007;
-const T_METHOD_HANDLE: u16 = 0x0008;
-const T_TYPE_LIST: u16 = 0x1001;
-const T_ANNOTATION_SET_REF_LIST: u16 = 0x1002;
-const T_ANNOTATION_SET_ITEM: u16 = 0x1003;
-const T_CODE_ITEM: u16 = 0x2001;
-const T_ANNOTATIONS_DIRECTORY: u16 = 0x2006;
-
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-pub(crate) struct MapItem {
-    pub(crate) size: u32,
-    pub(crate) offset: u32,
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-enum Format {
-    B,
-    C,
-    H,
-    I,
-    L,
-    N,
-    S,
-    T,
-    X,
-}
-
-#[derive(Clone, Copy, Debug)]
-struct Bytecode {
-    /// Canonical range-start opcode, mirroring `dex::Instruction::opcode`.
-    opcode: u8,
-    layout: u8,
-    format: Format,
-}
-
-/// `dex::kByteCode`, expanded into a flat 256-entry opcode table.
-const BYTECODE: &[(u8, u8, Format, u8)] = &[
-    (0x00, 1, Format::X, 1),
-    (0x01, 1, Format::X, 1),
-    (0x02, 2, Format::X, 1),
-    (0x03, 3, Format::X, 1),
-    (0x04, 1, Format::X, 1),
-    (0x05, 2, Format::X, 1),
-    (0x06, 3, Format::X, 1),
-    (0x07, 1, Format::X, 1),
-    (0x08, 2, Format::X, 1),
-    (0x09, 3, Format::X, 1),
-    (0x0A, 1, Format::X, 1),
-    (0x0B, 1, Format::X, 1),
-    (0x0C, 1, Format::X, 1),
-    (0x0D, 1, Format::X, 1),
-    (0x0E, 1, Format::X, 1),
-    (0x0F, 1, Format::X, 1),
-    (0x10, 1, Format::X, 1),
-    (0x11, 1, Format::X, 1),
-    (0x12, 1, Format::N, 1),
-    (0x13, 2, Format::S, 1),
-    (0x14, 3, Format::I, 1),
-    (0x15, 2, Format::H, 1),
-    (0x16, 2, Format::S, 1),
-    (0x17, 3, Format::I, 1),
-    (0x18, 5, Format::L, 1),
-    (0x19, 2, Format::H, 1),
-    (0x1A, 2, Format::C, 1),
-    (0x1B, 3, Format::C, 1),
-    (0x1C, 2, Format::C, 1),
-    (0x1D, 1, Format::X, 1),
-    (0x1E, 1, Format::X, 1),
-    (0x1F, 2, Format::C, 1),
-    (0x20, 2, Format::C, 1),
-    (0x21, 1, Format::X, 1),
-    (0x22, 2, Format::C, 1),
-    (0x23, 2, Format::C, 1),
-    (0x24, 3, Format::C, 1),
-    (0x25, 3, Format::C, 1),
-    (0x26, 3, Format::T, 1),
-    (0x27, 1, Format::X, 1),
-    (0x28, 1, Format::T, 1),
-    (0x29, 2, Format::T, 1),
-    (0x2A, 3, Format::T, 1),
-    (0x2B, 3, Format::T, 1),
-    (0x2C, 3, Format::T, 1),
-    (0x2D, 2, Format::X, 5),
-    (0x32, 2, Format::T, 6),
-    (0x38, 2, Format::T, 6),
-    (0x44, 2, Format::X, 14),
-    (0x52, 2, Format::C, 14),
-    (0x60, 2, Format::C, 14),
-    (0x6E, 3, Format::C, 5),
-    (0x74, 3, Format::C, 5),
-    (0x7B, 1, Format::X, 21),
-    (0x90, 2, Format::X, 32),
-    (0xB0, 1, Format::X, 32),
-    (0xD0, 2, Format::S, 8),
-    (0xD8, 2, Format::B, 11),
-    (0xFA, 4, Format::C, 1),
-    (0xFB, 4, Format::C, 1),
-    (0xFC, 3, Format::C, 1),
-    (0xFD, 3, Format::C, 1),
-    (0xFE, 2, Format::C, 1),
-    (0xFF, 2, Format::C, 1),
-];
-
-fn find_instruction(opcode: u8) -> Option<Bytecode> {
-    // Widening to `u16` matters: the final entry starts at 0xFF with variant 1,
-    // and `u8` arithmetic would wrap `0xFF + 1` to 0, making opcode 0xFF
-    // (const-method-type) unreachable.
-    let opcode = u16::from(opcode);
-    BYTECODE
-        .iter()
-        .find(|(start, _, _, variant)| {
-            opcode >= u16::from(*start) && opcode < u16::from(*start) + u16::from(*variant)
-        })
-        .map(|(start, layout, format, _)| Bytecode {
-            opcode: *start,
-            layout: *layout,
-            format: *format,
-        })
-}
-
-#[derive(Clone, Debug)]
-pub struct DexDisassembler {
-    size: u32,
-    groups: Vec<GroupTraits>,
-    string_map: MapItem,
-    type_map: MapItem,
-    proto_map: MapItem,
-    field_map: MapItem,
-    method_map: MapItem,
-    class_def_map: MapItem,
-    call_site_map: MapItem,
-    method_handle_map: MapItem,
-    code_item_offsets: Vec<u32>,
-    code_item_instruction_start: Vec<usize>,
-    instructions: Vec<InstructionValue>,
-    type_list_offsets: Vec<u32>,
-    annotation_set_ref_list_offsets: Vec<u32>,
-    annotation_set_offsets: Vec<u32>,
-    annotations_directory_item_offsets: Vec<u32>,
-    field_annotation_offsets: Vec<u32>,
-    method_annotation_offsets: Vec<u32>,
-    parameter_annotation_offsets: Vec<u32>,
-}
-
-fn get_item_base_size(kind: u16) -> usize {
-    match kind {
-        T_STRING_ID => 4,
-        T_TYPE_ID => 4,
-        T_PROTO_ID => 12,
-        T_FIELD_ID => 8,
-        T_METHOD_ID => 8,
-        T_CLASS_DEF => 32,
-        T_CALL_SITE_ID => 4,
-        T_METHOD_HANDLE => 8,
-        T_TYPE_LIST => 4,
-        T_ANNOTATION_SET_REF_LIST => 4,
-        T_ANNOTATION_SET_ITEM => 4,
-        T_CODE_ITEM => CODE_ITEM_HEADER,
-        T_ANNOTATIONS_DIRECTORY => 16,
-        _ => 1,
-    }
-}
-
-fn covers_array(image: &[u8], offset: usize, num: usize, elt_size: usize) -> bool {
-    if elt_size == 0 {
-        return false;
-    }
-    offset <= image.len() && (image.len() - offset) / elt_size >= num
-}
-
-impl DexDisassembler {
-    pub fn parse(image: &[u8]) -> Option<Self> {
-        let (file_size, map_off) = read_dex_header(image)?;
-        let image = &image[..file_size as usize];
-
-        let list_start = map_off as usize;
-        let list_size = read_u32(image, list_start)?;
-        if list_size > K_MAX_ITEM_LIST_SIZE {
-            return None;
-        }
-        let items_start = list_start.checked_add(4)?;
-        let items_end =
-            items_start.checked_add((list_size as usize).checked_mul(MAP_ITEM_SIZE)?)?;
-        if items_end > image.len() {
-            return None;
-        }
-        let mut map: BTreeMap<u16, MapItem> = BTreeMap::new();
-        for index in 0..list_size as usize {
-            let base = items_start + index * MAP_ITEM_SIZE;
-            let kind = read_u16(image, base)?;
-            let size = read_u32(image, base + 4)?;
-            let offset = read_u32(image, base + 8)?;
-            let item_size = get_item_base_size(kind);
-            if !covers_array(image, offset as usize, size as usize, item_size) {
-                return None;
-            }
-            if map.insert(kind, MapItem { size, offset }).is_some() {
-                return None;
-            }
-        }
-
-        let get = |kind: u16| *map.get(&kind).unwrap_or(&MapItem::default());
-
-        let type_list_map = get(T_TYPE_LIST);
-        let annotation_set_ref_map = get(T_ANNOTATION_SET_REF_LIST);
-        let annotation_set_map = get(T_ANNOTATION_SET_ITEM);
-        let annotations_directory_map = get(T_ANNOTATIONS_DIRECTORY);
-        let code_map = get(T_CODE_ITEM);
-
-        let type_list_offsets = parse_item_offsets(image, type_list_map, 2)?;
-        let annotation_set_ref_list_offsets = parse_item_offsets(image, annotation_set_ref_map, 4)?;
-        let annotation_set_offsets = parse_item_offsets(image, annotation_set_map, 4)?;
-        let (
-            annotations_directory_item_offsets,
-            field_annotation_offsets,
-            method_annotation_offsets,
-            parameter_annotation_offsets,
-        ) = parse_annotations_directory_items(image, annotations_directory_map)?;
-
-        let code_item_offsets = parse_code_item_offsets(image, code_map)?;
-        if code_item_offsets.is_empty() {
-            return None;
-        }
-
-        // Parse every code item's instruction stream once. All 42 reference
-        // groups then filter this flat, location-sorted list instead of
-        // re-decoding instructions for every group and equivalence range.
-        let mut code_item_instruction_start = Vec::new();
-        code_item_instruction_start.try_reserve_exact(code_item_offsets.len()).ok()?;
-        let mut instructions = Vec::new();
-        for &offset in &code_item_offsets {
-            code_item_instruction_start.push(instructions.len());
-            let parsed = parse_instructions(image, offset).ok()?;
-            instructions.try_reserve(parsed.len()).ok()?;
-            instructions.extend_from_slice(&parsed);
-        }
-
-        Some(DexDisassembler {
-            size: file_size,
-            groups: build_groups(),
-            string_map: get(T_STRING_ID),
-            type_map: get(T_TYPE_ID),
-            proto_map: get(T_PROTO_ID),
-            field_map: get(T_FIELD_ID),
-            method_map: get(T_METHOD_ID),
-            class_def_map: get(T_CLASS_DEF),
-            call_site_map: get(T_CALL_SITE_ID),
-            method_handle_map: get(T_METHOD_HANDLE),
-            code_item_offsets,
-            code_item_instruction_start,
-            instructions,
-            type_list_offsets,
-            annotation_set_ref_list_offsets,
-            annotation_set_offsets,
-            annotations_directory_item_offsets,
-            field_annotation_offsets,
-            method_annotation_offsets,
-            parameter_annotation_offsets,
-        })
-    }
-}
-
-fn read_dex_header(image: &[u8]) -> Option<(u32, u32)> {
-    if image.len() < HEADER_SIZE {
-        return None;
-    }
-    let magic = &image[..8];
-    if &magic[..4] != b"dex\n" || magic[7] != 0 {
-        return None;
-    }
-    let mut version = 0u32;
-    for &byte in &magic[4..7] {
-        if !byte.is_ascii_digit() {
-            return None;
-        }
-        version = version * 10 + u32::from(byte - b'0');
-    }
-    if !matches!(version, 35 | 37 | 38 | 39) {
-        return None;
-    }
-    let file_size = read_u32(image, 32)?;
-    let map_off = read_u32(image, 52)?;
-    if file_size > image.len() as u32
-        || file_size < HEADER_SIZE as u32
-        || map_off < HEADER_SIZE as u32
-    {
-        return None;
-    }
-    Some((file_size, map_off))
-}
-
-/// Reads the map item of `desired` type from a (possibly patched) DEX image.
-/// Mirrors the FFI's `ReadDexMapItem` helper.
-pub(crate) fn read_map_item(image: &[u8], desired: u16) -> Option<MapItem> {
-    let (_, map_off) = read_dex_header(image)?;
-    let list_start = map_off as usize;
-    let count = read_u32(image, list_start)?;
-    let items_start = list_start.checked_add(4)?;
-    let items_end = items_start.checked_add((count as usize).checked_mul(MAP_ITEM_SIZE)?)?;
-    if items_end > image.len() {
-        return None;
-    }
-    for index in 0..count as usize {
-        let base = items_start + index * MAP_ITEM_SIZE;
-        if read_u16(image, base)? == desired {
-            return Some(MapItem {
-                size: read_u32(image, base + 4)?,
-                offset: read_u32(image, base + 8)?,
-            });
-        }
-    }
-    None
-}
-
-/// Mirrors the FFI's `ValidateDexWriterWidths`: the narrow fixed-size lists must
-/// fit a 16-bit writer.
-pub(crate) fn narrow_writer_widths_ok(image: &[u8]) -> bool {
-    const NARROW_TYPES: [u16; 6] =
-        [T_TYPE_ID, T_PROTO_ID, T_FIELD_ID, T_METHOD_ID, T_CALL_SITE_ID, T_METHOD_HANDLE];
-    for kind in NARROW_TYPES {
-        if let Some(item) = read_map_item(image, kind) {
-            if item.size > u32::from(u16::MAX) + 1 {
-                return false;
-            }
-        }
-    }
-    true
-}
-
-/// Returns the `string_ids` list bounds from a patched DEX image.
-pub(crate) fn string_ids(image: &[u8]) -> Option<MapItem> {
-    read_map_item(image, T_STRING_ID)
-}
-
-fn parse_item_offsets(image: &[u8], map_item: MapItem, item_width: usize) -> Option<Vec<u32>> {
-    if !covers_array(image, map_item.offset as usize, map_item.size as usize, 4) {
-        return None;
-    }
-    let mut offsets = Vec::new();
-    let upper = image.len().saturating_sub(map_item.offset as usize) / item_width;
-    offsets.try_reserve(upper).ok()?;
-    let mut pos = map_item.offset as usize;
-    for _ in 0..map_item.size {
-        // AlignOn(image, 4).
-        let aligned = align_ceil(pos as u64, 4) as usize;
-        if aligned > image.len() {
-            return None;
-        }
-        pos = aligned;
-        let count = read_u32(image, pos)? as usize;
-        pos += 4;
-        if (image.len() - pos) / item_width < count {
-            return None;
-        }
-        for _ in 0..count {
-            offsets.push(pos as u32);
-            pos += item_width;
-        }
-    }
-    Some(offsets)
-}
-
-fn parse_annotations_directory_items(
-    image: &[u8],
-    map_item: MapItem,
-) -> Option<(Vec<u32>, Vec<u32>, Vec<u32>, Vec<u32>)> {
-    if !covers_array(image, map_item.offset as usize, map_item.size as usize, 16) {
-        return None;
-    }
-    let mut directory_offsets = Vec::new();
-    let mut field_offsets = Vec::new();
-    let mut method_offsets = Vec::new();
-    let mut parameter_offsets = Vec::new();
-    directory_offsets.try_reserve(map_item.size as usize).ok()?;
-    let mut pos = map_item.offset as usize;
-
-    let parse_list =
-        |pos: &mut usize, count: u32, width: usize, out: &mut Vec<u32>| -> Option<()> {
-            if (image.len() - *pos) / width < count as usize {
-                return None;
-            }
-            out.try_reserve(count as usize).ok()?;
-            for _ in 0..count {
-                out.push(*pos as u32);
-                *pos += width;
-            }
-            Some(())
-        };
-
-    for _ in 0..map_item.size {
-        let aligned = align_ceil(pos as u64, 4) as usize;
-        if aligned > image.len() {
-            return None;
-        }
-        pos = aligned;
-        if pos + 16 > image.len() {
-            return None;
-        }
-        directory_offsets.push(pos as u32);
-        let _class_annotations_off = read_u32(image, pos)?;
-        let fields_size = read_u32(image, pos + 4)?;
-        let methods_size = read_u32(image, pos + 8)?;
-        let parameters_size = read_u32(image, pos + 12)?;
-        pos += 16;
-        parse_list(&mut pos, fields_size, 8, &mut field_offsets)?;
-        parse_list(&mut pos, methods_size, 8, &mut method_offsets)?;
-        parse_list(&mut pos, parameters_size, 8, &mut parameter_offsets)?;
-    }
-    Some((directory_offsets, field_offsets, method_offsets, parameter_offsets))
-}
-
-fn parse_code_item_offsets(image: &[u8], code_map: MapItem) -> Option<Vec<u32>> {
-    if !covers_array(image, code_map.offset as usize, code_map.size as usize, CODE_ITEM_HEADER) {
-        return None;
-    }
-    let mut parser = CodeItemParser::new(code_map.offset as usize);
-    let mut offsets = Vec::new();
-    offsets.try_reserve(code_map.size as usize).ok()?;
-    for _ in 0..code_map.size {
-        offsets.push(parser.get_next(image)?);
-    }
-    Some(offsets)
-}
-
-struct CodeItemParser {
-    pos: usize,
-}
-
-impl CodeItemParser {
-    fn new(pos: usize) -> Self {
-        Self { pos }
-    }
-
-    fn get_next(&mut self, image: &[u8]) -> Option<u32> {
-        let aligned = align_ceil(self.pos as u64, 4) as usize;
-        if aligned > image.len() {
-            return None;
-        }
-        self.pos = aligned;
-        let code_item_offset = self.pos;
-        if self.pos + CODE_ITEM_HEADER > image.len() {
-            return None;
-        }
-        let tries_size = read_u16(image, self.pos + 6)? as usize;
-        let insns_size = read_u32(image, self.pos + 12)? as usize;
-        self.pos += CODE_ITEM_HEADER;
-        let insns_bytes = insns_size.checked_mul(2)?;
-        self.pos = self.pos.checked_add(insns_bytes)?;
-        if self.pos > image.len() {
-            return None;
-        }
-        if tries_size > 0 {
-            let aligned = align_ceil(self.pos as u64, 4) as usize;
-            if aligned > image.len() {
-                return None;
-            }
-            self.pos = aligned;
-            self.pos = self.pos.checked_add(tries_size.checked_mul(8)?)?;
-            if self.pos > image.len() {
-                return None;
-            }
-            let handlers_size = get_uleb128(image, &mut self.pos)?;
-            if image.len() - self.pos < handlers_size as usize {
-                return None;
-            }
-            for _ in 0..handlers_size {
-                let encoded_size = get_sleb128(image, &mut self.pos)?;
-                let abs_size = encoded_size.unsigned_abs() as usize;
-                if image.len() - self.pos < abs_size {
-                    return None;
-                }
-                for _ in 0..abs_size {
-                    if !skip_leb128(image, &mut self.pos) || !skip_leb128(image, &mut self.pos) {
-                        return None;
-                    }
-                }
-                if encoded_size <= 0 && !skip_leb128(image, &mut self.pos) {
-                    return None;
-                }
-            }
-        }
-        Some(code_item_offset as u32)
-    }
-}
-
-fn get_uleb128(image: &[u8], pos: &mut usize) -> Option<u32> {
-    let limit = K_MAX_LEB128_SIZE.min(image.len() - *pos) * 7;
-    let mut value = 0u32;
-    let mut shift = 0usize;
-    while shift < limit {
-        let byte = *image.get(*pos)?;
-        *pos += 1;
-        value |= u32::from(byte & 0x7F) << shift;
-        if byte & 0x80 == 0 {
-            return Some(value);
-        }
-        shift += 7;
-    }
-    None
-}
-
-fn get_sleb128(image: &[u8], pos: &mut usize) -> Option<i32> {
-    let limit = K_MAX_LEB128_SIZE.min(image.len() - *pos) * 7;
-    let mut value: i32 = 0;
-    let mut shift = 0usize;
-    while shift < limit {
-        let byte = *image.get(*pos)?;
-        *pos += 1;
-        value |= ((u32::from(byte & 0x7F)) << shift) as i32;
-        if byte & 0x80 == 0 {
-            return Some(if shift == 28 {
-                value
-            } else {
-                let num_bits = 32i32;
-                let s = num_bits - 1 - (shift as i32 + 6);
-                (value << s) >> s
-            });
-        }
-        shift += 7;
-    }
-    None
-}
-
-fn skip_leb128(image: &[u8], pos: &mut usize) -> bool {
-    let limit = K_MAX_LEB128_SIZE.min(image.len() - *pos);
-    for _ in 0..limit {
-        let byte = match image.get(*pos) {
-            Some(byte) => *byte,
-            None => return false,
-        };
-        *pos += 1;
-        if byte & 0x80 == 0 {
-            return true;
-        }
-    }
-    false
-}
-
-fn build_groups() -> Vec<GroupTraits> {
-    const WIDTHS: [u32; 42] = [
-        4, 4, 4, 4, 4, 2, 4, 4, 2, 2, 2, 4, 4, 2, 2, 2, 2, 2, 2, 4, 2, 2, 4, 4, 2, 2, 4, 4, 4, 4,
-        4, 4, 4, 4, 1, 2, 4, 4, 4, 4, 4, 4,
-    ];
-    const POOLS: [u8; 42] = [
-        0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 6, 7, 7, 8, 9,
-        9, 9, 9, 10, 11, 11, 11, 12, 13, 14, 15, 16,
-    ];
-    (0..42)
-        .map(|index| GroupTraits {
-            width: WIDTHS[index],
-            type_tag: index as u8,
-            pool_tag: POOLS[index],
-        })
-        .collect()
-}
-
-// Readers.
-
-#[derive(Clone, Copy)]
-enum ItemMapper {
-    TargetIndex { map: MapItem, item_size: u32, width: u8 },
-    TargetOffset32,
-    MethodHandle { map: MapItem, item_size: u32, min_type: u16, max_type: u16 },
-}
-
-#[derive(Clone, Copy)]
-enum ListMapper {
-    TargetIndex { map: MapItem, item_size: u32, width: u8 },
-    TargetOffset32,
-}
-
-#[derive(Clone, Copy)]
-enum InstrMapper {
-    TargetIndex { map: MapItem, item_size: u32, width: u8 },
-    RelCode8,
-    RelCode16,
-    RelCode32,
-}
-
-#[derive(Clone, Copy, PartialEq)]
-enum CodeFilter {
-    String16,
-    String32,
-    Type,
-    Proto,
-    CallSite,
-    MethodHandle,
-    Field,
-    Method,
-    Rel8,
-    Rel16,
-    Rel32,
-}
-
-fn read_target_index(image: &[u8], map: MapItem, item_size: u32, location: u32, width: u8) -> u32 {
-    let unsafe_idx = if width == 2 {
-        u32::from(read_u16(image, location as usize).unwrap_or(0))
-    } else {
-        read_u32(image, location as usize).unwrap_or(0)
-    };
-    if width == 4 && unsafe_idx == SENTINEL_INDEX {
-        return SENTINEL_INDEX;
-    }
-    if unsafe_idx >= map.size {
-        return K_INVALID_OFFSET;
-    }
-    map.offset.wrapping_add(unsafe_idx.wrapping_mul(item_size))
-}
-
-fn read_target_offset32(image: &[u8], location: u32) -> u32 {
-    let target = read_u32(image, location as usize).unwrap_or(0);
-    if target == SENTINEL_OFFSET {
-        return SENTINEL_OFFSET;
-    }
-    if target as usize >= image.len() {
-        return K_INVALID_OFFSET;
-    }
-    target
-}
-
-fn read_method_handle_field_or_method_id(
-    image: &[u8],
-    map: MapItem,
-    item_size: u32,
-    min_type: u16,
-    max_type: u16,
-    location: u32,
-) -> u32 {
-    let method_handle_type = read_u16(image, location as usize).unwrap_or(0);
-    if method_handle_type >= 0x09 {
-        return K_INVALID_OFFSET;
-    }
-    if method_handle_type < min_type || method_handle_type > max_type {
-        return SENTINEL_INDEX;
-    }
-    read_target_index(image, map, item_size, location + 4, 2)
-}
-
-fn run_item_mapper(mapper: ItemMapper, image: &[u8], input: u32) -> u32 {
-    match mapper {
-        ItemMapper::TargetIndex { map, item_size, width } => {
-            read_target_index(image, map, item_size, input, width)
-        }
-        ItemMapper::TargetOffset32 => read_target_offset32(image, input),
-        ItemMapper::MethodHandle { map, item_size, min_type, max_type } => {
-            read_method_handle_field_or_method_id(image, map, item_size, min_type, max_type, input)
-        }
-    }
-}
-
-fn run_list_mapper(mapper: ListMapper, image: &[u8], location: u32) -> u32 {
-    match mapper {
-        ListMapper::TargetIndex { map, item_size, width } => {
-            read_target_index(image, map, item_size, location, width)
-        }
-        ListMapper::TargetOffset32 => read_target_offset32(image, location),
-    }
-}
-
-fn item_reader(
-    image: &[u8],
-    lo: u32,
-    hi: u32,
-    map: MapItem,
-    item_size: u32,
-    rel_location: u32,
-    mapper: ItemMapper,
-    wants_item: bool,
-) -> Result<Vec<Reference>> {
-    let item_base_offset = map.offset;
-    let num_items = map.size;
-    let mapper_input_delta = if wants_item { 0 } else { rel_location };
-    let offset_of_index = |index: u32| item_base_offset.wrapping_add(index.wrapping_mul(item_size));
-
-    let mut cur_idx: u32;
-    if item_base_offset == 0 {
-        cur_idx = num_items;
-    } else if lo < item_base_offset {
-        cur_idx = 0;
-    } else if lo < offset_of_index(num_items) {
-        cur_idx = (lo - item_base_offset) / item_size;
-        if lo > offset_of_index(cur_idx).wrapping_add(rel_location) {
-            cur_idx += 1;
-        }
-    } else {
-        cur_idx = num_items;
-    }
-
-    let mut result = Vec::new();
-    result
-        .try_reserve(num_items.saturating_sub(cur_idx) as usize)
-        .map_err(|_| super::allocation_error("DEX item references"))?;
-    while cur_idx < num_items {
-        let item_offset = offset_of_index(cur_idx);
-        let location = item_offset.wrapping_add(rel_location);
-        if location >= hi {
-            break;
-        }
-        let target = run_item_mapper(mapper, image, item_offset.wrapping_add(mapper_input_delta));
-        if target == SENTINEL_OFFSET || target == SENTINEL_INDEX {
-            cur_idx += 1;
-            continue;
-        }
-        if target == K_INVALID_OFFSET {
-            break;
-        }
-        cur_idx += 1;
-        if location >= lo {
-            result.push(Reference { location, target });
-        }
-    }
-    Ok(result)
-}
-
-fn cached_item_list_reader(
-    image: &[u8],
-    lo: u32,
-    hi: u32,
-    rel_location: u32,
-    offsets: &[u32],
-    mapper: ListMapper,
-) -> Result<Vec<Reference>> {
-    let mut index = offsets.partition_point(|offset| *offset <= lo);
-    if index != 0 && offsets[index - 1].wrapping_add(rel_location) >= lo {
-        index -= 1;
-    }
-    let mut result = Vec::new();
-    result
-        .try_reserve(offsets.len().saturating_sub(index))
-        .map_err(|_| super::allocation_error("DEX annotation references"))?;
-    while index < offsets.len() {
-        let location = offsets[index].wrapping_add(rel_location);
-        if location >= hi {
-            break;
-        }
-        let target = run_list_mapper(mapper, image, location);
-        if target == K_INVALID_OFFSET {
-            break;
-        }
-        index += 1;
-        if target == SENTINEL_OFFSET {
-            continue;
-        }
-        result.push(Reference { location, target });
-    }
-    Ok(result)
-}
-
-#[derive(Clone, Copy, Debug)]
-struct InstructionValue {
-    instr_offset: u32,
-    opcode: u8,
-    format: Format,
-}
-
-fn code_item_insns(image: &[u8], base_offset: u32) -> Option<(usize, usize)> {
-    let base = base_offset as usize;
-    if base + CODE_ITEM_HEADER > image.len() {
-        return None;
-    }
-    let insns_size = read_u32(image, base + 12)? as usize;
-    let start = base + CODE_ITEM_HEADER;
-    let end = start.checked_add(insns_size.checked_mul(2)?)?;
-    if end > image.len() {
-        return None;
-    }
-    Some((start, end))
-}
-
-fn parse_instructions(image: &[u8], base_offset: u32) -> Result<Vec<InstructionValue>> {
-    let Some((insns_start, insns_end)) = code_item_insns(image, base_offset) else {
-        return Ok(Vec::new());
-    };
-    let mut pos = insns_start;
-    let mut boundary = insns_end;
-    let mut result = Vec::new();
-    result
-        .try_reserve((insns_end - insns_start) / 2)
-        .map_err(|_| super::allocation_error("DEX instructions"))?;
-    while pos < boundary {
-        let raw_opcode = image[pos];
-        let Some(instruction) = find_instruction(raw_opcode) else { break };
-        let length_bytes = instruction.layout as usize * 2;
-        if insns_end - pos < length_bytes {
-            break;
-        }
-        // Filters compare the canonical range-start opcode
-        // (native `value.instr->opcode`), not the raw byte.
-        let opcode = instruction.opcode;
-        if opcode == 0x26 || opcode == 0x2B || opcode == 0x2C {
-            let payload_rel = read_i32(image, pos + 2).unwrap_or(0);
-            // The native bound is relative to the remaining instruction bytes
-            // from the current instruction, not the whole code item.
-            let remaining_units = (insns_end - pos) as u32 / 2;
-            if payload_rel < i32::from(instruction.layout) || payload_rel as u32 >= remaining_units
-            {
-                break;
-            }
-            boundary = boundary.min(pos + payload_rel as usize * 2);
-        }
-        result.push(InstructionValue {
-            instr_offset: pos as u32,
-            opcode,
-            format: instruction.format,
-        });
-        pos += length_bytes;
-    }
-    Ok(result)
-}
-
-fn filter_location(filter: CodeFilter, value: InstructionValue) -> Option<u32> {
-    let format_c = value.format == Format::C;
-    let format_t = value.format == Format::T;
-    let location = match filter {
-        CodeFilter::String16 if format_c && value.opcode == 0x1A => value.instr_offset + 2,
-        CodeFilter::String32 if format_c && value.opcode == 0x1B => value.instr_offset + 2,
-        CodeFilter::Type
-            if format_c
-                && matches!(value.opcode, 0x1C | 0x1F | 0x20 | 0x22 | 0x23 | 0x24 | 0x25) =>
-        {
-            value.instr_offset + 2
-        }
-        CodeFilter::Proto if format_c && matches!(value.opcode, 0xFA | 0xFB) => {
-            value.instr_offset + 6
-        }
-        CodeFilter::Proto if format_c && value.opcode == 0xFF => value.instr_offset + 2,
-        CodeFilter::CallSite if format_c && matches!(value.opcode, 0xFC | 0xFD) => {
-            value.instr_offset + 2
-        }
-        CodeFilter::MethodHandle if format_c && value.opcode == 0xFE => value.instr_offset + 2,
-        CodeFilter::Field if format_c && matches!(value.opcode, 0x52 | 0x60) => {
-            value.instr_offset + 2
-        }
-        CodeFilter::Method if format_c && matches!(value.opcode, 0x6E | 0x74 | 0xFA | 0xFB) => {
-            value.instr_offset + 2
-        }
-        CodeFilter::Rel8 if format_t && value.opcode == 0x28 => value.instr_offset + 1,
-        CodeFilter::Rel16 if format_t && matches!(value.opcode, 0x29 | 0x32 | 0x38) => {
-            value.instr_offset + 2
-        }
-        CodeFilter::Rel32 if format_t && matches!(value.opcode, 0x26 | 0x2A | 0x2B | 0x2C) => {
-            value.instr_offset + 2
-        }
-        _ => return None,
-    };
-    Some(location)
-}
-
-fn run_instr_mapper(mapper: InstrMapper, image: &[u8], location: u32) -> u32 {
-    match mapper {
-        InstrMapper::TargetIndex { map, item_size, width } => {
-            read_target_index(image, map, item_size, location, width)
-        }
-        InstrMapper::RelCode8 => {
-            let delta = read_i8(image, location as usize).unwrap_or(0) as i32;
-            location.wrapping_add((delta - 1).wrapping_mul(2) as u32)
-        }
-        InstrMapper::RelCode16 => {
-            let delta = read_i16(image, location as usize).unwrap_or(0) as i32;
-            location.wrapping_add((delta - 1).wrapping_mul(2) as u32)
-        }
-        InstrMapper::RelCode32 => {
-            let delta = read_i32(image, location as usize).unwrap_or(0);
-            let target = i64::from(location) + i64::from(delta - 1) * 2;
-            if !(0..=u32::MAX as i64).contains(&target) || target >= i64::from(OFFSET_BOUND as u32)
-            {
-                K_INVALID_OFFSET
-            } else {
-                target as u32
-            }
-        }
-    }
-}
-
-fn instruction_reader(
-    image: &[u8],
-    lo: u32,
-    hi: u32,
-    code_item_offsets: &[u32],
-    code_item_instruction_start: &[usize],
-    instructions: &[InstructionValue],
-    filter: CodeFilter,
-    mapper: InstrMapper,
-) -> Result<Vec<Reference>> {
-    if code_item_offsets.is_empty() {
-        return Ok(Vec::new());
-    }
-    let mut index = code_item_offsets.partition_point(|offset| *offset <= lo);
-    if index != 0 {
-        index -= 1;
-    }
-    let start = code_item_instruction_start[index];
-    let mut result = Vec::new();
-    result
-        .try_reserve((hi.saturating_sub(lo) / 2) as usize)
-        .map_err(|_| super::allocation_error("DEX code references"))?;
-    for value in &instructions[start..] {
-        if value.instr_offset >= hi {
-            break;
-        }
-        let Some(location) = filter_location(filter, *value) else { continue };
-        if location == K_INVALID_OFFSET || location < lo {
-            continue;
-        }
-        if location >= hi {
-            break;
-        }
-        let target = run_instr_mapper(mapper, image, location);
-        if target != K_INVALID_OFFSET {
-            result.push(Reference { location, target });
-        }
-    }
-    Ok(result)
-}
-
-// Writers.
-
-#[derive(Clone, Copy)]
-enum WriteKind {
-    StringId16,
-    StringId32,
-    TypeId16,
-    TypeId32,
-    ProtoId16,
-    FieldId16,
-    FieldId32,
-    MethodId16,
-    MethodId32,
-    CallSiteId16,
-    MethodHandle16,
-    Abs32,
-    RelCode8,
-    RelCode16,
-    RelCode32,
-}
-
-fn write_kind(group: usize) -> WriteKind {
-    match group {
-        0 | 1 | 2 | 3 | 4 | 6 => WriteKind::StringId32,
-        5 => WriteKind::StringId16,
-        7 | 11 | 12 => WriteKind::TypeId32,
-        8 | 9 | 10 | 13 | 14 => WriteKind::TypeId16,
-        15 | 16 => WriteKind::ProtoId16,
-        17 | 18 => WriteKind::FieldId16,
-        19 => WriteKind::FieldId32,
-        20 | 21 => WriteKind::MethodId16,
-        22 | 23 => WriteKind::MethodId32,
-        24 => WriteKind::CallSiteId16,
-        25 => WriteKind::MethodHandle16,
-        34 => WriteKind::RelCode8,
-        35 => WriteKind::RelCode16,
-        36 => WriteKind::RelCode32,
-        _ => WriteKind::Abs32,
-    }
-}
-
-impl DexDisassembler {
-    fn write_target_index(
-        &self,
-        image: &mut [u8],
-        map: MapItem,
-        item_size: u32,
-        reference: Reference,
-        width: u8,
-    ) {
-        let unsafe_idx = reference.target.wrapping_sub(map.offset) / item_size;
-        if unsafe_idx >= map.size {
-            return;
-        }
-        if width == 2 {
-            let _ = write_u16(image, reference.location as usize, unsafe_idx as u16);
-        } else {
-            let _ = write_u32(image, reference.location as usize, unsafe_idx);
-        }
-    }
-}
-
-impl Disassembler for DexDisassembler {
-    fn size(&self) -> u32 {
-        self.size
-    }
-
-    fn groups(&self) -> &[GroupTraits] {
-        &self.groups
-    }
-
-    #[allow(clippy::too_many_lines)]
-    fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Result<Vec<Reference>> {
-        // The index field width equals the group's declared reference width for
-        // every index-based mapper (e.g. annotations-directory ids are 32-bit),
-        // so derive it instead of hardcoding per group.
-        let width = self.groups[group].width as u8;
-        let string_index =
-            |width: u8| ItemMapper::TargetIndex { map: self.string_map, item_size: 4, width };
-        let type_index =
-            |width: u8| ItemMapper::TargetIndex { map: self.type_map, item_size: 4, width };
-        let proto_index = ItemMapper::TargetIndex { map: self.proto_map, item_size: 12, width };
-        match group {
-            0 => item_reader(image, lo, hi, self.type_map, 4, 0, string_index(width), false),
-            1 => item_reader(image, lo, hi, self.proto_map, 12, 0, string_index(width), false),
-            2 => item_reader(image, lo, hi, self.field_map, 8, 4, string_index(width), false),
-            3 => item_reader(image, lo, hi, self.method_map, 8, 4, string_index(width), false),
-            4 => item_reader(image, lo, hi, self.class_def_map, 32, 16, string_index(width), false),
-            5 => instruction_reader(
-                image,
-                lo,
-                hi,
-                &self.code_item_offsets,
-                &self.code_item_instruction_start,
-                &self.instructions,
-                CodeFilter::String16,
-                InstrMapper::TargetIndex { map: self.string_map, item_size: 4, width },
-            ),
-            6 => instruction_reader(
-                image,
-                lo,
-                hi,
-                &self.code_item_offsets,
-                &self.code_item_instruction_start,
-                &self.instructions,
-                CodeFilter::String32,
-                InstrMapper::TargetIndex { map: self.string_map, item_size: 4, width },
-            ),
-            7 => item_reader(image, lo, hi, self.proto_map, 12, 4, type_index(width), false),
-            8 => item_reader(image, lo, hi, self.field_map, 8, 0, type_index(width), false),
-            9 => item_reader(image, lo, hi, self.field_map, 8, 2, type_index(width), false),
-            10 => item_reader(image, lo, hi, self.method_map, 8, 0, type_index(width), false),
-            11 => item_reader(image, lo, hi, self.class_def_map, 32, 0, type_index(width), false),
-            12 => item_reader(image, lo, hi, self.class_def_map, 32, 8, type_index(width), false),
-            13 => cached_item_list_reader(
-                image,
-                lo,
-                hi,
-                0,
-                &self.type_list_offsets,
-                ListMapper::TargetIndex { map: self.type_map, item_size: 4, width },
-            ),
-            14 => instruction_reader(
-                image,
-                lo,
-                hi,
-                &self.code_item_offsets,
-                &self.code_item_instruction_start,
-                &self.instructions,
-                CodeFilter::Type,
-                InstrMapper::TargetIndex { map: self.type_map, item_size: 4, width },
-            ),
-            15 => instruction_reader(
-                image,
-                lo,
-                hi,
-                &self.code_item_offsets,
-                &self.code_item_instruction_start,
-                &self.instructions,
-                CodeFilter::Proto,
-                InstrMapper::TargetIndex { map: self.proto_map, item_size: 12, width },
-            ),
-            16 => item_reader(image, lo, hi, self.method_map, 8, 2, proto_index, false),
-            17 => instruction_reader(
-                image,
-                lo,
-                hi,
-                &self.code_item_offsets,
-                &self.code_item_instruction_start,
-                &self.instructions,
-                CodeFilter::Field,
-                InstrMapper::TargetIndex { map: self.field_map, item_size: 8, width },
-            ),
-            18 => item_reader(
-                image,
-                lo,
-                hi,
-                self.method_handle_map,
-                8,
-                2,
-                ItemMapper::MethodHandle {
-                    map: self.field_map,
-                    item_size: 8,
-                    min_type: 0,
-                    max_type: 3,
-                },
-                true,
-            ),
-            19 => cached_item_list_reader(
-                image,
-                lo,
-                hi,
-                0,
-                &self.field_annotation_offsets,
-                ListMapper::TargetIndex { map: self.field_map, item_size: 8, width },
-            ),
-            20 => instruction_reader(
-                image,
-                lo,
-                hi,
-                &self.code_item_offsets,
-                &self.code_item_instruction_start,
-                &self.instructions,
-                CodeFilter::Method,
-                InstrMapper::TargetIndex { map: self.method_map, item_size: 8, width },
-            ),
-            21 => item_reader(
-                image,
-                lo,
-                hi,
-                self.method_handle_map,
-                8,
-                2,
-                ItemMapper::MethodHandle {
-                    map: self.method_map,
-                    item_size: 8,
-                    min_type: 4,
-                    max_type: 8,
-                },
-                true,
-            ),
-            22 => cached_item_list_reader(
-                image,
-                lo,
-                hi,
-                0,
-                &self.method_annotation_offsets,
-                ListMapper::TargetIndex { map: self.method_map, item_size: 8, width },
-            ),
-            23 => cached_item_list_reader(
-                image,
-                lo,
-                hi,
-                0,
-                &self.parameter_annotation_offsets,
-                ListMapper::TargetIndex { map: self.method_map, item_size: 8, width },
-            ),
-            24 => instruction_reader(
-                image,
-                lo,
-                hi,
-                &self.code_item_offsets,
-                &self.code_item_instruction_start,
-                &self.instructions,
-                CodeFilter::CallSite,
-                InstrMapper::TargetIndex { map: self.call_site_map, item_size: 4, width },
-            ),
-            25 => instruction_reader(
-                image,
-                lo,
-                hi,
-                &self.code_item_offsets,
-                &self.code_item_instruction_start,
-                &self.instructions,
-                CodeFilter::MethodHandle,
-                InstrMapper::TargetIndex { map: self.method_handle_map, item_size: 8, width },
-            ),
-            26 => {
-                item_reader(image, lo, hi, self.proto_map, 12, 8, ItemMapper::TargetOffset32, false)
-            }
-            27 => item_reader(
-                image,
-                lo,
-                hi,
-                self.class_def_map,
-                32,
-                12,
-                ItemMapper::TargetOffset32,
-                false,
-            ),
-            28 => cached_item_list_reader(
-                image,
-                lo,
-                hi,
-                4,
-                &self.parameter_annotation_offsets,
-                ListMapper::TargetOffset32,
-            ),
-            29 => cached_item_list_reader(
-                image,
-                lo,
-                hi,
-                0,
-                &self.annotation_set_ref_list_offsets,
-                ListMapper::TargetOffset32,
-            ),
-            30 => cached_item_list_reader(
-                image,
-                lo,
-                hi,
-                0,
-                &self.annotations_directory_item_offsets,
-                ListMapper::TargetOffset32,
-            ),
-            31 => cached_item_list_reader(
-                image,
-                lo,
-                hi,
-                4,
-                &self.field_annotation_offsets,
-                ListMapper::TargetOffset32,
-            ),
-            32 => cached_item_list_reader(
-                image,
-                lo,
-                hi,
-                4,
-                &self.method_annotation_offsets,
-                ListMapper::TargetOffset32,
-            ),
-            33 => item_reader(
-                image,
-                lo,
-                hi,
-                self.class_def_map,
-                32,
-                24,
-                ItemMapper::TargetOffset32,
-                false,
-            ),
-            34 => instruction_reader(
-                image,
-                lo,
-                hi,
-                &self.code_item_offsets,
-                &self.code_item_instruction_start,
-                &self.instructions,
-                CodeFilter::Rel8,
-                InstrMapper::RelCode8,
-            ),
-            35 => instruction_reader(
-                image,
-                lo,
-                hi,
-                &self.code_item_offsets,
-                &self.code_item_instruction_start,
-                &self.instructions,
-                CodeFilter::Rel16,
-                InstrMapper::RelCode16,
-            ),
-            36 => instruction_reader(
-                image,
-                lo,
-                hi,
-                &self.code_item_offsets,
-                &self.code_item_instruction_start,
-                &self.instructions,
-                CodeFilter::Rel32,
-                InstrMapper::RelCode32,
-            ),
-            37 => {
-                item_reader(image, lo, hi, self.string_map, 4, 0, ItemMapper::TargetOffset32, false)
-            }
-            38 => cached_item_list_reader(
-                image,
-                lo,
-                hi,
-                0,
-                &self.annotation_set_offsets,
-                ListMapper::TargetOffset32,
-            ),
-            39 => item_reader(
-                image,
-                lo,
-                hi,
-                self.class_def_map,
-                32,
-                28,
-                ItemMapper::TargetOffset32,
-                false,
-            ),
-            40 => item_reader(
-                image,
-                lo,
-                hi,
-                self.class_def_map,
-                32,
-                20,
-                ItemMapper::TargetOffset32,
-                false,
-            ),
-            41 => item_reader(
-                image,
-                lo,
-                hi,
-                self.call_site_map,
-                4,
-                0,
-                ItemMapper::TargetOffset32,
-                false,
-            ),
-            _ => Ok(Vec::new()),
-        }
-    }
-
-    fn write(&self, group: usize, image: &mut [u8], reference: Reference) {
-        match write_kind(group) {
-            WriteKind::StringId16 => {
-                self.write_target_index(image, self.string_map, 4, reference, 2);
-            }
-            WriteKind::StringId32 => {
-                self.write_target_index(image, self.string_map, 4, reference, 4);
-            }
-            WriteKind::TypeId16 => {
-                self.write_target_index(image, self.type_map, 4, reference, 2);
-            }
-            WriteKind::TypeId32 => {
-                self.write_target_index(image, self.type_map, 4, reference, 4);
-            }
-            WriteKind::ProtoId16 => {
-                self.write_target_index(image, self.proto_map, 12, reference, 2);
-            }
-            WriteKind::FieldId16 => {
-                self.write_target_index(image, self.field_map, 8, reference, 2);
-            }
-            WriteKind::FieldId32 => {
-                self.write_target_index(image, self.field_map, 8, reference, 4);
-            }
-            WriteKind::MethodId16 => {
-                self.write_target_index(image, self.method_map, 8, reference, 2);
-            }
-            WriteKind::MethodId32 => {
-                self.write_target_index(image, self.method_map, 8, reference, 4);
-            }
-            WriteKind::CallSiteId16 => {
-                self.write_target_index(image, self.call_site_map, 4, reference, 2);
-            }
-            WriteKind::MethodHandle16 => {
-                self.write_target_index(image, self.method_handle_map, 8, reference, 2);
-            }
-            WriteKind::Abs32 => {
-                let _ = write_u32(image, reference.location as usize, reference.target);
-            }
-            WriteKind::RelCode8 => {
-                let diff = reference.target as i64 - i64::from(reference.location);
-                let delta = diff / 2 + 1;
-                if i8::try_from(delta).is_ok() {
-                    if let Some(slot) = image.get_mut(reference.location as usize) {
-                        *slot = delta as i8 as u8;
-                    }
-                }
-            }
-            WriteKind::RelCode16 => {
-                let diff = reference.target as i64 - i64::from(reference.location);
-                let delta = diff / 2 + 1;
-                if i16::try_from(delta).is_ok() {
-                    let _ = write_u16(image, reference.location as usize, delta as i16 as u16);
-                }
-            }
-            WriteKind::RelCode32 => {
-                let diff = reference.target as i64 - i64::from(reference.location);
-                let delta = diff / 2 + 1;
-                if i32::try_from(delta).is_ok() {
-                    let _ = write_u32(image, reference.location as usize, delta as i32 as u32);
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn opcode_ff_resolves_to_const_method_type() {
-        // Regression: `0xFF + variant` must not wrap in `u8` arithmetic.
-        let instruction = find_instruction(0xFF).expect("opcode 0xFF must be known");
-        assert_eq!(instruction.layout, 2);
-        assert_eq!(instruction.format, Format::C);
-
-        // Boundary of the 0xD8..=0xE2 variant range must not leak into 0xE3.
-        assert_eq!(find_instruction(0xE2).unwrap().layout, 2);
-        assert!(find_instruction(0xE3).is_none());
-    }
-
-    #[test]
-    fn const_method_type_maps_to_proto_reference() {
-        let value = InstructionValue { instr_offset: 0x40, opcode: 0xFF, format: Format::C };
-        assert_eq!(filter_location(CodeFilter::Proto, value), Some(0x42));
-    }
-
-    #[test]
-    fn payload_bound_is_relative_to_remaining_instructions() {
-        // 10 instruction units: `nop` then `fill-array-data` with payload
-        // offset 9. That offset is valid against the whole item (10 units) but
-        // not against the remaining 9 units, so native stops before emitting it.
-        let mut image = vec![0u8; CODE_ITEM_HEADER + 20];
-        image[12..16].copy_from_slice(&10u32.to_le_bytes()); // insns_size
-        image[16] = 0x00; // nop
-        image[17] = 0x00;
-        image[18] = 0x26; // fill-array-data (3 units)
-        image[19] = 0x00; // vAA
-        image[20..24].copy_from_slice(&9i32.to_le_bytes()); // payload offset
-
-        let instructions = parse_instructions(&image, 0).unwrap();
-        assert_eq!(instructions.len(), 1);
-        assert_eq!(instructions[0].opcode, 0x00);
-    }
-
-    #[test]
-    fn target_index_width_controls_truncation() {
-        // Native reads `TypeIdItem::descriptor_idx` (group 0) and the
-        // annotations-directory ids (groups 19/22/23) as 32-bit indices; a
-        // hardcoded 16-bit read would silently truncate the high bytes.
-        let map = MapItem { size: 3, offset: 100 };
-        let mut image = vec![0u8; 120];
-        image[10..14].copy_from_slice(&0x0001_0002u32.to_le_bytes());
-        assert_eq!(read_target_index(&image, map, 4, 10, 4), K_INVALID_OFFSET);
-        assert_eq!(read_target_index(&image, map, 4, 10, 2), 108);
-    }
-}
-
-#[cfg(test)]
-mod opcode_family_tests {
-    use super::*;
-
-    #[test]
-    fn ranged_opcode_families_use_canonical_start() {
-        let insns = [
-            0x54u8, 0x00, 0x00, 0x00, // iget-object (family 0x52)
-            0x70, 0x00, 0x00, 0x00, 0x00, 0x00, // invoke-direct (family 0x6E)
-            0x33, 0x00, 0x00, 0x00, // cmpg-float (family 0x32)
-            0x39, 0x00, 0x00, 0x00, // if-ne (family 0x38)
-        ];
-        let mut image = vec![0u8; CODE_ITEM_HEADER + insns.len()];
-        image[12..16].copy_from_slice(&((insns.len() / 2) as u32).to_le_bytes());
-        image[CODE_ITEM_HEADER..].copy_from_slice(&insns);
-        let values = parse_instructions(&image, 0).unwrap();
-        let opcodes: Vec<u8> = values.iter().map(|v| v.opcode).collect();
-        assert_eq!(opcodes, vec![0x52, 0x6E, 0x32, 0x38]);
-        assert!(filter_location(CodeFilter::Field, values[0]).is_some());
-        assert!(filter_location(CodeFilter::Method, values[1]).is_some());
-        assert!(filter_location(CodeFilter::Rel16, values[2]).is_some());
-        assert!(filter_location(CodeFilter::Rel16, values[3]).is_some());
-    }
-}
diff --git a/src/zucchini_pure/elf.rs b/src/zucchini_pure/elf.rs
deleted file mode 100644
index 7aff2be..0000000
--- a/src/zucchini_pure/elf.rs
+++ /dev/null
@@ -1,1324 +0,0 @@
-//! Pure-Rust port of `disassembler_elf.cc` + `reloc_elf.cc` + `abs32_utils.cc`
-//! + `rel32_utils.cc` + `rel32_finder.cc` + `address_translator.cc` for apply.
-
-use super::arm;
-use super::bytes::{
-    align_ceil, increment_for_align_ceil2, increment_for_align_ceil4, range_covers,
-    range_is_bounded, read_i32, read_u16, read_u32, read_u64, write_u32, write_u64,
-};
-use super::{Disassembler, GroupTraits, K_INVALID_RVA, Reference, Result};
-
-const K_RVA_BOUND: u32 = 0x7FFF_FFFF;
-const K_SIZE_BOUND: u64 = 0x7FFF_0000;
-
-/// Fallible push: only grows the vector through `try_reserve`.
-fn push_checked<T>(vec: &mut Vec<T>, value: T) -> Option<()> {
-    if vec.len() == vec.capacity() {
-        vec.try_reserve(1).ok()?;
-    }
-    vec.push(value);
-    Some(())
-}
-
-const SHT_PROGBITS: u32 = 1;
-const SHT_RELA: u32 = 4;
-const SHT_NOBITS: u32 = 8;
-const SHT_REL: u32 = 9;
-const SHF_EXECINSTR: u64 = 1 << 2;
-const SHF_TLS: u64 = 1 << 10;
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum ElfKind {
-    X86,
-    X64,
-    AArch32,
-    AArch64,
-}
-
-impl ElfKind {
-    fn bitness(self) -> u32 {
-        match self {
-            ElfKind::X86 | ElfKind::AArch32 => 4,
-            ElfKind::X64 | ElfKind::AArch64 => 8,
-        }
-    }
-
-    fn class(self) -> u8 {
-        match self {
-            ElfKind::X86 | ElfKind::AArch32 => 1,
-            ElfKind::X64 | ElfKind::AArch64 => 2,
-        }
-    }
-
-    fn machine(self) -> u16 {
-        match self {
-            ElfKind::X86 => 3,
-            ElfKind::X64 => 62,
-            ElfKind::AArch32 => 40,
-            ElfKind::AArch64 => 183,
-        }
-    }
-
-    fn shdr_size(self) -> u16 {
-        match self {
-            ElfKind::X86 | ElfKind::AArch32 => 40,
-            ElfKind::X64 | ElfKind::AArch64 => 64,
-        }
-    }
-
-    fn phdr_size(self) -> u16 {
-        match self {
-            ElfKind::X86 | ElfKind::AArch32 => 32,
-            ElfKind::X64 | ElfKind::AArch64 => 56,
-        }
-    }
-
-    fn rel_type(self) -> u32 {
-        match self {
-            ElfKind::X86 | ElfKind::X64 => 8,
-            ElfKind::AArch32 => 23,
-            ElfKind::AArch64 => 0x403,
-        }
-    }
-
-    fn va_width(self) -> u32 {
-        self.bitness()
-    }
-
-    fn is_arm(self) -> bool {
-        matches!(self, ElfKind::AArch32 | ElfKind::AArch64)
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default)]
-struct SectionHeader {
-    sh_type: u32,
-    sh_flags: u64,
-    sh_addr: u64,
-    sh_offset: u64,
-    sh_size: u64,
-    sh_entsize: u64,
-}
-
-#[derive(Clone, Copy, Debug, Default)]
-struct RelocSection {
-    offset: u32,
-    size: u32,
-    entry_size: u32,
-}
-
-#[derive(Clone, Copy, Debug, Default)]
-struct ExecHeader {
-    offset: u32,
-    size: u32,
-    addr: u32,
-}
-
-#[derive(Clone, Copy, Debug, Default)]
-struct Unit {
-    offset_begin: u32,
-    offset_size: u32,
-    rva_begin: u32,
-    rva_size: u32,
-}
-
-impl Unit {
-    fn offset_end(&self) -> u32 {
-        self.offset_begin.wrapping_add(self.offset_size)
-    }
-
-    fn rva_end(&self) -> u32 {
-        self.rva_begin.wrapping_add(self.rva_size)
-    }
-
-    fn covers_offset(&self, offset: u32) -> bool {
-        range_covers(u64::from(self.offset_begin), u64::from(self.offset_size), u64::from(offset))
-    }
-
-    fn covers_rva(&self, rva: u32) -> bool {
-        range_covers(u64::from(self.rva_begin), u64::from(self.rva_size), u64::from(rva))
-    }
-
-    fn has_dangling_rva(&self) -> bool {
-        self.rva_size > self.offset_size
-    }
-
-    fn covers_dangling_rva(&self, rva: u32) -> bool {
-        self.covers_rva(rva) && rva - self.rva_begin >= self.offset_size
-    }
-
-    fn offset_to_rva_unsafe(&self, offset: u32) -> u32 {
-        offset.wrapping_sub(self.offset_begin).wrapping_add(self.rva_begin)
-    }
-
-    fn rva_to_offset_unsafe(&self, rva: u32, fake_offset_begin: u32) -> u32 {
-        let delta = rva.wrapping_sub(self.rva_begin);
-        if delta < self.offset_size {
-            delta.wrapping_add(self.offset_begin)
-        } else {
-            fake_offset_begin.wrapping_add(rva)
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-struct AddressTranslator {
-    by_offset: Vec<Unit>,
-    by_rva: Vec<Unit>,
-    fake_offset_begin: u32,
-}
-
-impl AddressTranslator {
-    fn initialize(&mut self, mut units: Vec<Unit>) -> bool {
-        for unit in &mut units {
-            if !range_is_bounded(
-                u64::from(unit.offset_begin),
-                u64::from(unit.offset_size),
-                u64::from(K_RVA_BOUND),
-            ) || !range_is_bounded(
-                u64::from(unit.rva_begin),
-                u64::from(unit.rva_size),
-                u64::from(K_RVA_BOUND),
-            ) {
-                return false;
-            }
-            unit.offset_size = unit.offset_size.min(unit.rva_size);
-        }
-        units.retain(|unit| unit.rva_size != 0);
-
-        units.sort_by_key(|unit| (unit.rva_begin, unit.rva_size));
-        units.dedup_by(|a, b| a.rva_begin == b.rva_begin && a.rva_size == b.rva_size);
-
-        if units.len() > 1 {
-            let mut slow = 0usize;
-            for fast in 1..units.len() {
-                if units[slow].rva_end() < units[fast].rva_begin {
-                    slow += 1;
-                    units[slow] = units[fast];
-                    continue;
-                }
-                let merge_optional = units[slow].rva_end() == units[fast].rva_begin;
-                if units[fast].offset_begin < units[slow].offset_begin
-                    || units[fast].offset_begin.wrapping_sub(units[slow].offset_begin)
-                        != units[fast].rva_begin.wrapping_sub(units[slow].rva_begin)
-                {
-                    if merge_optional {
-                        slow += 1;
-                        units[slow] = units[fast];
-                        continue;
-                    }
-                    return false;
-                }
-                let dangling_mismatch = (units[fast].has_dangling_rva()
-                    && units[fast].offset_end() < units[slow].offset_end())
-                    || (units[slow].has_dangling_rva()
-                        && units[slow].offset_end() < units[fast].offset_end());
-                if dangling_mismatch {
-                    if merge_optional {
-                        slow += 1;
-                        units[slow] = units[fast];
-                        continue;
-                    }
-                    return false;
-                }
-                units[slow].rva_size = units[slow]
-                    .rva_size
-                    .max(units[fast].rva_end().wrapping_sub(units[slow].rva_begin));
-                units[slow].offset_size = units[slow]
-                    .offset_size
-                    .max(units[fast].offset_end().wrapping_sub(units[slow].offset_begin));
-            }
-            slow += 1;
-            units.truncate(slow);
-        }
-
-        units.sort_by_key(|unit| unit.offset_begin);
-        for pair in units.windows(2) {
-            if pair[0].offset_end() > pair[1].offset_begin {
-                return false;
-            }
-        }
-
-        let mut offset_bound = 0u32;
-        let mut rva_bound = 0u32;
-        for unit in &units {
-            offset_bound = offset_bound.max(unit.offset_end());
-            rva_bound = rva_bound.max(unit.rva_end());
-        }
-        if !range_is_bounded(u64::from(offset_bound), u64::from(rva_bound), u64::from(K_RVA_BOUND))
-        {
-            return false;
-        }
-
-        self.by_offset = Vec::new();
-        if self.by_offset.try_reserve_exact(units.len()).is_err() {
-            return false;
-        }
-        self.by_offset.extend_from_slice(&units);
-        units.sort_by_key(|unit| unit.rva_begin);
-        self.by_rva = units;
-        self.fake_offset_begin = offset_bound;
-        true
-    }
-
-    fn offset_to_unit(&self, offset: u32) -> Option<&Unit> {
-        let index = self.by_offset.partition_point(|unit| unit.offset_begin <= offset);
-        if index == 0 {
-            return None;
-        }
-        let unit = &self.by_offset[index - 1];
-        unit.covers_offset(offset).then_some(unit)
-    }
-
-    fn rva_to_unit(&self, rva: u32) -> Option<&Unit> {
-        let index = self.by_rva.partition_point(|unit| unit.rva_begin <= rva);
-        if index == 0 {
-            return None;
-        }
-        let unit = &self.by_rva[index - 1];
-        unit.covers_rva(rva).then_some(unit)
-    }
-
-    fn offset_to_rva(&self, offset: u32) -> Option<u32> {
-        if offset >= self.fake_offset_begin {
-            let rva = offset.wrapping_sub(self.fake_offset_begin);
-            return match self.rva_to_unit(rva) {
-                Some(unit) if unit.has_dangling_rva() && unit.covers_dangling_rva(rva) => Some(rva),
-                _ => None,
-            };
-        }
-        self.offset_to_unit(offset).map(|unit| unit.offset_to_rva_unsafe(offset))
-    }
-
-    fn rva_to_offset(&self, rva: u32) -> Option<u32> {
-        self.rva_to_unit(rva).map(|unit| unit.rva_to_offset_unsafe(rva, self.fake_offset_begin))
-    }
-}
-
-pub struct ElfDisassembler {
-    kind: ElfKind,
-    size: u32,
-    groups: Vec<GroupTraits>,
-    translator: AddressTranslator,
-    reloc_sections: Vec<RelocSection>,
-    exec_headers: Vec<ExecHeader>,
-    abs32_locations: Vec<u32>,
-    /// Rel32 locations per address type. Intel uses index 0 only.
-    rel32_locations: Vec<Vec<u32>>,
-}
-
-impl ElfDisassembler {
-    pub fn parse(kind: ElfKind, image: &[u8]) -> Option<Self> {
-        let (sections, offset_bound) = parse_elf_header(kind, image)?;
-
-        let mut units = Vec::new();
-        units.try_reserve_exact(sections.len()).ok()?;
-        let mut judgements = Vec::new();
-        judgements.try_reserve_exact(sections.len()).ok()?;
-        judgements.resize(sections.len(), 0i32);
-        let mut offset_bound = offset_bound;
-
-        for (index, section) in sections.iter().enumerate() {
-            let judgement = judge_section(kind, image.len() as u64, section);
-            judgements[index] = judgement;
-            if judgement & 1 == 0 {
-                return None;
-            }
-            let sh_size = section.sh_size as u32;
-            let sh_offset = section.sh_offset as u32;
-            let sh_addr = section.sh_addr as u32;
-            if judgement & (1 << 1) != 0 {
-                units.push(Unit {
-                    offset_begin: sh_offset,
-                    offset_size: sh_size,
-                    rva_begin: sh_addr,
-                    rva_size: sh_size,
-                });
-            }
-            if judgement & (1 << 2) != 0 {
-                let end = sh_offset.checked_add(sh_size)?;
-                offset_bound = offset_bound.max(end);
-            }
-        }
-
-        let mut translator = AddressTranslator::default();
-        if !translator.initialize(units) {
-            return None;
-        }
-
-        let mut disassembler = ElfDisassembler {
-            kind,
-            size: offset_bound,
-            groups: build_groups(kind),
-            translator,
-            reloc_sections: Vec::new(),
-            exec_headers: Vec::new(),
-            abs32_locations: Vec::new(),
-            rel32_locations: vec![Vec::new(); rel32_type_count(kind)],
-        };
-
-        disassembler.extract_interesting_section_headers(&sections, &judgements)?;
-        disassembler.get_abs32_from_reloc_sections(image)?;
-        disassembler.get_rel32_from_code_sections(image)?;
-        Some(disassembler)
-    }
-
-    fn extract_interesting_section_headers(
-        &mut self,
-        sections: &[SectionHeader],
-        judgements: &[i32],
-    ) -> Option<()> {
-        self.reloc_sections.try_reserve(sections.len()).ok()?;
-        self.exec_headers.try_reserve(sections.len()).ok()?;
-        for (index, section) in sections.iter().enumerate() {
-            if judgements[index] & (1 << 3) == 0 {
-                continue;
-            }
-            if is_reloc_section(self.kind, section) {
-                self.reloc_sections.push(RelocSection {
-                    offset: section.sh_offset as u32,
-                    size: section.sh_size as u32,
-                    entry_size: section.sh_entsize as u32,
-                });
-            } else if is_exec_section(section) {
-                self.exec_headers.push(ExecHeader {
-                    offset: section.sh_offset as u32,
-                    size: section.sh_size as u32,
-                    addr: section.sh_addr as u32,
-                });
-            }
-        }
-        self.reloc_sections.sort_by_key(|section| section.offset);
-        self.exec_headers.sort_by_key(|header| header.offset);
-        Some(())
-    }
-
-    fn get_abs32_from_reloc_sections(&mut self, image: &[u8]) -> Option<()> {
-        let relocs = self.read_relocs(image, 0, self.size).ok()?;
-        let mut locations: Vec<u32> = Vec::new();
-        locations.try_reserve_exact(relocs.len()).ok()?;
-        locations.extend(relocs.iter().map(|reference| reference.target));
-        locations.sort_unstable();
-
-        // RemoveUntranslatableAbs32.
-        let mut kept = Vec::new();
-        kept.try_reserve_exact(locations.len()).ok()?;
-        for location in locations {
-            let value = self.read_absolute(location, image);
-            let Some(value) = value else { continue };
-            if value >= u64::from(K_RVA_BOUND) {
-                continue;
-            }
-            let target_rva = value as u32;
-            if self.translator.rva_to_offset(target_rva).is_some() {
-                kept.push(location);
-            }
-        }
-        locations = kept;
-
-        // RemoveOverlappingAbs32Locations.
-        remove_overlapping(self.kind.va_width(), &mut locations);
-        self.abs32_locations = locations;
-        Some(())
-    }
-
-    fn read_absolute(&self, offset: u32, image: &[u8]) -> Option<u64> {
-        if self.kind.bitness() == 4 {
-            read_u32(image, offset as usize).map(u64::from)
-        } else {
-            read_u64(image, offset as usize)
-        }
-    }
-
-    fn get_rel32_from_code_sections(&mut self, image: &[u8]) -> Option<()> {
-        let count = self.exec_headers.len();
-        for index in 0..count {
-            let section = self.exec_headers[index];
-            if !self.kind.is_arm() {
-                self.parse_exec_section_intel(&section, image)?;
-            } else {
-                self.parse_exec_section_arm(&section, image)?;
-            }
-        }
-        for locations in self.rel32_locations.iter_mut() {
-            locations.sort_unstable();
-        }
-        Some(())
-    }
-
-    fn parse_exec_section_intel(&mut self, section: &ExecHeader, image: &[u8]) -> Option<()> {
-        let start_rva = section.addr;
-        let end_rva = start_rva.wrapping_add(section.size);
-        let Some(region) = image.get(section.offset as usize..) else { return Some(()) };
-        let region = &region[..section.size.min(region.len() as u32) as usize];
-        for (gap_start, gap_end) in
-            self.abs32_gaps(section.offset, section.offset.wrapping_add(section.size))?
-        {
-            let mut cursor = gap_start as usize;
-            let gap_end = gap_end as usize;
-            while cursor < gap_end {
-                let candidate = intel_candidate(self.kind, image, cursor, gap_end);
-                if let Some((location, can_point_outside)) = candidate {
-                    if let Some(location_rva) = self.translator.offset_to_rva(location as u32) {
-                        let disp = read_u32(image, location).unwrap_or(0);
-                        let target_rva = location_rva.wrapping_add(4).wrapping_add(disp);
-                        if self.translator.rva_to_offset(target_rva).is_some()
-                            && (can_point_outside
-                                || (start_rva <= target_rva && target_rva < end_rva))
-                        {
-                            push_checked(&mut self.rel32_locations[0], location as u32)?;
-                            cursor = location + 4;
-                            continue;
-                        }
-                    }
-                }
-                cursor += 1;
-            }
-        }
-        let _ = region;
-        Some(())
-    }
-
-    fn parse_exec_section_arm(&mut self, section: &ExecHeader, image: &[u8]) -> Option<()> {
-        let is_thumb2 = if self.kind == ElfKind::AArch32 {
-            is_exec_section_thumb2(image, section)
-        } else {
-            false
-        };
-        let gaps = self.abs32_gaps(section.offset, section.offset.wrapping_add(section.size))?;
-        for (gap_start, gap_end) in gaps {
-            match self.kind {
-                ElfKind::AArch32 => {
-                    let mut cursor = align_gap_start_a32(gap_start, gap_end, is_thumb2);
-                    let step = if is_thumb2 { 2 } else { 4 };
-                    while cursor + step <= gap_end {
-                        let location = cursor as u32;
-                        let Some(instr_rva) = self.translator.offset_to_rva(location) else {
-                            cursor += step;
-                            continue;
-                        };
-                        let advancement = if is_thumb2 {
-                            let (found, size) =
-                                scan_thumb2(image, instr_rva, location, gap_end - cursor);
-                            if let Some((addr_type, target_rva)) = found {
-                                self.record_arm_rel32(addr_type, target_rva, location)?;
-                            }
-                            size
-                        } else {
-                            if let Some((addr_type, target_rva, _)) =
-                                scan_arm32(image, instr_rva, location)
-                            {
-                                self.record_arm_rel32(addr_type, target_rva, location)?;
-                            }
-                            4
-                        };
-                        // Native always advances by the decoded instruction size,
-                        // including when no reference type matches.
-                        cursor += advancement as usize;
-                    }
-                }
-                ElfKind::AArch64 => {
-                    let mut cursor =
-                        gap_start + increment_for_align_ceil4(gap_start as u64) as usize;
-                    while cursor + 4 <= gap_end {
-                        let location = cursor as u32;
-                        if let Some(instr_rva) = self.translator.offset_to_rva(location) {
-                            if let Some((addr_type, target_rva)) =
-                                scan_aarch64(image, instr_rva, location)
-                            {
-                                if let Some(target_offset) =
-                                    self.translator.rva_to_offset(target_rva)
-                                {
-                                    if self.is_target_in_exec_section(target_offset) {
-                                        push_checked(
-                                            &mut self.rel32_locations[addr_type as usize],
-                                            location,
-                                        )?;
-                                    }
-                                }
-                            }
-                        }
-                        cursor += 4;
-                    }
-                }
-                _ => unreachable!(),
-            }
-        }
-        Some(())
-    }
-
-    fn record_arm_rel32(&mut self, addr_type: u8, target_rva: u32, location: u32) -> Option<()> {
-        if let Some(target_offset) = self.translator.rva_to_offset(target_rva) {
-            if self.is_target_in_exec_section(target_offset) {
-                push_checked(&mut self.rel32_locations[addr_type as usize], location)?;
-            }
-        }
-        Some(())
-    }
-
-    fn is_target_in_exec_section(&self, offset: u32) -> bool {
-        let index = self.exec_headers.partition_point(|header| header.offset <= offset);
-        if index == 0 {
-            return false;
-        }
-        let header = self.exec_headers[index - 1];
-        offset >= header.offset && offset - header.offset < header.size
-    }
-
-    /// Mirrors `Abs32GapFinder`: non-empty gaps in `[region_start, region_end)`
-    /// that do not overlap an abs32 body.
-    fn abs32_gaps(&self, region_start: u32, region_end: u32) -> Option<Vec<(usize, usize)>> {
-        let width = self.kind.va_width();
-        let mut gaps = Vec::new();
-        gaps.try_reserve(self.abs32_locations.len().saturating_add(1)).ok()?;
-        let mut current = self.abs32_locations.partition_point(|location| *location < region_start);
-        let mut cur_lo = region_start;
-        if current > 0 {
-            let previous = self.abs32_locations[current - 1];
-            cur_lo = cur_lo.max(previous.saturating_add(width));
-        }
-        while current < self.abs32_locations.len() && self.abs32_locations[current] < region_end {
-            let hi = self.abs32_locations[current];
-            if hi > cur_lo {
-                gaps.push((cur_lo as usize, hi as usize));
-            }
-            cur_lo = hi.saturating_add(width);
-            current += 1;
-        }
-        if cur_lo < region_end {
-            gaps.push((cur_lo as usize, region_end as usize));
-        }
-        Some(gaps)
-    }
-
-    fn read_relocs(&self, image: &[u8], lo: u32, hi: u32) -> Result<Vec<Reference>> {
-        if self.reloc_sections.is_empty() {
-            return Ok(Vec::new());
-        }
-        let mut result = Vec::new();
-        // Upper bound: one reference per relocation entry in the range.
-        let upper = ((hi.saturating_sub(lo)) as usize) / 4 + 1;
-        result
-            .try_reserve(upper)
-            .map_err(|_| super::allocation_error("ELF relocation references"))?;
-        let bitness = self.kind.bitness();
-        let rel_type = self.kind.rel_type();
-
-        let mut current = self.reloc_sections.partition_point(|section| section.offset <= lo);
-        if current > 0 {
-            current -= 1;
-        }
-        let mut cursor = self.reloc_sections[current].offset;
-        if cursor < lo {
-            cursor += align_ceil(
-                u64::from(lo - cursor),
-                u64::from(self.reloc_sections[current].entry_size),
-            ) as u32;
-        }
-
-        let mut hi = hi;
-        let end_index = self.reloc_sections.partition_point(|section| section.offset <= hi);
-        if end_index > 0 {
-            let section = self.reloc_sections[end_index - 1];
-            if hi - section.offset < section.size {
-                hi = section.offset
-                    + align_ceil(u64::from(hi - section.offset), u64::from(section.entry_size))
-                        as u32;
-            }
-        }
-
-        loop {
-            while current < self.reloc_sections.len()
-                && cursor >= self.reloc_sections[current].offset + self.reloc_sections[current].size
-            {
-                current += 1;
-                if current == self.reloc_sections.len() {
-                    return Ok(result);
-                }
-                cursor = self.reloc_sections[current].offset;
-                if cursor + self.reloc_sections[current].entry_size > hi {
-                    return Ok(result);
-                }
-            }
-            if current >= self.reloc_sections.len() {
-                return Ok(result);
-            }
-            let entry_size = self.reloc_sections[current].entry_size;
-            if cursor + entry_size > hi {
-                return Ok(result);
-            }
-
-            let (r_offset, r_info) = if bitness == 4 {
-                (
-                    read_u32(image, cursor as usize).unwrap_or(0),
-                    read_u32(image, cursor as usize + 4).unwrap_or(0) as u64,
-                )
-            } else {
-                (
-                    read_u64(image, cursor as usize).unwrap_or(0) as u32,
-                    read_u64(image, cursor as usize + 8).unwrap_or(0),
-                )
-            };
-            let rel_type_value =
-                if bitness == 4 { (r_info & 0xFF) as u32 } else { (r_info & 0xFFFF_FFFF) as u32 };
-            if rel_type_value == rel_type {
-                let valid_r_offset =
-                    bitness == 4 || (r_offset as u64 & 0xFFFF_FFFF) == r_offset as u64;
-                if valid_r_offset {
-                    if let Some(target) = self.translator.rva_to_offset(r_offset) {
-                        if range_covers(0, image.len() as u64, u64::from(target))
-                            && target as usize + (bitness as usize) <= image.len()
-                        {
-                            result.push(Reference { location: cursor, target });
-                        }
-                    }
-                }
-            }
-            cursor += entry_size;
-        }
-    }
-
-    fn read_abs32(&self, image: &[u8], lo: u32, hi: u32) -> Result<Vec<Reference>> {
-        let mut result = Vec::new();
-        let start = self.abs32_locations.partition_point(|location| *location < lo);
-        let end = self.abs32_locations.partition_point(|location| *location < hi);
-        result
-            .try_reserve(end.saturating_sub(start))
-            .map_err(|_| super::allocation_error("ELF abs32 references"))?;
-        for &location in &self.abs32_locations[start..end] {
-            let Some(value) = self.read_absolute(location, image) else { continue };
-            if value >= u64::from(K_RVA_BOUND) {
-                continue;
-            }
-            if let Some(target) = self.translator.rva_to_offset(value as u32) {
-                result.push(Reference { location, target });
-            }
-        }
-        Ok(result)
-    }
-
-    fn read_rel32_intel(&self, image: &[u8], lo: u32, hi: u32) -> Result<Vec<Reference>> {
-        let mut result = Vec::new();
-        let locations = &self.rel32_locations[0];
-        let start = locations.partition_point(|location| *location < lo);
-        let end = locations.partition_point(|location| *location < hi);
-        result
-            .try_reserve(end.saturating_sub(start))
-            .map_err(|_| super::allocation_error("ELF rel32 references"))?;
-        for &location in &locations[start..end] {
-            let Some(location_rva) = self.translator.offset_to_rva(location) else { continue };
-            let disp = read_i32(image, location as usize).unwrap_or(0);
-            let target_rva = location_rva.wrapping_add(4).wrapping_add(disp as u32);
-            if let Some(target) = self.translator.rva_to_offset(target_rva) {
-                result.push(Reference { location, target });
-            }
-        }
-        Ok(result)
-    }
-
-    fn read_rel32_arm(
-        &self,
-        image: &[u8],
-        addr_type: usize,
-        lo: u32,
-        hi: u32,
-    ) -> Result<Vec<Reference>> {
-        let mut result = Vec::new();
-        let locations = &self.rel32_locations[addr_type];
-        let start = locations.partition_point(|location| *location < lo);
-        let end = locations.partition_point(|location| *location < hi);
-        result
-            .try_reserve(end.saturating_sub(start))
-            .map_err(|_| super::allocation_error("ELF ARM rel32 references"))?;
-        for &location in &locations[start..end] {
-            let Some(instr_rva) = self.translator.offset_to_rva(location) else { continue };
-            let target_rva = if self.kind == ElfKind::AArch32 {
-                fetch_and_read_a32(image, addr_type, location, instr_rva)
-            } else {
-                fetch_and_read_a64(image, addr_type, location, instr_rva)
-            };
-            if let Some(target_rva) = target_rva {
-                if let Some(target) = self.translator.rva_to_offset(target_rva) {
-                    result.push(Reference { location, target });
-                }
-            }
-        }
-        Ok(result)
-    }
-
-    fn write_reloc(&self, image: &mut [u8], reference: Reference) {
-        let target_rva = self.translator.offset_to_rva(reference.target).unwrap_or(K_INVALID_RVA);
-        if self.kind.bitness() == 4 {
-            let _ = write_u32(image, reference.location as usize, target_rva);
-        } else {
-            let _ = write_u64(image, reference.location as usize, u64::from(target_rva));
-        }
-    }
-
-    fn write_abs32(&self, image: &mut [u8], reference: Reference) {
-        let Some(target_rva) = self.translator.offset_to_rva(reference.target) else { return };
-        if self.kind.bitness() == 4 {
-            let _ = write_u32(image, reference.location as usize, target_rva);
-        } else {
-            let _ = write_u64(image, reference.location as usize, u64::from(target_rva));
-        }
-    }
-
-    fn write_rel32_intel(&self, image: &mut [u8], reference: Reference) {
-        let target_rva = self.translator.offset_to_rva(reference.target).unwrap_or(K_INVALID_RVA);
-        let location_rva =
-            self.translator.offset_to_rva(reference.location).unwrap_or(K_INVALID_RVA);
-        let code = target_rva.wrapping_sub(location_rva.wrapping_add(4));
-        let _ = write_u32(image, reference.location as usize, code);
-    }
-
-    fn write_rel32_arm(&self, image: &mut [u8], addr_type: usize, reference: Reference) {
-        let instr_rva = self.translator.offset_to_rva(reference.location).unwrap_or(K_INVALID_RVA);
-        let target_rva = self.translator.offset_to_rva(reference.target).unwrap_or(K_INVALID_RVA);
-        if self.kind == ElfKind::AArch32 {
-            write_arm32(image, addr_type, reference.location, instr_rva, target_rva);
-        } else {
-            write_aarch64(image, addr_type, reference.location, instr_rva, target_rva);
-        }
-    }
-}
-
-impl Disassembler for ElfDisassembler {
-    fn size(&self) -> u32 {
-        self.size
-    }
-
-    fn groups(&self) -> &[GroupTraits] {
-        &self.groups
-    }
-
-    fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Result<Vec<Reference>> {
-        if group == 0 {
-            return self.read_relocs(image, lo, hi);
-        }
-        if group == 1 {
-            return self.read_abs32(image, lo, hi);
-        }
-        match self.kind {
-            ElfKind::X86 | ElfKind::X64 => self.read_rel32_intel(image, lo, hi),
-            ElfKind::AArch32 | ElfKind::AArch64 => {
-                // Group index == address type index + 2 for ARM.
-                let addr_type = group - 2;
-                if addr_type < self.rel32_locations.len() {
-                    self.read_rel32_arm(image, addr_type, lo, hi)
-                } else {
-                    Ok(Vec::new())
-                }
-            }
-        }
-    }
-
-    fn write(&self, group: usize, image: &mut [u8], reference: Reference) {
-        if group == 0 {
-            self.write_reloc(image, reference);
-        } else if group == 1 {
-            self.write_abs32(image, reference);
-        } else {
-            match self.kind {
-                ElfKind::X86 | ElfKind::X64 => self.write_rel32_intel(image, reference),
-                ElfKind::AArch32 | ElfKind::AArch64 => {
-                    self.write_rel32_arm(image, group - 2, reference);
-                }
-            }
-        }
-    }
-}
-
-fn rel32_type_count(kind: ElfKind) -> usize {
-    match kind {
-        ElfKind::X86 | ElfKind::X64 => 1,
-        ElfKind::AArch32 => 5,
-        ElfKind::AArch64 => 3,
-    }
-}
-
-fn build_groups(kind: ElfKind) -> Vec<GroupTraits> {
-    let mut groups = Vec::new();
-    let reloc_width = kind.bitness();
-    groups.push(GroupTraits { width: reloc_width, type_tag: 0, pool_tag: 0 });
-    groups.push(GroupTraits { width: kind.va_width(), type_tag: 1, pool_tag: 1 });
-    match kind {
-        ElfKind::X86 | ElfKind::X64 => {
-            groups.push(GroupTraits { width: 4, type_tag: 2, pool_tag: 2 });
-        }
-        ElfKind::AArch32 => {
-            groups.push(GroupTraits { width: 4, type_tag: 2, pool_tag: 2 }); // A24
-            groups.push(GroupTraits { width: 2, type_tag: 3, pool_tag: 2 }); // T8
-            groups.push(GroupTraits { width: 2, type_tag: 4, pool_tag: 2 }); // T11
-            groups.push(GroupTraits { width: 4, type_tag: 5, pool_tag: 2 }); // T20
-            groups.push(GroupTraits { width: 4, type_tag: 6, pool_tag: 2 }); // T24
-        }
-        ElfKind::AArch64 => {
-            groups.push(GroupTraits { width: 4, type_tag: 2, pool_tag: 2 }); // Immd14
-            groups.push(GroupTraits { width: 4, type_tag: 3, pool_tag: 2 }); // Immd19
-            groups.push(GroupTraits { width: 4, type_tag: 4, pool_tag: 2 }); // Immd26
-        }
-    }
-    groups
-}
-
-fn judge_section(_kind: ElfKind, image_size: u64, section: &SectionHeader) -> i32 {
-    // Bit flags mirror `SectionJudgement`.
-    const SAFE: i32 = 1 << 0;
-    const USEFUL_ADDRESS: i32 = 1 << 1;
-    const USEFUL_BOUND: i32 = 1 << 2;
-    const MAYBE_POINTERS: i32 = 1 << 3;
-    const USELESS: i32 = SAFE;
-
-    if !region_fits(section.sh_addr, section.sh_size, K_SIZE_BOUND) {
-        return 0;
-    }
-    let offset_bound = if section.sh_type == SHT_NOBITS { K_SIZE_BOUND } else { image_size };
-    if !region_fits(section.sh_offset, section.sh_size, offset_bound) {
-        return 0;
-    }
-    if section.sh_size == 0 {
-        return USELESS;
-    }
-    if section.sh_addr == 0 {
-        return USELESS;
-    }
-    if section.sh_type == SHT_NOBITS {
-        if section.sh_flags & SHF_TLS != 0 {
-            return USELESS;
-        }
-        return SAFE | USEFUL_ADDRESS;
-    }
-    SAFE | USEFUL_ADDRESS | USEFUL_BOUND | MAYBE_POINTERS
-}
-
-fn region_fits(offset: u64, size: u64, container: u64) -> bool {
-    offset <= container && container - offset >= size
-}
-
-fn is_reloc_section(kind: ElfKind, section: &SectionHeader) -> bool {
-    if section.sh_type == SHT_REL {
-        return section.sh_entsize == kind.bitness() as u64 * 2;
-    }
-    if section.sh_type == SHT_RELA {
-        return section.sh_entsize == kind.bitness() as u64 * 2 + kind.bitness() as u64;
-    }
-    false
-}
-
-fn is_exec_section(section: &SectionHeader) -> bool {
-    section.sh_type == SHT_PROGBITS && section.sh_flags & SHF_EXECINSTR != 0
-}
-
-fn remove_overlapping(width: u32, locations: &mut Vec<u32>) {
-    if locations.len() <= 1 {
-        return;
-    }
-    let mut slow = 0usize;
-    let mut fast = 1usize;
-    loop {
-        while fast < locations.len() && locations[fast] - locations[slow] < width {
-            fast += 1;
-        }
-        slow += 1;
-        if fast == locations.len() {
-            break;
-        }
-        if slow != fast {
-            locations[slow] = locations[fast];
-        }
-        fast += 1;
-    }
-    locations.truncate(slow);
-}
-
-/// Parses the ELF header, section table, program table, and derives the
-/// `offset_bound` estimate. Mirrors `DisassemblerElf::ParseHeader`.
-fn parse_elf_header(kind: ElfKind, image: &[u8]) -> Option<(Vec<SectionHeader>, u32)> {
-    if u64::from(kind.class()) != 0 {
-        // QuickDetect checks.
-        if image.len() < 16 || &image[..4] != b"\x7FELF" {
-            return None;
-        }
-        if image[4] != kind.class() || image[5] != 1 {
-            return None;
-        }
-        let e_type = read_u16(image, 16)?;
-        if e_type != 2 && e_type != 3 {
-            return None;
-        }
-        let e_machine = read_u16(image, 18)?;
-        let e_version = read_u32(image, 20)?;
-        if e_version != 1 || image[6] != 1 || e_machine != kind.machine() {
-            return None;
-        }
-        let e_shentsize = read_u16(image, if kind.class() == 2 { 58 } else { 46 })?;
-        if e_shentsize != kind.shdr_size() {
-            return None;
-        }
-    }
-
-    let (e_shoff, e_phoff, e_shnum, e_phnum, e_shstrndx, e_phentsize) = if kind.class() == 2 {
-        (
-            read_u64(image, 40)?,
-            read_u64(image, 32)?,
-            read_u16(image, 60)?,
-            read_u16(image, 56)?,
-            read_u16(image, 62)?,
-            read_u16(image, 54)?,
-        )
-    } else {
-        (
-            u64::from(read_u32(image, 32)?),
-            u64::from(read_u32(image, 28)?),
-            read_u16(image, 48)?,
-            read_u16(image, 44)?,
-            read_u16(image, 50)?,
-            read_u16(image, 42)?,
-        )
-    };
-    if e_phentsize != kind.phdr_size() {
-        // Not part of QuickDetect, but the array read would fail anyway.
-    }
-
-    let sections_count = e_shnum as usize;
-    let shdr_size = kind.shdr_size() as usize;
-    let sections_start = usize::try_from(e_shoff).ok()?;
-    let sections_end = sections_start.checked_add(sections_count.checked_mul(shdr_size)?)?;
-    if sections_end > image.len() {
-        return None;
-    }
-    let mut sections = Vec::new();
-    sections.try_reserve(sections_count).ok()?;
-    for index in 0..sections_count {
-        let base = sections_start + index * shdr_size;
-        sections.push(parse_shdr(kind, image, base)?);
-    }
-    let section_table_end = sections_end as u32;
-
-    let segments_count = e_phnum as usize;
-    let phdr_size = kind.phdr_size() as usize;
-    let segments_start = usize::try_from(e_phoff).ok()?;
-    let segments_end = segments_start.checked_add(segments_count.checked_mul(phdr_size)?)?;
-    if segments_end > image.len() {
-        return None;
-    }
-    let segment_table_end = segments_end as u32;
-
-    // String section check.
-    let string_section_id = e_shstrndx as usize;
-    if string_section_id >= sections_count {
-        return None;
-    }
-    let section_names_size = sections[string_section_id].sh_size;
-    if section_names_size > 0 {
-        let offset = usize::try_from(sections[string_section_id].sh_offset).ok()?;
-        let end = offset.checked_add(usize::try_from(section_names_size).ok()?)?;
-        let names = image.get(offset..end)?;
-        if *names.last()? != 0 {
-            return None;
-        }
-    }
-
-    let mut offset_bound = section_table_end.max(segment_table_end);
-    for index in 0..segments_count {
-        let base = segments_start + index * phdr_size;
-        let (p_offset, p_filesz) = parse_phdr(kind, image, base)?;
-        // Validate the original 64-bit values before narrowing to offset_t.
-        let segment_end = p_offset.checked_add(p_filesz)?;
-        if segment_end > u64::from(u32::MAX) {
-            return None;
-        }
-        if !region_fits(p_offset, p_filesz, image.len() as u64) {
-            return None;
-        }
-        offset_bound = offset_bound.max(segment_end as u32);
-    }
-
-    Some((sections, offset_bound))
-}
-
-fn parse_shdr(kind: ElfKind, image: &[u8], base: usize) -> Option<SectionHeader> {
-    if kind.class() == 2 {
-        Some(SectionHeader {
-            sh_type: read_u32(image, base + 4)?,
-            sh_flags: read_u64(image, base + 8)?,
-            sh_addr: read_u64(image, base + 16)?,
-            sh_offset: read_u64(image, base + 24)?,
-            sh_size: read_u64(image, base + 32)?,
-            sh_entsize: read_u64(image, base + 56)?,
-        })
-    } else {
-        Some(SectionHeader {
-            sh_type: read_u32(image, base + 4)?,
-            sh_flags: u64::from(read_u32(image, base + 8)?),
-            sh_addr: u64::from(read_u32(image, base + 12)?),
-            sh_offset: u64::from(read_u32(image, base + 16)?),
-            sh_size: u64::from(read_u32(image, base + 20)?),
-            sh_entsize: u64::from(read_u32(image, base + 36)?),
-        })
-    }
-}
-
-fn parse_phdr(kind: ElfKind, image: &[u8], base: usize) -> Option<(u64, u64)> {
-    if kind.class() == 2 {
-        Some((read_u64(image, base + 8)?, read_u64(image, base + 32)?))
-    } else {
-        Some((u64::from(read_u32(image, base + 4)?), u64::from(read_u32(image, base + 16)?)))
-    }
-}
-
-fn is_exec_section_thumb2(image: &[u8], section: &ExecHeader) -> bool {
-    if section.addr % 4 != 0 || section.size % 4 != 0 {
-        return true;
-    }
-    let start = section.offset as usize;
-    let end = start + section.size as usize;
-    let Some(data) = image.get(start..end) else { return true };
-    let mut num = 0usize;
-    let mut den = 0usize;
-    let mut cursor = 0usize;
-    while cursor + 4 <= data.len() {
-        if data[cursor + 3] & 0xF0 == 0xE0 {
-            num += 1;
-        }
-        den += 1;
-        cursor += 4;
-    }
-    num < (den as f64 * 0.4) as usize
-}
-
-fn intel_candidate(
-    kind: ElfKind,
-    image: &[u8],
-    cursor: usize,
-    region_end: usize,
-) -> Option<(usize, bool)> {
-    if cursor + 5 <= region_end {
-        let first = *image.get(cursor)?;
-        if first == 0xE8 || first == 0xE9 {
-            return Some((cursor + 1, false));
-        }
-    }
-    if cursor + 6 <= region_end {
-        let c0 = *image.get(cursor)?;
-        let c1 = *image.get(cursor + 1)?;
-        if c0 == 0x0F && (c1 & 0xF0) == 0x80 {
-            return Some((cursor + 2, false));
-        }
-        if kind == ElfKind::X64
-            && ((c0 == 0xFF && (c1 == 0x15 || c1 == 0x25))
-                || ((c0 == 0x89 || c0 == 0x8B || c0 == 0x8D) && (c1 & 0xC7) == 0x05))
-        {
-            return Some((cursor + 2, true));
-        }
-    }
-    None
-}
-
-fn align_gap_start_a32(gap_start: usize, gap_end: usize, is_thumb2: bool) -> usize {
-    if is_thumb2 {
-        if gap_end.saturating_sub(gap_start) < 2 {
-            return gap_end;
-        }
-        gap_start + increment_for_align_ceil2(gap_start as u64) as usize
-    } else {
-        if gap_end.saturating_sub(gap_start) < 4 {
-            return gap_end;
-        }
-        gap_start + increment_for_align_ceil4(gap_start as u64) as usize
-    }
-}
-
-/// Returns `(addr_type, target_rva, instruction_size)` for ARM mode.
-fn scan_arm32(image: &[u8], instr_rva: u32, location: u32) -> Option<(u8, u32, u32)> {
-    let code32 = arm::fetch_arm_code32(image, location);
-    arm::read_a24(instr_rva, code32).map(|target| (0u8, target, 4u32))
-}
-
-/// Returns `(addr_type, target_rva, instruction_size)` for THUMB2 mode.
-/// Returns `(reference, instruction_size)` for THUMB2. Native always advances
-/// by the decoded instruction size, even when no reference type matches.
-fn scan_thumb2(
-    image: &[u8],
-    instr_rva: u32,
-    location: u32,
-    available: usize,
-) -> (Option<(u8, u32)>, u32) {
-    let code16 = arm::fetch_thumb2_code16(image, location);
-    let instr_size = arm::get_thumb2_instruction_size(code16);
-    if instr_size == 2 {
-        if let Some(target) = arm::read_t8(instr_rva, code16) {
-            return (Some((1, target)), 2);
-        }
-        if let Some(target) = arm::read_t11(instr_rva, code16) {
-            return (Some((2, target)), 2);
-        }
-        return (None, 2);
-    }
-    if available < 4 {
-        // Native does not fetch the second half if it lies outside the region.
-        return (None, 4);
-    }
-    let code32 = arm::fetch_thumb2_code32(image, location);
-    if let Some(target) = arm::read_t20(instr_rva, code32) {
-        return (Some((3, target)), 4);
-    }
-    if let Some(target) = arm::read_t24(instr_rva, code32) {
-        return (Some((4, target)), 4);
-    }
-    (None, 4)
-}
-
-fn scan_aarch64(image: &[u8], instr_rva: u32, location: u32) -> Option<(u8, u32)> {
-    let code32 = arm::fetch_arm_code32(image, location);
-    if let Some(target) = arm::read_immd14(instr_rva, code32) {
-        return Some((0, target));
-    }
-    if let Some(target) = arm::read_immd19(instr_rva, code32) {
-        return Some((1, target));
-    }
-    if let Some(target) = arm::read_immd26(instr_rva, code32) {
-        return Some((2, target));
-    }
-    None
-}
-
-fn fetch_and_read_a32(
-    image: &[u8],
-    addr_type: usize,
-    location: u32,
-    instr_rva: u32,
-) -> Option<u32> {
-    match addr_type {
-        0 => arm::read_a24(instr_rva, arm::fetch_arm_code32(image, location)),
-        1 => arm::read_t8(instr_rva, arm::fetch_thumb2_code16(image, location)),
-        2 => arm::read_t11(instr_rva, arm::fetch_thumb2_code16(image, location)),
-        3 => arm::read_t20(instr_rva, arm::fetch_thumb2_code32(image, location)),
-        4 => arm::read_t24(instr_rva, arm::fetch_thumb2_code32(image, location)),
-        _ => None,
-    }
-}
-
-fn fetch_and_read_a64(
-    image: &[u8],
-    addr_type: usize,
-    location: u32,
-    instr_rva: u32,
-) -> Option<u32> {
-    let code32 = arm::fetch_arm_code32(image, location);
-    match addr_type {
-        0 => arm::read_immd14(instr_rva, code32),
-        1 => arm::read_immd19(instr_rva, code32),
-        2 => arm::read_immd26(instr_rva, code32),
-        _ => None,
-    }
-}
-
-fn write_arm32(image: &mut [u8], addr_type: usize, location: u32, instr_rva: u32, target_rva: u32) {
-    match addr_type {
-        0 => {
-            let mut code = arm::fetch_arm_code32(image, location);
-            if arm::write_a24(instr_rva, target_rva, &mut code) {
-                arm::store_arm_code32(image, location, code);
-            }
-        }
-        1 => {
-            let mut code = arm::fetch_thumb2_code16(image, location);
-            if arm::write_t8(instr_rva, target_rva, &mut code) {
-                arm::store_thumb2_code16(image, location, code);
-            }
-        }
-        2 => {
-            let mut code = arm::fetch_thumb2_code16(image, location);
-            if arm::write_t11(instr_rva, target_rva, &mut code) {
-                arm::store_thumb2_code16(image, location, code);
-            }
-        }
-        3 => {
-            let mut code = arm::fetch_thumb2_code32(image, location);
-            if arm::write_t20(instr_rva, target_rva, &mut code) {
-                arm::store_thumb2_code32(image, location, code);
-            }
-        }
-        4 => {
-            let mut code = arm::fetch_thumb2_code32(image, location);
-            if arm::write_t24(instr_rva, target_rva, &mut code) {
-                arm::store_thumb2_code32(image, location, code);
-            }
-        }
-        _ => {}
-    }
-}
-
-fn write_aarch64(
-    image: &mut [u8],
-    addr_type: usize,
-    location: u32,
-    instr_rva: u32,
-    target_rva: u32,
-) {
-    let mut code = arm::fetch_arm_code32(image, location);
-    let ok = match addr_type {
-        0 => arm::write_immd14(instr_rva, target_rva, &mut code),
-        1 => arm::write_immd19(instr_rva, target_rva, &mut code),
-        2 => arm::write_immd26(instr_rva, target_rva, &mut code),
-        _ => false,
-    };
-    if ok {
-        arm::store_arm_code32(image, location, code);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn thumb2_unknown_32bit_reports_size_four() {
-        // code16 = 0xF800 selects a 32-bit THUMB2 instruction; the resulting
-        // code32 matches neither T20 nor T24, so it is advanced past in full.
-        let image = [0x00u8, 0xF8, 0x00, 0x00];
-        let (found, size) = scan_thumb2(&image, 0, 0, 4);
-        assert!(found.is_none());
-        assert_eq!(size, 4);
-    }
-
-    #[test]
-    fn thumb2_truncated_32bit_does_not_fetch() {
-        let image = [0x00u8, 0xF8, 0x00];
-        let (found, size) = scan_thumb2(&image, 0, 0, 2);
-        assert!(found.is_none());
-        assert_eq!(size, 4);
-    }
-
-    fn minimal_elf64(p_offset: u64, p_filesz: u64) -> Vec<u8> {
-        let mut image = vec![0u8; 64 + 56 + 64];
-        image[..4].copy_from_slice(b"\x7FELF");
-        image[4] = 2; // ELFCLASS64
-        image[5] = 1; // ELFDATA2LSB
-        image[6] = 1; // EV_CURRENT
-        image[16..18].copy_from_slice(&2u16.to_le_bytes()); // ET_EXEC
-        image[18..20].copy_from_slice(&62u16.to_le_bytes()); // EM_X86_64
-        image[20..24].copy_from_slice(&1u32.to_le_bytes());
-        image[32..40].copy_from_slice(&64u64.to_le_bytes()); // e_phoff
-        image[40..48].copy_from_slice(&120u64.to_le_bytes()); // e_shoff
-        image[54..56].copy_from_slice(&56u16.to_le_bytes()); // e_phentsize
-        image[56..58].copy_from_slice(&1u16.to_le_bytes()); // e_phnum
-        image[58..60].copy_from_slice(&64u16.to_le_bytes()); // e_shentsize
-        image[60..62].copy_from_slice(&1u16.to_le_bytes()); // e_shnum
-        // Section 0 stays a zeroed SHT_NULL entry.
-        image[72..80].copy_from_slice(&p_offset.to_le_bytes());
-        image[96..104].copy_from_slice(&p_filesz.to_le_bytes());
-        image
-    }
-
-    #[test]
-    fn elf64_program_header_bounds_are_validated_as_u64() {
-        assert!(parse_elf_header(ElfKind::X64, &minimal_elf64(0x80, 0x10)).is_some());
-        // 2^32 offsets must not truncate to a small valid-looking value.
-        assert!(parse_elf_header(ElfKind::X64, &minimal_elf64(0x1_0000_0000, 0x10)).is_none());
-        // A segment extending past the image must fail too.
-        assert!(parse_elf_header(ElfKind::X64, &minimal_elf64(0x80, 0x1000)).is_none());
-    }
-}
diff --git a/src/zucchini_pure/engine.rs b/src/zucchini_pure/engine.rs
deleted file mode 100644
index 3e188a5..0000000
--- a/src/zucchini_pure/engine.rs
+++ /dev/null
@@ -1,1061 +0,0 @@
-//! Format-independent apply engine: equivalences, extra data, raw deltas,
-//! reference correction, `OffsetMapper`, and `TargetPool`.
-
-use std::collections::BTreeMap;
-
-use super::dex;
-use super::patch::{
-    EXE_TYPE_DEX, EXE_TYPE_ELF_AARCH32, EXE_TYPE_ELF_AARCH64, EXE_TYPE_ELF_X64, EXE_TYPE_ELF_X86,
-    EXE_TYPE_NOOP, Equivalence, PatchElement,
-};
-use super::{
-    Disassembler, Error, GroupTraits, K_INVALID_OFFSET, OFFSET_BOUND, Result, Status,
-    is_android_executable, make_disassembler,
-};
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub struct Reference {
-    pub location: u32,
-    pub target: u32,
-}
-
-pub(crate) struct NoOpDisassembler {
-    pub size: u32,
-}
-
-impl Disassembler for NoOpDisassembler {
-    fn size(&self) -> u32 {
-        self.size
-    }
-
-    fn groups(&self) -> &[GroupTraits] {
-        &[]
-    }
-
-    fn read(&self, _group: usize, _image: &[u8], _lo: u32, _hi: u32) -> Result<Vec<Reference>> {
-        Ok(Vec::new())
-    }
-
-    fn write(&self, _group: usize, _image: &mut [u8], _reference: Reference) {}
-}
-
-fn apply_error(message: impl Into<String>) -> Error {
-    Error::new(Status::ApplyError, message)
-}
-
-fn check_not_cancelled(cancelled: &dyn Fn() -> bool) -> Result<()> {
-    if cancelled() {
-        Err(Error::new(Status::Cancelled, "Zucchini apply cancelled"))
-    } else {
-        Ok(())
-    }
-}
-
-/// Old-image analysis shared by preflight and apply for one element.
-pub(crate) struct ElementAnalysis {
-    disasm: Box<dyn Disassembler>,
-    refs: GroupRefCache,
-}
-
-/// Per-group references for one parsed image, computed once. Ranged queries
-/// binary-search the location-sorted list instead of re-scanning the
-/// disassembler for every equivalence.
-struct GroupRefCache {
-    refs: Vec<Vec<Reference>>,
-}
-
-impl GroupRefCache {
-    fn build(disasm: &dyn Disassembler, image: &[u8]) -> Result<Self> {
-        let groups = disasm.groups();
-        let size = disasm.size();
-        let mut refs = Vec::new();
-        refs.try_reserve_exact(groups.len())
-            .map_err(|_| super::allocation_error("Zucchini reference groups"))?;
-        for group in 0..groups.len() {
-            refs.push(disasm.read(group, image, 0, size)?);
-        }
-        Ok(Self { refs })
-    }
-
-    fn full(&self, group: usize) -> &[Reference] {
-        &self.refs[group]
-    }
-
-    fn range(&self, group: usize, lo: u32, hi: u32) -> &[Reference] {
-        let refs = &self.refs[group];
-        let start = refs.partition_point(|reference| reference.location < lo);
-        let end = refs.partition_point(|reference| reference.location < hi);
-        &refs[start..end]
-    }
-}
-
-/// Parses the old element and caches its per-group references once.
-pub(crate) fn analyze_element(exe_type: u32, old_element: &[u8]) -> Result<ElementAnalysis> {
-    let disasm = make_disassembler(exe_type, old_element)
-        .ok_or_else(|| apply_error("failed to create old disassembler"))?;
-    let refs = GroupRefCache::build(&*disasm, old_element)?;
-    Ok(ElementAnalysis { disasm, refs })
-}
-
-/// Splits the element's old and new regions out of the images.
-pub(crate) fn element_regions<'a>(
-    old: &'a [u8],
-    element: &PatchElement,
-    output: &'a mut [u8],
-) -> Result<(&'a [u8], &'a mut [u8])> {
-    let matching = &element.element_match;
-    let old_end = (matching.old_offset as usize)
-        .checked_add(matching.old_size as usize)
-        .ok_or_else(|| apply_error("old element range overflow"))?;
-    let new_end = (matching.new_offset as usize)
-        .checked_add(matching.new_size as usize)
-        .ok_or_else(|| apply_error("new element range overflow"))?;
-    let old_element = old
-        .get(matching.old_offset as usize..old_end)
-        .ok_or_else(|| apply_error("old element out of bounds"))?;
-    let new_element = output
-        .get_mut(matching.new_offset as usize..new_end)
-        .ok_or_else(|| apply_error("new element out of bounds"))?;
-    Ok((old_element, new_element))
-}
-
-pub(crate) fn apply_element(
-    element: &PatchElement,
-    old_element: &[u8],
-    new_element: &mut [u8],
-    analysis: &ElementAnalysis,
-    cancelled: &dyn Fn() -> bool,
-) -> Result<()> {
-    check_not_cancelled(cancelled)?;
-    apply_equivalence_and_extra_data(old_element, element, new_element, cancelled)?;
-    apply_raw_delta(element, new_element, cancelled)?;
-    apply_references_correction(
-        element.element_match.exe_type,
-        old_element,
-        element,
-        new_element,
-        &*analysis.disasm,
-        &analysis.refs,
-        cancelled,
-    )?;
-    Ok(())
-}
-
-/// Mirrors the native FFI's `PreflightAndroidElements` for one element: apply
-/// equivalence/extra/raw data to a scratch output, then run the Android
-/// boundary and DEX-target validations that upstream Zucchini does not.
-pub(crate) fn preflight_element(
-    element: &PatchElement,
-    old_element: &[u8],
-    new_element: &mut [u8],
-    analysis: &ElementAnalysis,
-    cancelled: &dyn Fn() -> bool,
-) -> Result<()> {
-    let exe_type = element.element_match.exe_type;
-    if exe_type == EXE_TYPE_NOOP || !is_android_executable(exe_type) {
-        return Ok(());
-    }
-    check_not_cancelled(cancelled)?;
-
-    apply_equivalence_and_extra_data(old_element, element, new_element, cancelled)?;
-    apply_raw_delta(element, new_element, cancelled)?;
-
-    let old_disasm = &*analysis.disasm;
-    let new_disasm = make_disassembler(exe_type, new_element)
-        .ok_or_else(|| apply_error("failed to create new disassembler"))?;
-    if old_disasm.size() != old_element.len() as u32
-        || new_disasm.size() != new_element.len() as u32
-    {
-        return Err(apply_error("disassembler and element size mismatch"));
-    }
-    let new_size = new_element.len() as u32;
-    if !validate_reference_boundaries(
-        old_disasm,
-        &analysis.refs,
-        exe_type,
-        element,
-        new_size,
-        cancelled,
-    )? {
-        return Err(apply_error("reference boundary violation"));
-    }
-    if exe_type == EXE_TYPE_DEX {
-        if !dex::narrow_writer_widths_ok(new_element) {
-            return Err(apply_error("dex writer width violation"));
-        }
-        if !validate_dex_reference_targets(
-            old_disasm,
-            &*new_disasm,
-            &analysis.refs,
-            element,
-            new_element,
-            cancelled,
-        )? {
-            return Err(apply_error("dex reference target violation"));
-        }
-    }
-    Ok(())
-}
-
-/// Mirrors the FFI's `ValidateReferenceBoundaries`. Returns `Ok(true)` when the
-/// element is safe, `Ok(false)` on a boundary violation, and `Err(Cancelled)`
-/// if the caller cancels.
-fn validate_reference_boundaries(
-    old_disasm: &dyn Disassembler,
-    cache: &GroupRefCache,
-    exe_type: u32,
-    element: &PatchElement,
-    new_size: u32,
-    cancelled: &dyn Fn() -> bool,
-) -> Result<bool> {
-    let mut boundaries: Vec<u32> = Vec::new();
-    boundaries
-        .try_reserve(element.equivalences.len().saturating_mul(2))
-        .map_err(|_| super::allocation_error("Zucchini equivalence boundaries"))?;
-    for equivalence in &element.equivalences {
-        boundaries.push(equivalence.src_offset);
-        boundaries.push(equivalence.src_end());
-    }
-    boundaries.sort_unstable();
-
-    for (group_index, group) in old_disasm.groups().iter().enumerate() {
-        check_not_cancelled(cancelled)?;
-        let mut writer_width = group.width;
-        if group.type_tag == 0 {
-            match exe_type {
-                EXE_TYPE_ELF_X86 | EXE_TYPE_ELF_AARCH32 => writer_width = 8,
-                EXE_TYPE_ELF_X64 | EXE_TYPE_ELF_AARCH64 => writer_width = 16,
-                _ => {}
-            }
-        }
-
-        for reference in cache.full(group_index) {
-            let boundary = boundaries.partition_point(|value| *value <= reference.location);
-            if boundary < boundaries.len()
-                && boundaries[boundary] < reference.location.wrapping_add(group.width)
-            {
-                return Ok(false);
-            }
-        }
-
-        for equivalence in &element.equivalences {
-            check_not_cancelled(cancelled)?;
-            for reference in cache.range(group_index, equivalence.src_offset, equivalence.src_end())
-            {
-                if reference.location < equivalence.src_offset
-                    || reference.location > equivalence.src_end()
-                    || group.width > equivalence.src_end() - reference.location
-                {
-                    return Ok(false);
-                }
-                let projected = equivalence
-                    .dst_offset
-                    .wrapping_add(reference.location.wrapping_sub(equivalence.src_offset));
-                if projected > new_size || writer_width > new_size - projected {
-                    return Ok(false);
-                }
-            }
-        }
-    }
-    Ok(true)
-}
-
-/// Mirrors the FFI's `ValidateDexReferenceTargets`. Returns `Ok(true)` when the
-/// targets are safe, `Ok(false)` on violation, and `Err(Cancelled)` otherwise.
-fn validate_dex_reference_targets(
-    old_disasm: &dyn Disassembler,
-    new_disasm: &dyn Disassembler,
-    cache: &GroupRefCache,
-    element: &PatchElement,
-    new_image: &[u8],
-    cancelled: &dyn Fn() -> bool,
-) -> Result<bool> {
-    let Some(string_ids) = dex::string_ids(new_image) else { return Ok(false) };
-
-    let mut pools: BTreeMap<u8, Vec<usize>> = BTreeMap::new();
-    for (index, group) in old_disasm.groups().iter().enumerate() {
-        pools.entry(group.pool_tag).or_default().push(index);
-    }
-
-    let mut deltas = element.reference_deltas.iter();
-    let mapper =
-        OffsetMapper::new(&element.equivalences, old_disasm.size(), new_image.len() as u32)?;
-
-    for (pool_tag, sub_groups) in &pools {
-        check_not_cancelled(cancelled)?;
-        let mut targets = TargetPool::default();
-        for &group_index in sub_groups {
-            targets.insert_references(cache.full(group_index))?;
-        }
-        targets.filter_and_project(&mapper)?;
-        if let Some(extra) = element.extra_targets.get(pool_tag) {
-            targets.insert_targets(&extra.targets)?;
-            if !extra.done {
-                return Ok(false);
-            }
-        }
-
-        for &group_index in sub_groups {
-            let type_tag = old_disasm.groups()[group_index].type_tag;
-            if usize::from(type_tag) >= new_disasm.groups().len() {
-                return Ok(false);
-            }
-            for equivalence in &element.equivalences {
-                check_not_cancelled(cancelled)?;
-                for reference in
-                    cache.range(group_index, equivalence.src_offset, equivalence.src_end())
-                {
-                    let projected = mapper.extended_forward_project(reference.target);
-                    let expected = targets.key_for_nearest_offset(projected);
-                    let Some(delta) = deltas.next() else { return Ok(false) };
-                    let key = i64::from(expected) + i64::from(*delta);
-                    if !(0..=i64::from(u32::MAX)).contains(&key) {
-                        return Ok(false);
-                    }
-                    let key = key as u32;
-                    if !targets.key_is_valid(key) {
-                        return Ok(false);
-                    }
-                    if type_tag == 5 {
-                        let target = targets.offset_for_key(key);
-                        if target < string_ids.offset
-                            || (target - string_ids.offset) % 4 != 0
-                            || (target - string_ids.offset) / 4 > u32::from(u16::MAX)
-                        {
-                            return Ok(false);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(deltas.next().is_none() && element.reference_deltas_done)
-}
-
-/// Mirrors `ApplyEquivalenceAndExtraData`.
-fn apply_equivalence_and_extra_data(
-    old_image: &[u8],
-    element: &PatchElement,
-    new_image: &mut [u8],
-    cancelled: &dyn Fn() -> bool,
-) -> Result<()> {
-    let mut extra_cursor = 0usize;
-    let mut dst_it = 0usize;
-
-    for equivalence in &element.equivalences {
-        check_not_cancelled(cancelled)?;
-        let next_dst_it = equivalence.dst_offset as usize;
-        if next_dst_it < dst_it {
-            return Err(apply_error("overlapping equivalences"));
-        }
-        let gap = next_dst_it - dst_it;
-        let extra = take_extra(&element.extra_data, &mut extra_cursor, gap)?;
-        new_image
-            .get_mut(dst_it..next_dst_it)
-            .ok_or_else(|| apply_error("extra data out of bounds"))?
-            .copy_from_slice(extra);
-
-        let src_begin = equivalence.src_offset as usize;
-        let src_end = src_begin
-            .checked_add(equivalence.length as usize)
-            .ok_or_else(|| apply_error("equivalence source overflow"))?;
-        let dst_end = next_dst_it
-            .checked_add(equivalence.length as usize)
-            .ok_or_else(|| apply_error("equivalence destination overflow"))?;
-        let source = old_image
-            .get(src_begin..src_end)
-            .ok_or_else(|| apply_error("equivalence source out of bounds"))?;
-        new_image
-            .get_mut(next_dst_it..dst_end)
-            .ok_or_else(|| apply_error("equivalence destination out of bounds"))?
-            .copy_from_slice(source);
-        dst_it = dst_end;
-    }
-
-    let gap = new_image
-        .len()
-        .checked_sub(dst_it)
-        .ok_or_else(|| apply_error("extra data length mismatch"))?;
-    let extra = take_extra(&element.extra_data, &mut extra_cursor, gap)?;
-    new_image
-        .get_mut(dst_it..)
-        .ok_or_else(|| apply_error("extra data out of bounds"))?
-        .copy_from_slice(extra);
-
-    if !element.equivalences_done || extra_cursor != element.extra_data.len() {
-        return Err(apply_error("trailing equivalence or extra data"));
-    }
-    Ok(())
-}
-
-fn take_extra<'a>(extra: &'a [u8], cursor: &mut usize, size: usize) -> Result<&'a [u8]> {
-    let end = cursor.checked_add(size).ok_or_else(|| apply_error("extra data length overflow"))?;
-    let slice = extra.get(*cursor..end).ok_or_else(|| apply_error("extra data exhausted"))?;
-    *cursor = end;
-    Ok(slice)
-}
-
-/// Mirrors `ApplyRawDelta`.
-fn apply_raw_delta(
-    element: &PatchElement,
-    new_image: &mut [u8],
-    cancelled: &dyn Fn() -> bool,
-) -> Result<()> {
-    let mut base_copy_offset: u32 = 0;
-    let mut equivalence_index = 0usize;
-
-    for delta in &element.raw_deltas {
-        check_not_cancelled(cancelled)?;
-        while equivalence_index < element.equivalences.len() {
-            let equivalence = element.equivalences[equivalence_index];
-            let end = base_copy_offset
-                .checked_add(equivalence.length)
-                .ok_or_else(|| apply_error("equivalence length overflow"))?;
-            if end <= delta.copy_offset {
-                base_copy_offset = end;
-                equivalence_index += 1;
-            } else {
-                break;
-            }
-        }
-        let equivalence = element
-            .equivalences
-            .get(equivalence_index)
-            .ok_or_else(|| apply_error("error reading equivalences"))?;
-        if delta.copy_offset < base_copy_offset
-            || delta.copy_offset
-                >= base_copy_offset
-                    .checked_add(equivalence.length)
-                    .ok_or_else(|| apply_error("equivalence length overflow"))?
-        {
-            return Err(apply_error("raw delta out of equivalence range"));
-        }
-        let index = equivalence
-            .dst_offset
-            .checked_sub(base_copy_offset)
-            .and_then(|value| value.checked_add(delta.copy_offset))
-            .ok_or_else(|| apply_error("raw delta destination overflow"))?;
-        let slot = new_image
-            .get_mut(index as usize)
-            .ok_or_else(|| apply_error("raw delta out of bounds"))?;
-        *slot = slot.wrapping_add(delta.diff as u8);
-    }
-
-    if !element.raw_deltas_done {
-        return Err(apply_error("found trailing raw delta"));
-    }
-    Ok(())
-}
-
-/// Mirrors `ApplyReferencesCorrection`.
-fn apply_references_correction(
-    exe_type: u32,
-    old_image: &[u8],
-    element: &PatchElement,
-    new_image: &mut [u8],
-    old_disasm: &dyn Disassembler,
-    cache: &GroupRefCache,
-    cancelled: &dyn Fn() -> bool,
-) -> Result<()> {
-    check_not_cancelled(cancelled)?;
-    let new_disasm = make_disassembler(exe_type, new_image)
-        .ok_or_else(|| apply_error("failed to create new disassembler"))?;
-    if old_disasm.size() != old_image.len() as u32 || new_disasm.size() != new_image.len() as u32 {
-        return Err(apply_error("disassembler and element size mismatch"));
-    }
-
-    let old_groups = old_disasm.groups();
-    let new_groups = new_disasm.groups();
-    let mapper =
-        OffsetMapper::new(&element.equivalences, old_image.len() as u32, new_image.len() as u32)?;
-
-    let mut pools: BTreeMap<u8, Vec<usize>> = BTreeMap::new();
-    for (index, group) in old_groups.iter().enumerate() {
-        pools.entry(group.pool_tag).or_default().push(index);
-    }
-
-    let mut deltas = element.reference_deltas.iter();
-    for (pool_tag, sub_groups) in &pools {
-        check_not_cancelled(cancelled)?;
-        let mut targets = TargetPool::default();
-        for &group_index in sub_groups {
-            targets.insert_references(cache.full(group_index))?;
-        }
-        targets.filter_and_project(&mapper)?;
-
-        if let Some(extra) = element.extra_targets.get(pool_tag) {
-            targets.insert_targets(&extra.targets)?;
-            if !extra.done {
-                return Err(apply_error("found trailing extra targets"));
-            }
-        }
-
-        for &group_index in sub_groups {
-            let type_tag = old_groups[group_index].type_tag as usize;
-            if type_tag >= new_groups.len() {
-                return Err(apply_error("new reference group is missing"));
-            }
-            for equivalence in &element.equivalences {
-                check_not_cancelled(cancelled)?;
-                for &reference in
-                    cache.range(group_index, equivalence.src_offset, equivalence.src_end())
-                {
-                    check_not_cancelled(cancelled)?;
-                    let mut reference = reference;
-                    let projected = mapper.extended_forward_project(reference.target);
-                    let expected_key = targets.key_for_nearest_offset(projected);
-                    let delta = deltas
-                        .next()
-                        .ok_or_else(|| apply_error("error reading reference delta"))?;
-                    let key = expected_key.wrapping_add(*delta as u32);
-                    if !targets.key_is_valid(key) {
-                        return Err(apply_error("invalid reference delta"));
-                    }
-                    reference.target = targets.offset_for_key(key);
-                    reference.location = reference
-                        .location
-                        .wrapping_sub(equivalence.src_offset)
-                        .wrapping_add(equivalence.dst_offset);
-                    new_disasm.write(type_tag, new_image, reference);
-                }
-            }
-        }
-    }
-
-    // Match `ReferenceDeltaSource::Done()`: unconsumed malformed trailing bytes
-    // are a trailing-reference-delta error even if every needed delta decoded.
-    if deltas.next().is_some() || !element.reference_deltas_done {
-        return Err(apply_error("found trailing reference delta"));
-    }
-    Ok(())
-}
-
-/// Mirrors `OffsetMapper` in `equivalence_map.cc`.
-struct OffsetMapper {
-    equivalences: Vec<Equivalence>,
-    old_image_size: u32,
-    new_image_size: u32,
-}
-
-impl OffsetMapper {
-    fn new(source: &[Equivalence], old_image_size: u32, new_image_size: u32) -> Result<Self> {
-        let mut equivalences = Vec::new();
-        equivalences
-            .try_reserve_exact(source.len())
-            .map_err(|_| super::allocation_error("Zucchini equivalences"))?;
-        equivalences.extend_from_slice(source);
-        PruneEquivalencesAndSortBySource::prune(&mut equivalences);
-        Ok(Self { equivalences, old_image_size, new_image_size })
-    }
-
-    fn naive_extended_forward_project(&self, unit: &Equivalence, offset: u32) -> u32 {
-        let value = offset as i64 - unit.src_offset as i64 + unit.dst_offset as i64;
-        let clamped = value.clamp(0, self.new_image_size as i64 - 1);
-        clamped as u32
-    }
-
-    fn extended_forward_project(&self, offset: u32) -> u32 {
-        if offset < self.old_image_size {
-            // First equivalence with `src_offset > offset`.
-            let pos =
-                self.equivalences.partition_point(|equivalence| equivalence.src_offset <= offset);
-            let mut chosen = pos;
-            if pos != 0 {
-                let back = self.equivalences[pos - 1];
-                let take_back = pos == self.equivalences.len()
-                    || offset < back.src_end()
-                    || (offset - back.src_end()) < (self.equivalences[pos].src_offset - offset);
-                if take_back {
-                    chosen = pos - 1;
-                }
-            }
-            return self.naive_extended_forward_project(&self.equivalences[chosen], offset);
-        }
-        let delta = offset - self.old_image_size;
-        if delta < OFFSET_BOUND as u32 - self.new_image_size {
-            self.new_image_size + delta
-        } else {
-            (OFFSET_BOUND - 1) as u32
-        }
-    }
-
-    fn forward_project_all(&self, offsets: &mut Vec<u32>) {
-        let mut current = 0usize;
-        for source in offsets.iter_mut() {
-            while current < self.equivalences.len()
-                && self.equivalences[current].src_end() <= *source
-            {
-                current += 1;
-            }
-            if current < self.equivalences.len() && self.equivalences[current].src_offset <= *source
-            {
-                *source = *source - self.equivalences[current].src_offset
-                    + self.equivalences[current].dst_offset;
-            } else {
-                *source = K_INVALID_OFFSET;
-            }
-        }
-        offsets.retain(|value| *value != K_INVALID_OFFSET);
-    }
-}
-
-/// Reproduces the permutation produced by libstdc++'s `std::sort` when the
-/// comparator only orders by `src_offset`.
-///
-/// Zucchini's reference-delta stream is generated with the native OffsetMapper,
-/// whose `PruneEquivalencesAndSortBySource` calls `std::sort`. `std::sort` is
-/// not stable, and the pruning is order-sensitive for equivalences that share a
-/// `src_offset` (their post-prune order determines which one a projection
-/// picks). A stable Rust sort produces a different projection and diverges from
-/// native output, so the exact native permutation must be reproduced. This is
-/// a direct port of libstdc++ `__introsort_loop` / `__final_insertion_sort`
-/// with the `__partial_sort` heap fallback.
-#[allow(clippy::many_single_char_names)]
-mod stdcpp {
-    use super::Equivalence;
-
-    const THRESHOLD: usize = 16;
-
-    #[inline]
-    fn comp(a: &Equivalence, b: &Equivalence) -> bool {
-        a.src_offset < b.src_offset
-    }
-
-    fn lg(n: usize) -> u32 {
-        (usize::BITS - 1) - n.leading_zeros()
-    }
-
-    fn move_median_to_first(v: &mut [Equivalence], result: usize, a: usize, b: usize, c: usize) {
-        if comp(&v[a], &v[b]) {
-            if comp(&v[b], &v[c]) {
-                v.swap(result, b);
-            } else if comp(&v[a], &v[c]) {
-                v.swap(result, c);
-            } else {
-                v.swap(result, a);
-            }
-        } else if comp(&v[a], &v[c]) {
-            v.swap(result, a);
-        } else if comp(&v[b], &v[c]) {
-            v.swap(result, c);
-        } else {
-            v.swap(result, b);
-        }
-    }
-
-    fn unguarded_partition(
-        v: &mut [Equivalence],
-        mut first: usize,
-        mut last: usize,
-        pivot: usize,
-    ) -> usize {
-        loop {
-            while comp(&v[first], &v[pivot]) {
-                first += 1;
-            }
-            last -= 1;
-            while comp(&v[pivot], &v[last]) {
-                last -= 1;
-            }
-            if first >= last {
-                return first;
-            }
-            v.swap(first, last);
-            first += 1;
-        }
-    }
-
-    fn unguarded_partition_pivot(v: &mut [Equivalence], first: usize, last: usize) -> usize {
-        let mid = first + (last - first) / 2;
-        move_median_to_first(v, first, first + 1, mid, last - 1);
-        unguarded_partition(v, first + 1, last, first)
-    }
-
-    fn unguarded_linear_insert(v: &mut [Equivalence], mut last: usize) {
-        let value = v[last];
-        let mut next = last - 1;
-        while comp(&value, &v[next]) {
-            v[last] = v[next];
-            last = next;
-            next -= 1;
-        }
-        v[last] = value;
-    }
-
-    fn insertion_sort(v: &mut [Equivalence], first: usize, last: usize) {
-        if first == last {
-            return;
-        }
-        for i in (first + 1)..last {
-            if comp(&v[i], &v[first]) {
-                let value = v[i];
-                let mut j = i;
-                while j > first {
-                    v[j] = v[j - 1];
-                    j -= 1;
-                }
-                v[first] = value;
-            } else {
-                unguarded_linear_insert(v, i);
-            }
-        }
-    }
-
-    fn unguarded_insertion_sort(v: &mut [Equivalence], first: usize, last: usize) {
-        for i in first..last {
-            unguarded_linear_insert(v, i);
-        }
-    }
-
-    fn final_insertion_sort(v: &mut [Equivalence], first: usize, last: usize) {
-        if last - first > THRESHOLD {
-            insertion_sort(v, first, first + THRESHOLD);
-            unguarded_insertion_sort(v, first + THRESHOLD, last);
-        } else {
-            insertion_sort(v, first, last);
-        }
-    }
-
-    fn push_heap(v: &mut [Equivalence], mut hole: usize, top: usize, value: Equivalence) {
-        let mut parent = (hole - 1) / 2;
-        while hole > top && comp(&v[parent], &value) {
-            v[hole] = v[parent];
-            hole = parent;
-            parent = (hole - 1) / 2;
-        }
-        v[hole] = value;
-    }
-
-    fn adjust_heap(v: &mut [Equivalence], mut hole: usize, len: usize, value: Equivalence) {
-        let top = hole;
-        let mut second = hole;
-        while second < (len - 1) / 2 {
-            second = 2 * (second + 1);
-            if comp(&v[second], &v[second - 1]) {
-                second -= 1;
-            }
-            v[hole] = v[second];
-            hole = second;
-        }
-        if len & 1 == 0 && second == (len - 2) / 2 {
-            second = 2 * (second + 1);
-            v[hole] = v[second - 1];
-            hole = second - 1;
-        }
-        push_heap(v, hole, top, value);
-    }
-
-    fn pop_heap(v: &mut [Equivalence], last: usize) {
-        // [0, last) is the heap; `last` is the element being removed.
-        let value = v[last];
-        v[last] = v[0];
-        adjust_heap(&mut v[..last], 0, last, value);
-    }
-
-    fn heapsort(v: &mut [Equivalence]) {
-        if v.len() < 2 {
-            return;
-        }
-        let len = v.len();
-        let mut parent = (len - 2) / 2;
-        loop {
-            let value = v[parent];
-            adjust_heap(v, parent, len, value);
-            if parent == 0 {
-                break;
-            }
-            parent -= 1;
-        }
-        let mut last = len;
-        while last > 1 {
-            last -= 1;
-            pop_heap(v, last);
-        }
-    }
-
-    fn introsort_loop(v: &mut [Equivalence], first: usize, mut last: usize, mut depth: u32) {
-        while last - first > THRESHOLD {
-            if depth == 0 {
-                heapsort(&mut v[first..last]);
-                return;
-            }
-            depth -= 1;
-            let cut = unguarded_partition_pivot(v, first, last);
-            introsort_loop(v, cut, last, depth);
-            last = cut;
-        }
-    }
-
-    pub(super) fn sort_by_src(v: &mut [Equivalence]) {
-        let n = v.len();
-        if n > 1 {
-            introsort_loop(v, 0, n, lg(n) * 2);
-            final_insertion_sort(v, 0, n);
-        }
-    }
-}
-
-/// Mirrors `OffsetMapper::PruneEquivalencesAndSortBySource`.
-struct PruneEquivalencesAndSortBySource;
-
-impl PruneEquivalencesAndSortBySource {
-    fn prune(equivalences: &mut Vec<Equivalence>) {
-        stdcpp::sort_by_src(equivalences);
-
-        let mut current = 0usize;
-        while current < equivalences.len() {
-            let mut next_is_reaper = false;
-            let mut next = current + 1;
-            while next < equivalences.len() {
-                if equivalences[next].src_offset >= equivalences[current].src_end() {
-                    break;
-                }
-                if equivalences[current].length < equivalences[next].length {
-                    let delta = equivalences[current].src_end() - equivalences[next].src_offset;
-                    equivalences[current].length -= delta;
-                    next_is_reaper = true;
-                    break;
-                }
-                next += 1;
-            }
-
-            if next_is_reaper {
-                for reduced in (current + 1)..next {
-                    equivalences[reduced].length = 0;
-                }
-                current = next;
-            } else {
-                for reduced in (current + 1)..next {
-                    let delta = equivalences[current].src_end() - equivalences[reduced].src_offset;
-                    let shrink = equivalences[reduced].length.min(delta);
-                    equivalences[reduced].length -= shrink;
-                    equivalences[reduced].src_offset += delta;
-                    equivalences[reduced].dst_offset += delta;
-                }
-                current += 1;
-            }
-        }
-
-        equivalences.retain(|equivalence| equivalence.length != 0);
-    }
-}
-
-/// Mirrors `TargetPool`.
-#[derive(Default)]
-struct TargetPool {
-    targets: Vec<u32>,
-}
-
-impl TargetPool {
-    fn sort_and_uniquify(&mut self) {
-        self.targets.sort_unstable();
-        self.targets.dedup();
-    }
-
-    fn insert_references(&mut self, references: &[Reference]) -> Result<()> {
-        self.targets
-            .try_reserve(references.len())
-            .map_err(|_| super::allocation_error("Zucchini target pool"))?;
-        self.targets.extend(references.iter().map(|reference| reference.target));
-        self.sort_and_uniquify();
-        Ok(())
-    }
-
-    fn insert_targets(&mut self, targets: &[u32]) -> Result<()> {
-        self.targets
-            .try_reserve(targets.len())
-            .map_err(|_| super::allocation_error("Zucchini target pool"))?;
-        self.targets.extend_from_slice(targets);
-        self.sort_and_uniquify();
-        Ok(())
-    }
-
-    fn filter_and_project(&mut self, mapper: &OffsetMapper) -> Result<()> {
-        mapper.forward_project_all(&mut self.targets);
-        self.targets.sort_unstable();
-        Ok(())
-    }
-
-    /// Mirrors `KeyForNearestOffset`, including its lower-key tie-breaking.
-    fn key_for_nearest_offset(&self, offset: u32) -> u32 {
-        let mut pos = self.targets.partition_point(|target| *target < offset);
-        if pos != 0 {
-            if pos == self.targets.len()
-                || self.targets[pos] - offset >= offset - self.targets[pos - 1]
-            {
-                pos -= 1;
-            }
-        }
-        pos as u32
-    }
-
-    fn offset_for_key(&self, key: u32) -> u32 {
-        self.targets[key as usize]
-    }
-
-    fn key_is_valid(&self, key: u32) -> bool {
-        (key as usize) < self.targets.len()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs;
-
-    /// The cached per-group references must equal what a fresh ranged read
-    /// returns for every group and range.
-    #[test]
-    fn group_ref_cache_matches_ranged_reads() {
-        let fixtures = "tests/fixtures/zucchini";
-        for (name, exe_type) in [
-            ("elf-old", EXE_TYPE_ELF_X64),
-            ("elf-arm32-old", EXE_TYPE_ELF_AARCH32),
-            ("elf-arm64-old", EXE_TYPE_ELF_AARCH64),
-            ("dex-old.dex", EXE_TYPE_DEX),
-            ("dex-large-old.dex", EXE_TYPE_DEX),
-        ] {
-            let Ok(image) = fs::read(format!("{fixtures}/{name}")) else { continue };
-            let disasm = make_disassembler(exe_type, &image).unwrap();
-            let cache = GroupRefCache::build(&*disasm, &image).unwrap();
-            let size = disasm.size();
-            let ranges = [(0, size), (0, size / 3), (size / 3, size * 2 / 3), (size * 2 / 3, size)];
-            for group in 0..disasm.groups().len() {
-                for &(lo, hi) in &ranges {
-                    if lo > hi || hi > size {
-                        continue;
-                    }
-                    let expected = disasm.read(group, &image, lo, hi).unwrap();
-                    assert_eq!(
-                        cache.range(group, lo, hi),
-                        expected.as_slice(),
-                        "{name} group {group} range {lo}..{hi}"
-                    );
-                }
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod native_sort_tests {
-    use super::*;
-
-    /// Guards the libstdc++ `std::sort` port: the native permutation of
-    /// equal-`src_offset` equivalences is what the reference-delta stream
-    /// depends on, so the expected order below was produced by compiling
-    /// `PruneEquivalencesAndSortBySource`'s `std::sort` comparator with
-    /// libstdc++ on this 48-element tie-heavy input.
-    #[test]
-    fn sort_reproduces_native_tie_order() {
-        let input: [(u32, u32, u32); 48] = [
-            (0, 1000, 1),
-            (5, 1001, 2),
-            (10, 1002, 3),
-            (15, 1003, 4),
-            (6, 1004, 5),
-            (11, 1005, 1),
-            (16, 1006, 2),
-            (4, 1007, 3),
-            (12, 1008, 4),
-            (0, 1009, 5),
-            (5, 1010, 1),
-            (10, 1011, 2),
-            (1, 1012, 3),
-            (6, 1013, 4),
-            (11, 1014, 5),
-            (16, 1015, 1),
-            (7, 1016, 2),
-            (12, 1017, 3),
-            (0, 1018, 4),
-            (5, 1019, 5),
-            (13, 1020, 1),
-            (1, 1021, 2),
-            (6, 1022, 3),
-            (11, 1023, 4),
-            (2, 1024, 5),
-            (7, 1025, 1),
-            (12, 1026, 2),
-            (0, 1027, 3),
-            (8, 1028, 4),
-            (13, 1029, 5),
-            (1, 1030, 1),
-            (6, 1031, 2),
-            (14, 1032, 3),
-            (2, 1033, 4),
-            (7, 1034, 5),
-            (12, 1035, 1),
-            (3, 1036, 2),
-            (8, 1037, 3),
-            (13, 1038, 4),
-            (1, 1039, 5),
-            (9, 1040, 1),
-            (14, 1041, 2),
-            (2, 1042, 3),
-            (7, 1043, 4),
-            (15, 1044, 5),
-            (3, 1045, 1),
-            (8, 1046, 2),
-            (13, 1047, 3),
-        ];
-        let expected: [(u32, u32, u32); 48] = [
-            (0, 1000, 1),
-            (0, 1009, 5),
-            (0, 1027, 3),
-            (0, 1018, 4),
-            (1, 1039, 5),
-            (1, 1030, 1),
-            (1, 1012, 3),
-            (1, 1021, 2),
-            (2, 1042, 3),
-            (2, 1033, 4),
-            (2, 1024, 5),
-            (3, 1045, 1),
-            (3, 1036, 2),
-            (4, 1007, 3),
-            (5, 1001, 2),
-            (5, 1019, 5),
-            (5, 1010, 1),
-            (6, 1004, 5),
-            (6, 1031, 2),
-            (6, 1022, 3),
-            (6, 1013, 4),
-            (7, 1025, 1),
-            (7, 1016, 2),
-            (7, 1043, 4),
-            (7, 1034, 5),
-            (8, 1037, 3),
-            (8, 1028, 4),
-            (8, 1046, 2),
-            (9, 1040, 1),
-            (10, 1011, 2),
-            (10, 1002, 3),
-            (11, 1014, 5),
-            (11, 1023, 4),
-            (11, 1005, 1),
-            (12, 1008, 4),
-            (12, 1035, 1),
-            (12, 1017, 3),
-            (12, 1026, 2),
-            (13, 1047, 3),
-            (13, 1038, 4),
-            (13, 1029, 5),
-            (13, 1020, 1),
-            (14, 1041, 2),
-            (14, 1032, 3),
-            (15, 1003, 4),
-            (15, 1044, 5),
-            (16, 1006, 2),
-            (16, 1015, 1),
-        ];
-        let mut values: Vec<Equivalence> = input
-            .iter()
-            .map(|&(src_offset, dst_offset, length)| Equivalence { src_offset, dst_offset, length })
-            .collect();
-        stdcpp::sort_by_src(&mut values);
-        let got: Vec<(u32, u32, u32)> =
-            values.iter().map(|e| (e.src_offset, e.dst_offset, e.length)).collect();
-        assert_eq!(got, expected);
-    }
-}
diff --git a/src/zucchini_pure/mod.rs b/src/zucchini_pure/mod.rs
deleted file mode 100644
index c255cd8..0000000
--- a/src/zucchini_pure/mod.rs
+++ /dev/null
@@ -1,244 +0,0 @@
-//! Pure-Rust, apply-only reimplementation of the Zucchini executable patcher.
-//!
-//! The native implementation vendored for this crate links the upstream C++
-//! `components/zucchini` sources plus libchrome. This module is an independent
-//! Rust port of the apply path (no C++ and no libchrome). It targets exactly
-//! the element formats that Android delta OTA payloads use: `NoOp`, ELF
-//! x86/x86-64/AArch32/AArch64, and DEX.
-//!
-//! Scope and status are documented in `docs/zucchini-rust-port.md`.
-
-// This is a line-by-line port of the C++ apply path, so several clippy style
-// lints (control-flow shape, argument counts, explicit byte indexing) are
-// intentionally allowed rather than restructured away from the original.
-#![allow(
-    clippy::collapsible_if,
-    clippy::implicit_saturating_sub,
-    clippy::manual_is_multiple_of,
-    clippy::needless_range_loop,
-    clippy::too_many_arguments,
-    clippy::type_complexity,
-    clippy::unnecessary_cast
-)]
-
-use std::error;
-use std::fmt;
-
-mod arm;
-pub mod bytes;
-mod crc32;
-mod dex;
-mod elf;
-mod engine;
-pub mod patch;
-
-pub use elf::ElfDisassembler;
-pub use engine::Reference;
-
-/// Exclusive upper bound for buffers represented by Zucchini offsets.
-pub const OFFSET_BOUND: usize = (u32::MAX / 2) as usize;
-/// `0xFFFFFFFE`, distinct from the fake-offset sentinel used by DEX indices.
-pub const K_INVALID_OFFSET: u32 = 0xFFFF_FFFE;
-pub const K_INVALID_RVA: u32 = 0xFFFF_FFFE;
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum Status {
-    InvalidArgument,
-    InvalidPatch,
-    UnsupportedElement,
-    WrongOutputSize,
-    ApplyError,
-    AllocationFailure,
-    UnsupportedTarget,
-    Cancelled,
-    Unknown(i32),
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct Error {
-    status: Status,
-    message: String,
-}
-
-impl Error {
-    pub fn status(&self) -> Status {
-        self.status
-    }
-
-    pub(crate) fn new(status: Status, message: impl Into<String>) -> Self {
-        Self { status, message: message.into() }
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        formatter.write_str(&self.message)
-    }
-}
-
-impl error::Error for Error {}
-
-pub type Result<T> = std::result::Result<T, Error>;
-
-/// Builds an `AllocationFailure` for a named attacker-influenced allocation.
-pub(crate) fn allocation_error(context: &str) -> Error {
-    Error::new(Status::AllocationFailure, format!("unable to allocate {context}"))
-}
-
-/// A parsed reference type within an executable element.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub struct GroupTraits {
-    pub width: u32,
-    pub type_tag: u8,
-    pub pool_tag: u8,
-}
-
-/// The reference-correction interface implemented by each element format.
-pub trait Disassembler {
-    /// Size of the recognized executable, after header parsing shrinks the view.
-    fn size(&self) -> u32;
-
-    /// Reference groups, in the native `MakeReferenceGroups()` order.
-    fn groups(&self) -> &[GroupTraits];
-
-    /// Emits references of `group` whose bodies lie in `[lo, hi)`.
-    ///
-    /// Fallible so that reference vectors derived from attacker-controlled
-    /// counts can fail with `Status::AllocationFailure` instead of aborting.
-    fn read(&self, group: usize, image: &[u8], lo: u32, hi: u32) -> Result<Vec<Reference>>;
-
-    /// Writes a single corrected reference into the new image.
-    fn write(&self, group: usize, image: &mut [u8], reference: Reference);
-}
-
-/// Applies a Zucchini patch into a newly allocated, exact-size output buffer.
-pub fn apply(old: &[u8], patch_bytes: &[u8], output_size: usize) -> Result<Vec<u8>> {
-    apply_with_cancel(old, patch_bytes, output_size, || false)
-}
-
-/// Same as [`apply`], but polls `cancelled` between elements, pools, and
-/// equivalence units and returns [`Status::Cancelled`] if it becomes true.
-///
-/// This keeps the original [`apply`] signature intact while giving callers a
-/// cooperative stop hook (for example, a UI or signal-driven token).
-pub fn apply_with_cancel<F: Fn() -> bool>(
-    old: &[u8],
-    patch_bytes: &[u8],
-    output_size: usize,
-    cancelled: F,
-) -> Result<Vec<u8>> {
-    apply_inner(old, patch_bytes, output_size, &cancelled)
-}
-
-fn apply_inner(
-    old: &[u8],
-    patch_bytes: &[u8],
-    output_size: usize,
-    cancelled: &dyn Fn() -> bool,
-) -> Result<Vec<u8>> {
-    let check = || -> Result<()> {
-        if cancelled() {
-            Err(Error::new(Status::Cancelled, "Zucchini apply cancelled"))
-        } else {
-            Ok(())
-        }
-    };
-
-    check()?;
-    if old.len() >= OFFSET_BOUND || output_size >= OFFSET_BOUND {
-        return Err(Error::new(Status::InvalidArgument, "image exceeds Zucchini offset bound"));
-    }
-    if patch_bytes.len() >= OFFSET_BOUND {
-        return Err(Error::new(Status::InvalidArgument, "patch exceeds Zucchini offset bound"));
-    }
-
-    let patch = patch::Patch::parse(patch_bytes)?;
-    if patch.header.new_size as usize != output_size {
-        return Err(Error::new(Status::WrongOutputSize, "output buffer size does not match patch"));
-    }
-
-    // Reject element formats that Android never emits, matching the native FFI
-    // allow-list (NoOp plus Android executables).
-    for element in &patch.elements {
-        if element.element_match.exe_type != patch::EXE_TYPE_NOOP
-            && !is_android_executable(element.element_match.exe_type)
-        {
-            return Err(Error::new(
-                Status::UnsupportedElement,
-                "element format is not enabled by Android",
-            ));
-        }
-    }
-
-    let mut output = Vec::new();
-    output.try_reserve_exact(output_size).map_err(|error| {
-        Error::new(
-            Status::AllocationFailure,
-            format!("unable to allocate Zucchini output: {error}"),
-        )
-    })?;
-    output.resize(output_size, 0);
-
-    // Android hardens upstream apply with an additional preflight. Mirror the
-    // native FFI so unsafe patches are rejected before publication. The native
-    // `PreflightAndroidElements` performs the old-file check here too, hence the
-    // preflight-specific message.
-    if !patch::check_old_file_cancel(&patch.header, old, cancelled)? {
-        return Err(Error::new(Status::ApplyError, "android executable preflight failed"));
-    }
-    for element in &patch.elements {
-        check()?;
-        let exe_type = element.element_match.exe_type;
-        // Parse and cache the old element's per-group references once, then
-        // share them between preflight and apply (the native FFI re-reads them
-        // for every equivalence in both phases).
-        let (old_element, new_element) = engine::element_regions(old, element, &mut output)?;
-        let analysis = engine::analyze_element(exe_type, old_element)?;
-        engine::preflight_element(element, old_element, new_element, &analysis, cancelled)
-            .map_err(|error| match error.status() {
-                Status::Cancelled => error,
-                _ => Error::new(Status::ApplyError, "android executable preflight failed"),
-            })?;
-        let (old_element, new_element) = engine::element_regions(old, element, &mut output)?;
-        engine::apply_element(element, old_element, new_element, &analysis, cancelled)?;
-    }
-
-    if !patch::check_new_file_cancel(&patch.header, &output, cancelled)? {
-        return Err(Error::new(Status::ApplyError, "zucchini apply failed"));
-    }
-    Ok(output)
-}
-
-pub(crate) fn is_android_executable(exe_type: u32) -> bool {
-    matches!(
-        exe_type,
-        patch::EXE_TYPE_ELF_X86
-            | patch::EXE_TYPE_ELF_X64
-            | patch::EXE_TYPE_ELF_AARCH32
-            | patch::EXE_TYPE_ELF_AARCH64
-            | patch::EXE_TYPE_DEX
-    )
-}
-
-/// Dispatches to the format disassembler for `exe_type`, parsing `image`.
-pub(crate) fn make_disassembler(exe_type: u32, image: &[u8]) -> Option<Box<dyn Disassembler>> {
-    match exe_type {
-        patch::EXE_TYPE_NOOP => {
-            Some(Box::new(engine::NoOpDisassembler { size: image.len() as u32 }))
-        }
-        patch::EXE_TYPE_ELF_X86 => {
-            elf::ElfDisassembler::parse(elf::ElfKind::X86, image).map(|d| Box::new(d) as _)
-        }
-        patch::EXE_TYPE_ELF_X64 => {
-            elf::ElfDisassembler::parse(elf::ElfKind::X64, image).map(|d| Box::new(d) as _)
-        }
-        patch::EXE_TYPE_ELF_AARCH32 => {
-            elf::ElfDisassembler::parse(elf::ElfKind::AArch32, image).map(|d| Box::new(d) as _)
-        }
-        patch::EXE_TYPE_ELF_AARCH64 => {
-            elf::ElfDisassembler::parse(elf::ElfKind::AArch64, image).map(|d| Box::new(d) as _)
-        }
-        patch::EXE_TYPE_DEX => dex::DexDisassembler::parse(image).map(|d| Box::new(d) as _),
-        _ => None,
-    }
-}
diff --git a/src/zucchini_pure/patch.rs b/src/zucchini_pure/patch.rs
deleted file mode 100644
index 11213e1..0000000
--- a/src/zucchini_pure/patch.rs
+++ /dev/null
@@ -1,508 +0,0 @@
-//! Parsing for the Zucchini ensemble patch format.
-//!
-//! This mirrors `components/zucchini/patch_reader.{h,cc}` and
-//! `components/zucchini/patch_utils.h`, including the stream-termination
-//! semantics that the native apply path relies on.
-
-use std::collections::BTreeMap;
-
-use super::bytes::read_u16;
-use super::bytes::read_u32;
-use super::{Error, Result, Status};
-
-/// Magic signature `'Z' | ('u' << 8) | ('c' << 16) | ('c' << 24)`.
-pub const PATCH_MAGIC: u32 = u32::from_le_bytes(*b"Zucc");
-pub const MAJOR_VERSION: u16 = 1;
-pub const K_INVALID_VERSION: u16 = 0xFFFF;
-
-pub const EXE_TYPE_NOOP: u32 = u32::from_le_bytes(*b"NoOp");
-pub const EXE_TYPE_ELF_X86: u32 = u32::from_le_bytes(*b"Ex86");
-pub const EXE_TYPE_ELF_X64: u32 = u32::from_le_bytes(*b"Ex64");
-pub const EXE_TYPE_ELF_AARCH32: u32 = u32::from_le_bytes(*b"EA32");
-pub const EXE_TYPE_ELF_AARCH64: u32 = u32::from_le_bytes(*b"EA64");
-pub const EXE_TYPE_DEX: u32 = u32::from_le_bytes(*b"DEX ");
-
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-pub struct PatchHeader {
-    pub magic: u32,
-    pub major_version: u16,
-    pub minor_version: u16,
-    pub old_size: u32,
-    pub old_crc: u32,
-    pub new_size: u32,
-    pub new_crc: u32,
-}
-
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-pub struct ElementMatch {
-    pub old_offset: u32,
-    pub old_size: u32,
-    pub new_offset: u32,
-    pub new_size: u32,
-    pub exe_type: u32,
-}
-
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-pub struct Equivalence {
-    pub src_offset: u32,
-    pub dst_offset: u32,
-    pub length: u32,
-}
-
-impl Equivalence {
-    pub fn src_end(&self) -> u32 {
-        self.src_offset.wrapping_add(self.length)
-    }
-
-    pub fn dst_end(&self) -> u32 {
-        self.dst_offset.wrapping_add(self.length)
-    }
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub struct RawDeltaUnit {
-    pub copy_offset: u32,
-    pub diff: i8,
-}
-
-#[derive(Clone, Debug)]
-pub struct PatchElement {
-    pub element_match: ElementMatch,
-    pub equivalences: Vec<Equivalence>,
-    /// Whether every equivalence stream was fully consumed (native `Done()`).
-    pub equivalences_done: bool,
-    pub extra_data: Vec<u8>,
-    pub raw_deltas: Vec<RawDeltaUnit>,
-    pub raw_deltas_done: bool,
-    pub reference_deltas: Vec<i32>,
-    pub reference_deltas_done: bool,
-    pub extra_targets: BTreeMap<u8, ExtraTargets>,
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct ExtraTargets {
-    pub targets: Vec<u32>,
-    pub done: bool,
-}
-
-#[derive(Clone, Debug)]
-pub struct Patch {
-    pub header: PatchHeader,
-    pub elements: Vec<PatchElement>,
-}
-
-struct Cursor<'a> {
-    data: &'a [u8],
-    pos: usize,
-}
-
-impl<'a> Cursor<'a> {
-    fn new(data: &'a [u8]) -> Self {
-        Self { data, pos: 0 }
-    }
-
-    fn remaining(&self) -> usize {
-        self.data.len().saturating_sub(self.pos)
-    }
-
-    fn empty(&self) -> bool {
-        self.remaining() == 0
-    }
-
-    fn take(&mut self, count: usize) -> Option<&'a [u8]> {
-        let end = self.pos.checked_add(count)?;
-        let slice = self.data.get(self.pos..end)?;
-        self.pos = end;
-        Some(slice)
-    }
-
-    fn u8(&mut self) -> Option<u8> {
-        let value = *self.data.get(self.pos)?;
-        self.pos += 1;
-        Some(value)
-    }
-
-    fn u16(&mut self) -> Option<u16> {
-        let value = read_u16(self.data, self.pos)?;
-        self.pos += 2;
-        Some(value)
-    }
-
-    fn u32(&mut self) -> Option<u32> {
-        let value = read_u32(self.data, self.pos)?;
-        self.pos += 4;
-        Some(value)
-    }
-
-    /// Decodes a `uint32_t` base-128 varint, mirroring `DecodeVarUInt`. On
-    /// failure the cursor is left unchanged, matching `ParseVarUInt`, which only
-    /// consumes bytes when decoding succeeds.
-    fn var_u32(&mut self) -> Option<u32> {
-        let start = self.pos;
-        let mut value = 0u32;
-        for shift in (0..32).step_by(7) {
-            let Some(&byte) = self.data.get(self.pos) else {
-                self.pos = start;
-                return None;
-            };
-            self.pos += 1;
-            value |= u32::from(byte & 0x7F) << shift;
-            if byte < 0x80 {
-                return Some(value);
-            }
-        }
-        self.pos = start;
-        None
-    }
-
-    /// Decodes an `int32_t` zig-zag varint, mirroring `DecodeVarInt`.
-    fn var_i32(&mut self) -> Option<i32> {
-        let tmp = self.var_u32()?;
-        if tmp & 1 != 0 { Some(!((tmp >> 1) as i32)) } else { Some((tmp >> 1) as i32) }
-    }
-
-    /// Mirrors `patch::ParseBuffer`: a `uint32_t` size followed by that many bytes.
-    fn buffer(&mut self) -> Option<&'a [u8]> {
-        let size = self.u32()? as usize;
-        self.take(size)
-    }
-}
-
-fn invalid_patch(message: &str) -> Error {
-    Error { status: Status::InvalidPatch, message: message.into() }
-}
-
-fn executable_version(exe_type: u32) -> Option<u16> {
-    match exe_type {
-        EXE_TYPE_NOOP | EXE_TYPE_ELF_X86 | EXE_TYPE_ELF_X64 | EXE_TYPE_ELF_AARCH32
-        | EXE_TYPE_ELF_AARCH64 | EXE_TYPE_DEX => Some(1),
-        _ => None,
-    }
-}
-
-fn parse_element_match(cursor: &mut Cursor<'_>) -> Option<ElementMatch> {
-    let old_offset = cursor.u32()?;
-    let old_size = cursor.u32()?;
-    let new_offset = cursor.u32()?;
-    let new_size = cursor.u32()?;
-    let exe_type = cursor.u32()?;
-    let version = cursor.u16()?;
-    let expected = executable_version(exe_type)?;
-    if expected != version {
-        return None;
-    }
-    if old_size == 0 || new_size == 0 {
-        return None;
-    }
-    Some(ElementMatch { old_offset, old_size, new_offset, new_size, exe_type })
-}
-
-/// Decodes all equivalences and reports whether the three streams were fully
-/// consumed, matching `EquivalenceSource::Done()`.
-fn parse_equivalences(
-    src_skip: &[u8],
-    dst_skip: &[u8],
-    copy_count: &[u8],
-) -> Result<(Vec<Equivalence>, bool)> {
-    let mut src = Cursor::new(src_skip);
-    let mut dst = Cursor::new(dst_skip);
-    let mut count = Cursor::new(copy_count);
-    let mut result = Vec::new();
-    // Each decoded equivalence consumes at least one byte from every stream.
-    let upper = src_skip.len().min(dst_skip.len()).min(copy_count.len());
-    result
-        .try_reserve(upper)
-        .map_err(|_| super::allocation_error("Zucchini equivalence stream"))?;
-    let mut previous_src: u32 = 0;
-    let mut previous_dst: u32 = 0;
-    while !src.empty() && !dst.empty() && !count.empty() {
-        let length = match count.var_u32() {
-            Some(value) => value,
-            None => break,
-        };
-        let src_diff = match src.var_i32() {
-            Some(value) => value,
-            None => break,
-        };
-        let src_offset = match (previous_src as i64).checked_add(src_diff as i64) {
-            Some(value) if (0..=u32::MAX as i64).contains(&value) => value as u32,
-            _ => break,
-        };
-        previous_src = match src_offset.checked_add(length) {
-            Some(value) => value,
-            None => break,
-        };
-        let dst_diff = match dst.var_u32() {
-            Some(value) => value,
-            None => break,
-        };
-        let dst_offset = match previous_dst.checked_add(dst_diff) {
-            Some(value) => value,
-            None => break,
-        };
-        previous_dst = match dst_offset.checked_add(length) {
-            Some(value) => value,
-            None => break,
-        };
-        result.push(Equivalence { src_offset, dst_offset, length });
-    }
-    let done = src.empty() && dst.empty() && count.empty();
-    Ok((result, done))
-}
-
-fn parse_raw_deltas(skip: &[u8], diffs: &[u8]) -> Result<(Vec<RawDeltaUnit>, bool)> {
-    let mut skip = Cursor::new(skip);
-    let mut diffs = Cursor::new(diffs);
-    let mut result = Vec::new();
-    let upper = skip.data.len().min(diffs.data.len());
-    result.try_reserve(upper).map_err(|_| super::allocation_error("Zucchini raw delta stream"))?;
-    let mut compensation: u32 = 0;
-    while !skip.empty() && !diffs.empty() {
-        let diff = match skip.var_u32() {
-            Some(value) => value,
-            None => break,
-        };
-        let copy_offset = match diff.checked_add(compensation) {
-            Some(value) => value,
-            None => break,
-        };
-        let byte = match diffs.u8() {
-            Some(value) => value,
-            None => break,
-        };
-        let byte_diff = byte as i8;
-        if byte_diff == 0 {
-            break;
-        }
-        compensation = match copy_offset.checked_add(1) {
-            Some(value) => value,
-            None => break,
-        };
-        result.push(RawDeltaUnit { copy_offset, diff: byte_diff });
-    }
-    let done = skip.empty() && diffs.empty();
-    Ok((result, done))
-}
-
-fn parse_reference_deltas(source: &[u8]) -> Result<(Vec<i32>, bool)> {
-    let mut cursor = Cursor::new(source);
-    let mut result = Vec::new();
-    result
-        .try_reserve(source.len())
-        .map_err(|_| super::allocation_error("Zucchini reference delta stream"))?;
-    while !cursor.empty() {
-        match cursor.var_i32() {
-            Some(value) => result.push(value),
-            None => break,
-        }
-    }
-    Ok((result, cursor.empty()))
-}
-
-fn parse_extra_targets(source: &[u8]) -> Result<ExtraTargets> {
-    let mut cursor = Cursor::new(source);
-    let mut targets = Vec::new();
-    targets
-        .try_reserve(source.len())
-        .map_err(|_| super::allocation_error("Zucchini extra target stream"))?;
-    let mut compensation: u32 = 0;
-    while !cursor.empty() {
-        let diff = match cursor.var_u32() {
-            Some(value) => value,
-            None => break,
-        };
-        let target = match diff.checked_add(compensation) {
-            Some(value) => value,
-            None => break,
-        };
-        compensation = match target.checked_add(1) {
-            Some(value) => value,
-            None => break,
-        };
-        targets.push(target);
-    }
-    Ok(ExtraTargets { targets, done: cursor.empty() })
-}
-
-impl PatchElement {
-    fn parse(cursor: &mut Cursor<'_>) -> Result<Self> {
-        let element_match =
-            parse_element_match(cursor).ok_or_else(|| invalid_patch("invalid patch element"))?;
-
-        let src_skip =
-            cursor.buffer().ok_or_else(|| invalid_patch("invalid equivalence source"))?;
-        let dst_skip =
-            cursor.buffer().ok_or_else(|| invalid_patch("invalid equivalence source"))?;
-        let copy_count =
-            cursor.buffer().ok_or_else(|| invalid_patch("invalid equivalence source"))?;
-        let (equivalences, equivalences_done) = parse_equivalences(src_skip, dst_skip, copy_count)?;
-        let extra_slice = cursor.buffer().ok_or_else(|| invalid_patch("invalid extra data"))?;
-        let mut extra_data = Vec::new();
-        extra_data
-            .try_reserve_exact(extra_slice.len())
-            .map_err(|_| super::allocation_error("Zucchini extra data"))?;
-        extra_data.extend_from_slice(extra_slice);
-
-        // Mirrors ValidateEquivalencesAndExtraData().
-        let old_region_size = u64::from(element_match.old_size);
-        let new_region_size = u64::from(element_match.new_size);
-        let mut total_length: u64 = 0;
-        let mut previous_dst_end: u64 = 0;
-        for equivalence in &equivalences {
-            if !super::bytes::range_is_bounded(
-                u64::from(equivalence.src_offset),
-                u64::from(equivalence.length),
-                old_region_size,
-            ) || !super::bytes::range_is_bounded(
-                u64::from(equivalence.dst_offset),
-                u64::from(equivalence.length),
-                new_region_size,
-            ) {
-                return Err(invalid_patch("out of bounds equivalence"));
-            }
-            if previous_dst_end > u64::from(equivalence.dst_end()) {
-                return Err(invalid_patch("out of order equivalence"));
-            }
-            previous_dst_end = u64::from(equivalence.dst_end());
-            total_length += u64::from(equivalence.length);
-        }
-        if total_length > new_region_size
-            || extra_data.len() as u64 != new_region_size - total_length
-        {
-            return Err(invalid_patch("incorrect amount of extra data"));
-        }
-
-        let raw_skip = cursor.buffer().ok_or_else(|| invalid_patch("invalid raw delta source"))?;
-        let raw_diff = cursor.buffer().ok_or_else(|| invalid_patch("invalid raw delta source"))?;
-        let (raw_deltas, raw_deltas_done) = parse_raw_deltas(raw_skip, raw_diff)?;
-
-        let reference_source =
-            cursor.buffer().ok_or_else(|| invalid_patch("invalid reference delta source"))?;
-        let (reference_deltas, reference_deltas_done) = parse_reference_deltas(reference_source)?;
-
-        let pool_count = cursor.u32().ok_or_else(|| invalid_patch("invalid extra target list"))?;
-        // Each pool costs at least a tag byte plus a 4-byte length prefix.
-        if pool_count as usize > cursor.remaining() / 5 {
-            return Err(invalid_patch("invalid extra target list"));
-        }
-        let mut extra_targets = BTreeMap::new();
-        for _ in 0..pool_count {
-            let pool_tag = cursor.u8().ok_or_else(|| invalid_patch("invalid extra target list"))?;
-            if pool_tag == 0xFF {
-                return Err(invalid_patch("invalid pool tag"));
-            }
-            let source =
-                cursor.buffer().ok_or_else(|| invalid_patch("invalid extra target list"))?;
-            if extra_targets.insert(pool_tag, parse_extra_targets(source)?).is_some() {
-                return Err(invalid_patch("duplicate pool tag"));
-            }
-        }
-
-        Ok(PatchElement {
-            element_match,
-            equivalences,
-            equivalences_done,
-            extra_data,
-            raw_deltas,
-            raw_deltas_done,
-            reference_deltas,
-            reference_deltas_done,
-            extra_targets,
-        })
-    }
-}
-
-impl Patch {
-    pub fn parse(data: &[u8]) -> Result<Self> {
-        let mut cursor = Cursor::new(data);
-        let header = PatchHeader {
-            magic: cursor.u32().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
-            major_version: cursor.u16().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
-            minor_version: cursor.u16().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
-            old_size: cursor.u32().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
-            old_crc: cursor.u32().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
-            new_size: cursor.u32().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
-            new_crc: cursor.u32().ok_or_else(|| invalid_patch("invalid ensemble patch"))?,
-        };
-        if header.magic != PATCH_MAGIC || header.major_version != MAJOR_VERSION {
-            return Err(invalid_patch("invalid ensemble patch"));
-        }
-        let element_count = cursor.u32().ok_or_else(|| invalid_patch("invalid ensemble patch"))?;
-        let mut elements = Vec::new();
-        // Each element header is 22 bytes, so this bounds the reservation even
-        // if `element_count` is absurd.
-        let upper = (data.len() / 22).min(element_count as usize);
-        elements
-            .try_reserve(upper)
-            .map_err(|_| super::allocation_error("Zucchini patch elements"))?;
-        let mut current_dst_offset: u32 = 0;
-        for _ in 0..element_count {
-            let element = PatchElement::parse(&mut cursor)?;
-            if !region_fits(
-                element.element_match.old_offset,
-                element.element_match.old_size,
-                header.old_size,
-            ) || !region_fits(
-                element.element_match.new_offset,
-                element.element_match.new_size,
-                header.new_size,
-            ) {
-                return Err(invalid_patch("invalid patch element"));
-            }
-            if element.element_match.new_offset != current_dst_offset {
-                return Err(invalid_patch("invalid patch element"));
-            }
-            current_dst_offset = element
-                .element_match
-                .new_offset
-                .checked_add(element.element_match.new_size)
-                .ok_or_else(|| invalid_patch("invalid patch element"))?;
-            elements.push(element);
-        }
-        if current_dst_offset != header.new_size {
-            return Err(invalid_patch("patch elements do not fully cover new image"));
-        }
-        if !cursor.empty() {
-            return Err(invalid_patch("patch was not fully consumed"));
-        }
-        Ok(Patch { header, elements })
-    }
-}
-
-fn region_fits(offset: u32, size: u32, container: u32) -> bool {
-    offset <= container && container - offset >= size
-}
-
-pub fn check_old_file(header: &PatchHeader, old_image: &[u8]) -> bool {
-    old_image.len() == header.old_size as usize
-        && super::crc32::calculate_crc32(old_image) == header.old_crc
-}
-
-pub fn check_new_file(header: &PatchHeader, new_image: &[u8]) -> bool {
-    new_image.len() == header.new_size as usize
-        && super::crc32::calculate_crc32(new_image) == header.new_crc
-}
-
-/// Cancellable variant of [`check_old_file`].
-pub(crate) fn check_old_file_cancel(
-    header: &PatchHeader,
-    old_image: &[u8],
-    cancelled: &dyn Fn() -> bool,
-) -> Result<bool> {
-    if old_image.len() != header.old_size as usize {
-        return Ok(false);
-    }
-    Ok(super::crc32::calculate_crc32_cancel(old_image, cancelled)? == header.old_crc)
-}
-
-/// Cancellable variant of [`check_new_file`].
-pub(crate) fn check_new_file_cancel(
-    header: &PatchHeader,
-    new_image: &[u8],
-    cancelled: &dyn Fn() -> bool,
-) -> Result<bool> {
-    if new_image.len() != header.new_size as usize {
-        return Ok(false);
-    }
-    Ok(super::crc32::calculate_crc32_cancel(new_image, cancelled)? == header.new_crc)
-}
diff --git a/tests/zucchini_pure.rs b/tests/zucchini_pure.rs
deleted file mode 100644
index 9f3e3d8..0000000
--- a/tests/zucchini_pure.rs
+++ /dev/null
@@ -1,271 +0,0 @@
-//! Byte-exact fixture tests for the pure-Rust Zucchini apply path.
-
-use std::fs;
-use std::path::Path;
-
-use otadump::zucchini_pure::{self, Status};
-
-const FIXTURES: &str = "tests/fixtures/zucchini";
-
-/// Applies `<name>-old<ext>` + `<name>.zuc` and compares with `<name>-new<ext>`.
-fn assert_fixture(name: &str, extension: &str) {
-    let fixtures = Path::new(FIXTURES);
-    let old = fs::read(fixtures.join(format!("{name}-old{extension}"))).unwrap();
-    let expected = fs::read(fixtures.join(format!("{name}-new{extension}"))).unwrap();
-    let patch = fs::read(fixtures.join(format!("{name}.zuc"))).unwrap();
-    let output = zucchini_pure::apply(&old, &patch, expected.len()).unwrap();
-    assert_eq!(output, expected, "fixture {name} did not reconstruct byte-exactly");
-}
-
-#[test]
-fn pure_rust_applies_noop_and_elf_fixtures() {
-    assert_fixture("noop", ".bin");
-    assert_fixture("elf-x86", "");
-    assert_fixture("elf", "");
-    assert_fixture("elf-arm32", "");
-    assert_fixture("elf-arm64", "");
-}
-
-#[test]
-fn pure_rust_applies_dex_fixtures() {
-    assert_fixture("dex", ".dex");
-    assert_fixture("dex-large", ".dex");
-}
-
-#[test]
-fn pure_rust_rejects_garbage_patch() {
-    let error = zucchini_pure::apply(b"abcd", b"not a patch", 5).unwrap_err();
-    assert_eq!(error.status(), Status::InvalidPatch);
-}
-
-#[test]
-fn pure_rust_rejects_wrong_output_size() {
-    let fixtures = Path::new(FIXTURES);
-    let old = fs::read(fixtures.join("noop-old.bin")).unwrap();
-    let patch = fs::read(fixtures.join("noop.zuc")).unwrap();
-    let error = zucchini_pure::apply(&old, &patch, 999).unwrap_err();
-    assert_eq!(error.status(), Status::WrongOutputSize);
-}
-
-/// Mirrors the native test for `dex-large-unsafe16.zuc`: the Android preflight
-/// must reject the unsafe 16-bit string reference before publication.
-#[test]
-fn pure_rust_rejects_unsafe_large_dex_string16_reference() {
-    let fixtures = Path::new(FIXTURES);
-    let old = fs::read(fixtures.join("dex-large-old.dex")).unwrap();
-    let patch = fs::read(fixtures.join("dex-large-unsafe16.zuc")).unwrap();
-    let expected_size = fs::metadata(fixtures.join("dex-large-new.dex")).unwrap().len() as usize;
-    let error = zucchini_pure::apply(&old, &patch, expected_size).unwrap_err();
-    assert_eq!(error.status(), Status::ApplyError);
-    assert_eq!(error.to_string(), "android executable preflight failed");
-}
-
-#[test]
-fn pure_rust_rejects_truncated_patch() {
-    let fixtures = Path::new(FIXTURES);
-    let old = fs::read(fixtures.join("noop-old.bin")).unwrap();
-    let patch = fs::read(fixtures.join("noop.zuc")).unwrap();
-    let error = zucchini_pure::apply(&old, &patch[..patch.len() - 1], 5).unwrap_err();
-    assert_eq!(error.status(), Status::InvalidPatch);
-}
-
-fn var_u32(mut value: u32, out: &mut Vec<u8>) {
-    while value >= 0x80 {
-        out.push((value as u8) | 0x80);
-        value >>= 7;
-    }
-    out.push(value as u8);
-}
-
-fn var_i32(value: i32, out: &mut Vec<u8>) {
-    let encoded = if value < 0 { (((!value) as u32) << 1) | 1 } else { (value as u32) << 1 };
-    var_u32(encoded, out);
-}
-
-fn push_buffer(out: &mut Vec<u8>, data: &[u8]) {
-    out.extend_from_slice(&(data.len() as u32).to_le_bytes());
-    out.extend_from_slice(data);
-}
-
-fn crc32(data: &[u8]) -> u32 {
-    let mut table = [0u32; 256];
-    for (index, entry) in table.iter_mut().enumerate() {
-        let mut r = index as u32;
-        for _ in 0..8 {
-            r = (r >> 1) ^ (0xEDB8_8320 & (!((r & 1).wrapping_sub(1))));
-        }
-        *entry = r;
-    }
-    let mut crc = 0xFFFF_FFFFu32;
-    for &byte in data {
-        crc = table[((crc ^ u32::from(byte)) & 0xFF) as usize] ^ (crc >> 8);
-    }
-    crc ^ 0xFFFF_FFFF
-}
-
-/// Builds a single-element NoOp patch whose reference-delta stream is
-/// `reference_delta`.
-fn build_noop_patch(old: &[u8], new: &[u8], reference_delta: &[u8]) -> Vec<u8> {
-    let mut patch = Vec::new();
-    patch.extend_from_slice(b"Zucc");
-    patch.extend_from_slice(&1u16.to_le_bytes());
-    patch.extend_from_slice(&0u16.to_le_bytes());
-    patch.extend_from_slice(&(old.len() as u32).to_le_bytes());
-    patch.extend_from_slice(&crc32(old).to_le_bytes());
-    patch.extend_from_slice(&(new.len() as u32).to_le_bytes());
-    patch.extend_from_slice(&crc32(new).to_le_bytes());
-    patch.extend_from_slice(&1u32.to_le_bytes());
-
-    patch.extend_from_slice(&0u32.to_le_bytes());
-    patch.extend_from_slice(&(old.len() as u32).to_le_bytes());
-    patch.extend_from_slice(&0u32.to_le_bytes());
-    patch.extend_from_slice(&(new.len() as u32).to_le_bytes());
-    patch.extend_from_slice(&u32::from_le_bytes(*b"NoOp").to_le_bytes());
-    patch.extend_from_slice(&1u16.to_le_bytes());
-
-    let mut src_skip = Vec::new();
-    var_i32(0, &mut src_skip);
-    let mut dst_skip = Vec::new();
-    var_u32(0, &mut dst_skip);
-    let mut copy_count = Vec::new();
-    var_u32(old.len() as u32, &mut copy_count);
-    push_buffer(&mut patch, &src_skip);
-    push_buffer(&mut patch, &dst_skip);
-    push_buffer(&mut patch, &copy_count);
-
-    push_buffer(&mut patch, &new[old.len()..]);
-    push_buffer(&mut patch, &[]); // raw delta skip
-    push_buffer(&mut patch, &[]); // raw delta diff
-    push_buffer(&mut patch, reference_delta);
-    patch.extend_from_slice(&0u32.to_le_bytes());
-    patch
-}
-
-#[test]
-fn pure_rust_rejects_malformed_trailing_reference_delta() {
-    let old = b"ABCD";
-    let new = b"ABCDE";
-
-    // A well-formed empty stream applies cleanly for NoOp elements.
-    let valid = build_noop_patch(old, new, &[]);
-    assert_eq!(zucchini_pure::apply(old, &valid, new.len()).unwrap(), new.to_vec());
-
-    // An unterminated varint must be rejected like the native Done() semantics,
-    // even though a NoOp element needs no reference deltas at all.
-    let malformed = build_noop_patch(old, new, &[0x80]);
-    let error = zucchini_pure::apply(old, &malformed, new.len()).unwrap_err();
-    assert_eq!(error.status(), Status::ApplyError);
-}
-
-#[test]
-fn pure_rust_honors_cancellation() {
-    use std::cell::Cell;
-
-    let fixtures = Path::new(FIXTURES);
-    let old = fs::read(fixtures.join("noop-old.bin")).unwrap();
-    let patch = fs::read(fixtures.join("noop.zuc")).unwrap();
-    let new_size = fs::metadata(fixtures.join("noop-new.bin")).unwrap().len() as usize;
-
-    let calls = Cell::new(0);
-    let error = zucchini_pure::apply_with_cancel(&old, &patch, new_size, || {
-        calls.set(calls.get() + 1);
-        calls.get() > 1
-    })
-    .unwrap_err();
-    assert_eq!(error.status(), Status::Cancelled);
-}
-
-/// Cancellation occurring while the Android preflight is running must surface
-/// as `Status::Cancelled`, not be folded into the preflight `ApplyError`.
-#[test]
-fn pure_rust_preserves_cancellation_through_preflight() {
-    use std::cell::Cell;
-
-    let fixtures = Path::new(FIXTURES);
-    for (old_name, patch_name, new_name) in
-        [("elf-old", "elf.zuc", "elf-new"), ("dex-old.dex", "dex.zuc", "dex-new.dex")]
-    {
-        let old = fs::read(fixtures.join(old_name)).unwrap();
-        let patch = fs::read(fixtures.join(patch_name)).unwrap();
-        let size = fs::metadata(fixtures.join(new_name)).unwrap().len() as usize;
-
-        // Every early poll site (CRC chunks, per-element, per-group, per
-        // equivalence, and DEX target validation) must preserve Cancelled.
-        for threshold in 1..=20u32 {
-            let calls = Cell::new(0u32);
-            let error = zucchini_pure::apply_with_cancel(&old, &patch, size, || {
-                calls.set(calls.get() + 1);
-                calls.get() >= threshold
-            })
-            .unwrap_err();
-            assert_eq!(
-                error.status(),
-                Status::Cancelled,
-                "{patch_name} threshold {threshold} lost cancellation: {error}"
-            );
-        }
-    }
-}
-
-/// A declared stream length larger than the patch must be rejected during
-/// parsing without attempting the allocation.
-#[test]
-fn pure_rust_rejects_absurd_declared_stream_length() {
-    let old = b"ABCD";
-    let new = b"ABCDE";
-    let mut patch = Vec::new();
-    patch.extend_from_slice(b"Zucc");
-    patch.extend_from_slice(&1u16.to_le_bytes());
-    patch.extend_from_slice(&0u16.to_le_bytes());
-    patch.extend_from_slice(&(old.len() as u32).to_le_bytes());
-    patch.extend_from_slice(&crc32(old).to_le_bytes());
-    patch.extend_from_slice(&(new.len() as u32).to_le_bytes());
-    patch.extend_from_slice(&crc32(new).to_le_bytes());
-    patch.extend_from_slice(&1u32.to_le_bytes());
-
-    patch.extend_from_slice(&0u32.to_le_bytes());
-    patch.extend_from_slice(&(old.len() as u32).to_le_bytes());
-    patch.extend_from_slice(&0u32.to_le_bytes());
-    patch.extend_from_slice(&(new.len() as u32).to_le_bytes());
-    patch.extend_from_slice(&u32::from_le_bytes(*b"NoOp").to_le_bytes());
-    patch.extend_from_slice(&1u16.to_le_bytes());
-
-    patch.extend_from_slice(&1u32.to_le_bytes());
-    patch.push(0); // src_skip
-    patch.extend_from_slice(&1u32.to_le_bytes());
-    patch.push(0); // dst_skip
-    // copy_count claims 4 GiB while the patch ends here.
-    patch.extend_from_slice(&u32::MAX.to_le_bytes());
-
-    let error = zucchini_pure::apply(old, &patch, new.len()).unwrap_err();
-    assert_eq!(error.status(), Status::InvalidPatch);
-}
-
-#[test]
-fn pure_rust_rejects_absurd_pool_count() {
-    let old = b"ABCD";
-    let new = b"ABCDE";
-    let mut patch = build_noop_patch(old, new, &[]);
-    let len = patch.len();
-    patch[len - 4..].copy_from_slice(&u32::MAX.to_le_bytes());
-    let error = zucchini_pure::apply(old, &patch, new.len()).unwrap_err();
-    assert_eq!(error.status(), Status::InvalidPatch);
-}
-
-#[test]
-fn pure_rust_rejects_absurd_element_count() {
-    let old = b"ABCD";
-    let new = b"ABCDE";
-    let mut patch = build_noop_patch(old, new, &[]);
-    patch[24..28].copy_from_slice(&u32::MAX.to_le_bytes());
-    let error = zucchini_pure::apply(old, &patch, new.len()).unwrap_err();
-    assert_eq!(error.status(), Status::InvalidPatch);
-}
-
-/// Real-world differential case (AndroidX annotation-jvm 1.8.1 -> 1.10.0).
-/// It requires both the canonical Dalvik opcode-family mapping and the
-/// libstdc++ `std::sort` tie ordering in the equivalence-map pruning.
-#[test]
-fn pure_rust_applies_realistic_dex_differential_fixture() {
-    assert_fixture("annotation-jvm", ".dex");
-}

From c55a0a809a5143ca1bd3f4e3e13ec7611c66df62 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 22:24:23 +0530
Subject: [PATCH 39/42] test: consolidate opaque fixtures into deterministic
 corpus

Signed-off-by: Akhil Narang <me@akhilnarang.dev>
---
 src/lz4.rs                                    |  86 ++++++++++++------
 tests/delta_extraction.rs                     |  63 +++++++------
 tests/fixture_corpus.rs                       |  30 ++++++
 tests/fixtures/corpus/MANIFEST.txt            |  46 ++++++++++
 tests/fixtures/corpus/README.md               |   8 ++
 tests/fixtures/corpus/SHA256SUMS              |   1 +
 tests/fixtures/corpus/opaque-fixtures.zip     | Bin 0 -> 1822459 bytes
 tests/fixtures/fec/fec-300-block.bin          | Bin 16384 -> 0 bytes
 tests/fixtures/fec/fec-one-block.bin          |   1 -
 tests/fixtures/lz4/lz4-no-postfix.lz4         | Bin 768 -> 0 bytes
 tests/fixtures/lz4/lz4-no-postfix.raw         |   3 -
 tests/fixtures/lz4/lz4hc9-no-postfix.lz4      | Bin 1152 -> 0 bytes
 tests/fixtures/lz4/lz4hc9-no-postfix.raw      | Bin 1536 -> 0 bytes
 tests/fixtures/lz4/zero-padding-layout.lz4    | Bin 608 -> 0 bytes
 tests/fixtures/lz4/zero-padding-layout.raw    |   2 -
 .../fixtures/lz4diff/lz4-bsdiff/patch.lz4diff | Bin 181 -> 0 bytes
 .../lz4diff/lz4hc9-bsdiff/patch.lz4diff       | Bin 185 -> 0 bytes
 .../lz4diff/postfix-bsdiff/patch.lz4diff      | Bin 366 -> 0 bytes
 .../lz4diff/raw-puffdiff/patch.lz4diff        | Bin 304 -> 0 bytes
 .../fixtures/lz4diff/raw-puffdiff/source.bin  | Bin 17 -> 0 bytes
 .../fixtures/lz4diff/raw-puffdiff/target.bin  | Bin 22 -> 0 bytes
 .../lz4diff/zero-padding-bsdiff/patch.lz4diff | Bin 202 -> 0 bytes
 tests/fixtures/puffin/deflates-sample1.bin    | Bin 17 -> 0 bytes
 tests/fixtures/puffin/deflates-sample2.bin    | Bin 22 -> 0 bytes
 .../fixtures/puffin/patch-1-to-2-zucchini.puf | Bin 176 -> 0 bytes
 tests/fixtures/puffin/patch-1-to-2.puf        | Bin 266 -> 0 bytes
 tests/fixtures/puffin/patch-1-to-raw.puf      | Bin 185 -> 0 bytes
 tests/fixtures/puffin/raw-11-22-33-44.bin     |   1 -
 tests/fixtures/zucchini/README.md             |  24 +----
 tests/fixtures/zucchini/SHA256SUMS            |   2 +-
 .../fixtures/zucchini/annotation-jvm-new.dex  | Bin 29516 -> 0 bytes
 .../fixtures/zucchini/annotation-jvm-old.dex  | Bin 28568 -> 0 bytes
 tests/fixtures/zucchini/annotation-jvm.zuc    | Bin 8286 -> 0 bytes
 tests/fixtures/zucchini/dex-large-new.dex     | Bin 786788 -> 0 bytes
 tests/fixtures/zucchini/dex-large-old.dex     | Bin 786788 -> 0 bytes
 .../fixtures/zucchini/dex-large-unsafe16.zuc  | Bin 65758 -> 0 bytes
 tests/fixtures/zucchini/dex-large.zuc         | Bin 65758 -> 0 bytes
 tests/fixtures/zucchini/dex-new.dex           | Bin 400 -> 0 bytes
 tests/fixtures/zucchini/dex-old.dex           | Bin 400 -> 0 bytes
 tests/fixtures/zucchini/dex.zuc               | Bin 223 -> 0 bytes
 tests/fixtures/zucchini/elf-arm32-new         | Bin 280 -> 0 bytes
 tests/fixtures/zucchini/elf-arm32-old         | Bin 280 -> 0 bytes
 tests/fixtures/zucchini/elf-arm32.zuc         | Bin 103 -> 0 bytes
 tests/fixtures/zucchini/elf-arm64-new         | Bin 384 -> 0 bytes
 tests/fixtures/zucchini/elf-arm64-old         | Bin 384 -> 0 bytes
 tests/fixtures/zucchini/elf-arm64.zuc         | Bin 104 -> 0 bytes
 tests/fixtures/zucchini/elf-new               | Bin 4680 -> 0 bytes
 tests/fixtures/zucchini/elf-old               | Bin 4680 -> 0 bytes
 tests/fixtures/zucchini/elf-x86-new           | Bin 280 -> 0 bytes
 tests/fixtures/zucchini/elf-x86-old           | Bin 280 -> 0 bytes
 tests/fixtures/zucchini/elf-x86.zuc           | Bin 103 -> 0 bytes
 tests/fixtures/zucchini/elf.zuc               | Bin 112 -> 0 bytes
 tests/fixtures/zucchini/noop-new.bin          |   1 -
 tests/fixtures/zucchini/noop-old.bin          |   1 -
 tests/fixtures/zucchini/noop.zuc              | Bin 88 -> 0 bytes
 55 files changed, 178 insertions(+), 91 deletions(-)
 create mode 100644 tests/fixture_corpus.rs
 create mode 100644 tests/fixtures/corpus/MANIFEST.txt
 create mode 100644 tests/fixtures/corpus/README.md
 create mode 100644 tests/fixtures/corpus/SHA256SUMS
 create mode 100644 tests/fixtures/corpus/opaque-fixtures.zip
 delete mode 100644 tests/fixtures/fec/fec-300-block.bin
 delete mode 100644 tests/fixtures/fec/fec-one-block.bin
 delete mode 100644 tests/fixtures/lz4/lz4-no-postfix.lz4
 delete mode 100644 tests/fixtures/lz4/lz4-no-postfix.raw
 delete mode 100644 tests/fixtures/lz4/lz4hc9-no-postfix.lz4
 delete mode 100644 tests/fixtures/lz4/lz4hc9-no-postfix.raw
 delete mode 100644 tests/fixtures/lz4/zero-padding-layout.lz4
 delete mode 100644 tests/fixtures/lz4/zero-padding-layout.raw
 delete mode 100644 tests/fixtures/lz4diff/lz4-bsdiff/patch.lz4diff
 delete mode 100644 tests/fixtures/lz4diff/lz4hc9-bsdiff/patch.lz4diff
 delete mode 100644 tests/fixtures/lz4diff/postfix-bsdiff/patch.lz4diff
 delete mode 100644 tests/fixtures/lz4diff/raw-puffdiff/patch.lz4diff
 delete mode 100644 tests/fixtures/lz4diff/raw-puffdiff/source.bin
 delete mode 100644 tests/fixtures/lz4diff/raw-puffdiff/target.bin
 delete mode 100644 tests/fixtures/lz4diff/zero-padding-bsdiff/patch.lz4diff
 delete mode 100644 tests/fixtures/puffin/deflates-sample1.bin
 delete mode 100644 tests/fixtures/puffin/deflates-sample2.bin
 delete mode 100644 tests/fixtures/puffin/patch-1-to-2-zucchini.puf
 delete mode 100644 tests/fixtures/puffin/patch-1-to-2.puf
 delete mode 100644 tests/fixtures/puffin/patch-1-to-raw.puf
 delete mode 100644 tests/fixtures/puffin/raw-11-22-33-44.bin
 delete mode 100644 tests/fixtures/zucchini/annotation-jvm-new.dex
 delete mode 100644 tests/fixtures/zucchini/annotation-jvm-old.dex
 delete mode 100644 tests/fixtures/zucchini/annotation-jvm.zuc
 delete mode 100644 tests/fixtures/zucchini/dex-large-new.dex
 delete mode 100644 tests/fixtures/zucchini/dex-large-old.dex
 delete mode 100644 tests/fixtures/zucchini/dex-large-unsafe16.zuc
 delete mode 100644 tests/fixtures/zucchini/dex-large.zuc
 delete mode 100644 tests/fixtures/zucchini/dex-new.dex
 delete mode 100644 tests/fixtures/zucchini/dex-old.dex
 delete mode 100644 tests/fixtures/zucchini/dex.zuc
 delete mode 100644 tests/fixtures/zucchini/elf-arm32-new
 delete mode 100644 tests/fixtures/zucchini/elf-arm32-old
 delete mode 100644 tests/fixtures/zucchini/elf-arm32.zuc
 delete mode 100644 tests/fixtures/zucchini/elf-arm64-new
 delete mode 100644 tests/fixtures/zucchini/elf-arm64-old
 delete mode 100644 tests/fixtures/zucchini/elf-arm64.zuc
 delete mode 100755 tests/fixtures/zucchini/elf-new
 delete mode 100755 tests/fixtures/zucchini/elf-old
 delete mode 100644 tests/fixtures/zucchini/elf-x86-new
 delete mode 100644 tests/fixtures/zucchini/elf-x86-old
 delete mode 100644 tests/fixtures/zucchini/elf-x86.zuc
 delete mode 100644 tests/fixtures/zucchini/elf.zuc
 delete mode 100644 tests/fixtures/zucchini/noop-new.bin
 delete mode 100644 tests/fixtures/zucchini/noop-old.bin
 delete mode 100644 tests/fixtures/zucchini/noop.zuc

diff --git a/src/lz4.rs b/src/lz4.rs
index 6075365..a70f6e8 100644
--- a/src/lz4.rs
+++ b/src/lz4.rs
@@ -309,31 +309,57 @@ unsafe extern "C" {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::collections::HashMap;
+    use std::fs::File;
+    use std::sync::OnceLock;
+
+    use zip::ZipArchive;
+
+    static FIXTURES: OnceLock<HashMap<String, Vec<u8>>> = OnceLock::new();
+
+    fn fixture(path: &str) -> Vec<u8> {
+        FIXTURES
+            .get_or_init(|| {
+                let file = File::open("tests/fixtures/corpus/opaque-fixtures.zip").unwrap();
+                let mut archive = ZipArchive::new(file).unwrap();
+                let mut fixtures = HashMap::with_capacity(archive.len());
+                for index in 0..archive.len() {
+                    let mut member = archive.by_index(index).unwrap();
+                    let mut bytes = Vec::new();
+                    std::io::copy(&mut member, &mut bytes).unwrap();
+                    fixtures.insert(member.name().to_string(), bytes);
+                }
+                fixtures
+            })
+            .get(path)
+            .unwrap_or_else(|| panic!("missing fixture in corpus zip: {path}"))
+            .clone()
+    }
 
     #[test]
     fn matches_frozen_lz4_reference() {
-        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
-        let expected = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.lz4");
+        let raw = fixture("lz4/lz4-no-postfix.raw");
+        let expected = fixture("lz4/lz4-no-postfix.lz4");
 
-        let compressed = compress_dest_size(raw, expected.len(), false).unwrap();
+        let compressed = compress_dest_size(&raw, expected.len(), false).unwrap();
         assert_eq!(compressed, expected);
-        assert_eq!(decompress_safe_partial(expected, raw.len()).unwrap(), raw);
+        assert_eq!(decompress_safe_partial(&expected, raw.len()).unwrap(), raw);
     }
 
     #[test]
     fn matches_frozen_lz4hc9_reference() {
-        let raw = include_bytes!("../tests/fixtures/lz4/lz4hc9-no-postfix.raw");
-        let expected = include_bytes!("../tests/fixtures/lz4/lz4hc9-no-postfix.lz4");
+        let raw = fixture("lz4/lz4hc9-no-postfix.raw");
+        let expected = fixture("lz4/lz4hc9-no-postfix.lz4");
 
-        let compressed = compress_hc_dest_size(raw, expected.len(), 9, false).unwrap();
+        let compressed = compress_hc_dest_size(&raw, expected.len(), 9, false).unwrap();
         assert_eq!(compressed, expected);
-        assert_eq!(decompress_safe_partial(expected, raw.len()).unwrap(), raw);
+        assert_eq!(decompress_safe_partial(&expected, raw.len()).unwrap(), raw);
     }
 
     #[test]
     fn matches_frozen_zero_padding_layout() {
-        let raw = include_bytes!("../tests/fixtures/lz4/zero-padding-layout.raw");
-        let expected = include_bytes!("../tests/fixtures/lz4/zero-padding-layout.lz4");
+        let raw = fixture("lz4/zero-padding-layout.raw");
+        let expected = fixture("lz4/zero-padding-layout.lz4");
         let (raw_block, compressed_raw) = raw.split_at(32);
         let (expected_raw, expected_compressed) = expected.split_at(32);
 
@@ -379,32 +405,32 @@ mod tests {
 
     #[test]
     fn rejects_invalid_compression_levels() {
-        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
+        let raw = fixture("lz4/lz4-no-postfix.raw");
         assert_eq!(
-            compress_hc_dest_size(raw, 512, HC_LEVEL_MIN - 1, false).unwrap_err().status(),
+            compress_hc_dest_size(&raw, 512, HC_LEVEL_MIN - 1, false).unwrap_err().status(),
             Status::InvalidArgument
         );
         assert_eq!(
-            compress_hc_dest_size(raw, 512, HC_LEVEL_MAX + 1, false).unwrap_err().status(),
+            compress_hc_dest_size(&raw, 512, HC_LEVEL_MAX + 1, false).unwrap_err().status(),
             Status::InvalidArgument
         );
     }
 
     #[test]
     fn rejects_zero_or_oversized_inputs() {
-        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
-        let expected = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.lz4");
+        let raw = fixture("lz4/lz4-no-postfix.raw");
+        let expected = fixture("lz4/lz4-no-postfix.lz4");
 
         assert_eq!(
             compress_dest_size(&[], 512, false).unwrap_err().status(),
             Status::InvalidArgument
         );
         assert_eq!(
-            compress_dest_size(raw, 0, false).unwrap_err().status(),
+            compress_dest_size(&raw, 0, false).unwrap_err().status(),
             Status::InvalidArgument
         );
         assert_eq!(
-            compress_dest_size(raw, MAX_INPUT_SIZE + 1, false).unwrap_err().status(),
+            compress_dest_size(&raw, MAX_INPUT_SIZE + 1, false).unwrap_err().status(),
             Status::InvalidArgument
         );
         assert_eq!(
@@ -412,37 +438,37 @@ mod tests {
             Status::InvalidArgument
         );
         assert_eq!(
-            decompress_safe_partial(expected, 0).unwrap_err().status(),
+            decompress_safe_partial(&expected, 0).unwrap_err().status(),
             Status::InvalidArgument
         );
         assert_eq!(
-            decompress_safe_partial(expected, MAX_INPUT_SIZE + 1).unwrap_err().status(),
+            decompress_safe_partial(&expected, MAX_INPUT_SIZE + 1).unwrap_err().status(),
             Status::InvalidArgument
         );
     }
 
     #[test]
     fn rejects_stored_not_smaller_than_raw() {
-        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
+        let raw = fixture("lz4/lz4-no-postfix.raw");
         assert_eq!(
-            compress_dest_size(raw, raw.len(), false).unwrap_err().status(),
+            compress_dest_size(&raw, raw.len(), false).unwrap_err().status(),
             Status::InvalidArgument
         );
         assert_eq!(
-            compress_dest_size(raw, raw.len() + 10, false).unwrap_err().status(),
+            compress_dest_size(&raw, raw.len() + 10, false).unwrap_err().status(),
             Status::InvalidArgument
         );
         assert_eq!(
-            decompress_safe_partial(raw, raw.len() / 2).unwrap_err().status(),
+            decompress_safe_partial(&raw, raw.len() / 2).unwrap_err().status(),
             Status::InvalidArgument
         );
     }
 
     #[test]
     fn fails_on_corrupted_decompression_input() {
-        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
-        let expected = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.lz4");
-        let mut corrupted = expected.to_vec();
+        let raw = fixture("lz4/lz4-no-postfix.raw");
+        let expected = fixture("lz4/lz4-no-postfix.lz4");
+        let mut corrupted = expected.clone();
         corrupted[0] = 0xff;
         corrupted[1] = 0xff;
         assert_eq!(
@@ -453,8 +479,8 @@ mod tests {
 
     #[test]
     fn fails_on_decompression_size_mismatch() {
-        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
-        let expected = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.lz4");
+        let raw = fixture("lz4/lz4-no-postfix.raw");
+        let expected = fixture("lz4/lz4-no-postfix.lz4");
         let compressed_end = expected.iter().rposition(|byte| *byte != 0).map_or(0, |i| i + 1);
         assert_eq!(
             decompress_safe_partial(&expected[..compressed_end], raw.len() + 256)
@@ -466,8 +492,8 @@ mod tests {
 
     #[test]
     fn fails_when_output_budget_too_small() {
-        let raw = include_bytes!("../tests/fixtures/lz4/lz4-no-postfix.raw");
-        let error = compress_dest_size(raw, 16, false).unwrap_err();
+        let raw = fixture("lz4/lz4-no-postfix.raw");
+        let error = compress_dest_size(&raw, 16, false).unwrap_err();
         assert!(
             error.status() == Status::CompressionDivergence
                 || error.status() == Status::CompressionFailed
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index bdcb3f2..8604b61 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -9,6 +9,8 @@ use prost::Message;
 use ring::digest;
 use tempfile::TempDir;
 
+mod fixture_corpus;
+
 #[derive(Clone, PartialEq, Message)]
 struct Extent {
     #[prost(uint64, optional, tag = "1")]
@@ -149,10 +151,6 @@ const BROTLI_INVALID_HEADER_PATCH: &[u8] = &[
     0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
 ];
 
-const PUFFIN_FIXTURES: &str = "tests/fixtures/puffin";
-const LZ4_FIXTURES: &str = "tests/fixtures/lz4";
-const LZ4DIFF_FIXTURES: &str = "tests/fixtures/lz4diff";
-
 #[cfg(otadump_zucchini)]
 fn brotli_compress(bytes: &[u8]) -> Vec<u8> {
     let mut compressed = Vec::new();
@@ -165,7 +163,7 @@ fn brotli_compress(bytes: &[u8]) -> Vec<u8> {
 
 #[cfg(otadump_zucchini)]
 fn zucchini_brotli_patch(name: &str) -> Vec<u8> {
-    let patch = fs::read(Path::new(ZUCCHINI_FIXTURES).join(format!("{name}.zuc"))).unwrap();
+    let patch = fixture_corpus::read(&format!("zucchini/{name}.zuc"));
     brotli_compress(&patch)
 }
 
@@ -187,11 +185,11 @@ fn truncated_zucchini_patch(name: &str) -> Vec<u8> {
 }
 
 fn lz4_reference(name: &str) -> Vec<u8> {
-    fs::read(Path::new(LZ4_FIXTURES).join(name)).unwrap()
+    fixture_corpus::read(&format!("lz4/{name}"))
 }
 
 fn lz4diff_fixture_case(name: &str) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
-    let patch = fs::read(Path::new(LZ4DIFF_FIXTURES).join(name).join("patch.lz4diff")).unwrap();
+    let patch = fixture_corpus::read(&format!("lz4diff/{name}/patch.lz4diff"));
     let (source, target) = match name {
         "lz4-bsdiff" => {
             let block = lz4_reference("lz4-no-postfix.lz4");
@@ -211,13 +209,10 @@ fn lz4diff_fixture_case(name: &str) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
             target[23] ^= 0x5a;
             (source, target)
         }
-        "raw-puffdiff" => {
-            let fixtures = Path::new(LZ4DIFF_FIXTURES).join(name);
-            (
-                fs::read(fixtures.join("source.bin")).unwrap(),
-                fs::read(fixtures.join("target.bin")).unwrap(),
-            )
-        }
+        "raw-puffdiff" => (
+            fixture_corpus::read("lz4diff/raw-puffdiff/source.bin"),
+            fixture_corpus::read("lz4diff/raw-puffdiff/target.bin"),
+        ),
         _ => panic!("unknown LZ4DIFF fixture {name}"),
     };
     (source, target, patch)
@@ -463,7 +458,7 @@ fn run_puffdiff_extraction(source: &[u8], target: &[u8], patch: &[u8]) -> Result
 }
 
 fn puffin_fixture(name: &str) -> Vec<u8> {
-    fs::read(Path::new(PUFFIN_FIXTURES).join(name)).unwrap()
+    fixture_corpus::read(&format!("puffin/{name}"))
 }
 
 fn with_puffin_patch_type(patch: &[u8], patch_type: u8) -> Vec<u8> {
@@ -476,6 +471,14 @@ fn with_puffin_patch_type(patch: &[u8], patch_type: u8) -> Vec<u8> {
     changed
 }
 
+fn with_puffin_inner_patch(patch: &[u8], inner_patch: &[u8]) -> Vec<u8> {
+    let header_len = u32::from_be_bytes(patch[4..8].try_into().unwrap()) as usize;
+    let mut changed = Vec::with_capacity(8 + header_len + inner_patch.len());
+    changed.extend_from_slice(&patch[..8 + header_len]);
+    changed.extend_from_slice(inner_patch);
+    changed
+}
+
 #[test]
 fn puffdiff_bsdiff_reconstructs_pinned_puffin_goldens() {
     let source = puffin_fixture("deflates-sample1.bin");
@@ -573,24 +576,19 @@ fn malformed_puffdiff_zucchini_fails_without_publication_or_process_failure() {
     }
 }
 
-#[cfg(otadump_zucchini)]
-const ZUCCHINI_FIXTURES: &str = "tests/fixtures/zucchini";
-
 #[cfg(otadump_zucchini)]
 fn assert_zucchini_fixture(name: &str, extension: &str) {
-    let fixtures = Path::new(ZUCCHINI_FIXTURES);
-    let old = fs::read(fixtures.join(format!("{name}-old{extension}"))).unwrap();
-    let expected = fs::read(fixtures.join(format!("{name}-new{extension}"))).unwrap();
-    let patch = fs::read(fixtures.join(format!("{name}.zuc"))).unwrap();
+    let old = fixture_corpus::read(&format!("zucchini/{name}-old{extension}"));
+    let expected = fixture_corpus::read(&format!("zucchini/{name}-new{extension}"));
+    let patch = fixture_corpus::read(&format!("zucchini/{name}.zuc"));
     let output = otadump::zucchini::apply(&old, &patch, expected.len()).unwrap();
     assert_eq!(output, expected);
 }
 
 #[cfg(otadump_zucchini)]
 fn assert_zucchini_extraction(name: &str, extension: &str) {
-    let fixtures = Path::new(ZUCCHINI_FIXTURES);
-    let old = fs::read(fixtures.join(format!("{name}-old{extension}"))).unwrap();
-    let target = fs::read(fixtures.join(format!("{name}-new{extension}"))).unwrap();
+    let old = fixture_corpus::read(&format!("zucchini/{name}-old{extension}"));
+    let target = fixture_corpus::read(&format!("zucchini/{name}-new{extension}"));
     let patch = zucchini_brotli_patch(name);
     let temporary = TempDir::new().unwrap();
     let source_dir = temporary.path().join("source");
@@ -742,13 +740,18 @@ fn zucchini_wrapper_applies_large_dex_jumbo_reference() {
     assert_zucchini_fixture("dex-large", ".dex");
 }
 
+#[test]
+#[cfg(otadump_zucchini)]
+fn zucchini_wrapper_matches_annotation_jvm_parity_golden() {
+    assert_zucchini_fixture("annotation-jvm", ".dex");
+}
+
 #[test]
 #[cfg(otadump_zucchini)]
 fn zucchini_wrapper_rejects_unsafe_large_dex_string16_reference() {
-    let fixtures = Path::new(ZUCCHINI_FIXTURES);
-    let old = fs::read(fixtures.join("dex-large-old.dex")).unwrap();
-    let patch = fs::read(fixtures.join("dex-large-unsafe16.zuc")).unwrap();
-    let expected_size = fs::metadata(fixtures.join("dex-large-new.dex")).unwrap().len() as usize;
+    let old = fixture_corpus::read("zucchini/dex-large-old.dex");
+    let patch = fixture_corpus::read("zucchini/dex-large-unsafe16.zuc");
+    let expected_size = fixture_corpus::read("zucchini/dex-large-new.dex").len();
     let error = otadump::zucchini::apply(&old, &patch, expected_size).unwrap_err();
     assert_eq!(error.status(), otadump::zucchini::Status::ApplyError);
     assert_eq!(error.to_string(), "android executable preflight failed");
@@ -1478,7 +1481,7 @@ fn fec_extents_match_android_reference_vectors() {
                 .map(|index| ((index % 4096) * 37 + (index / 4096) * 53 + 13) as u8)
                 .collect()
         };
-        let fec = fs::read(Path::new("tests/fixtures/fec").join(fixture)).unwrap();
+        let fec = fixture_corpus::read(&format!("fec/{fixture}"));
         let mut target = data.clone();
         target.extend_from_slice(&fec);
         let manifest = DeltaArchiveManifest {
diff --git a/tests/fixture_corpus.rs b/tests/fixture_corpus.rs
new file mode 100644
index 0000000..2c51f6f
--- /dev/null
+++ b/tests/fixture_corpus.rs
@@ -0,0 +1,30 @@
+use std::collections::HashMap;
+use std::fs::File;
+use std::sync::OnceLock;
+
+use zip::ZipArchive;
+
+const CORPUS_ZIP: &str = "tests/fixtures/corpus/opaque-fixtures.zip";
+
+static FIXTURES: OnceLock<HashMap<String, Vec<u8>>> = OnceLock::new();
+
+fn load() -> HashMap<String, Vec<u8>> {
+    let file = File::open(CORPUS_ZIP).expect("failed to open fixture corpus zip");
+    let mut archive = ZipArchive::new(file).expect("failed to parse fixture corpus zip");
+    let mut fixtures = HashMap::with_capacity(archive.len());
+    for index in 0..archive.len() {
+        let mut member = archive.by_index(index).expect("failed to read fixture corpus entry");
+        let mut bytes = Vec::new();
+        std::io::copy(&mut member, &mut bytes).expect("failed to decode fixture corpus entry");
+        fixtures.insert(member.name().to_string(), bytes);
+    }
+    fixtures
+}
+
+pub fn read(path: &str) -> Vec<u8> {
+    FIXTURES
+        .get_or_init(load)
+        .get(path)
+        .unwrap_or_else(|| panic!("missing fixture in corpus zip: {path}"))
+        .clone()
+}
diff --git a/tests/fixtures/corpus/MANIFEST.txt b/tests/fixtures/corpus/MANIFEST.txt
new file mode 100644
index 0000000..caca90a
--- /dev/null
+++ b/tests/fixtures/corpus/MANIFEST.txt
@@ -0,0 +1,46 @@
+75ca5f457bae225fcb8191f4ef8746743019c1eb4e330d1321f56b956441009a       16384  fec/fec-300-block.bin
+ee94e02ccf9b3e11fad2939dcf1e38cd1439b86436c457bf3dc42256811f1681        8192  fec/fec-one-block.bin
+6ea395fcef53c8e4de2fc708f4c8e1db7de05b53e48a891c77cbebee4e914e65         768  lz4/lz4-no-postfix.lz4
+d0f1ef7cd255d13146f34b70060f21a545428534feeb90837aace772c80331dc        1024  lz4/lz4-no-postfix.raw
+12a28b1f3d4cc5f8b0bfa534f062abae2b9bdbcd886fa2d657cf81e10b2e273e        1152  lz4/lz4hc9-no-postfix.lz4
+ae91406138d4876551426d6e267b62e15a297e4f4d06a807a1adfce08440af88        1536  lz4/lz4hc9-no-postfix.raw
+1e5b41d7f2e7c5d541a65b683be0c357da12241a036509853962e8888e900c87         608  lz4/zero-padding-layout.lz4
+9ec1afaf310fcf60f084bae0daca993d6ff54966a5bae97f4c0bce71db996920         800  lz4/zero-padding-layout.raw
+4cd1380f674ea78e86276bc9ce39ab88b45bbbccb96c611e18bdd7108c738cfa         181  lz4diff/lz4-bsdiff/patch.lz4diff
+43efe58bdcd3552ffcda9608aa72a9f8189984af9cecd3143d468021e3b54c2d         185  lz4diff/lz4hc9-bsdiff/patch.lz4diff
+08fe5ecea8e3f48ec17665d50807516d63b17dcb729baa540566679a261228d4         366  lz4diff/postfix-bsdiff/patch.lz4diff
+4b9ce7db27ac550c6d7fd1e7f18a535c3a4616c8702fe9655a1d10839c681846         304  lz4diff/raw-puffdiff/patch.lz4diff
+de0527c0d2d27f378cb79aec447172e0efcfff9cc45d0be05c313a87a2069280          17  lz4diff/raw-puffdiff/source.bin
+649b17ae72a6d503a1176604d876923270cd467ae1d458a54e58575eda98766e          22  lz4diff/raw-puffdiff/target.bin
+3c5f3a2fa1bbf4dd938eb05dfb76cf53d4a95b70cb06e35faed6c560a7077260         202  lz4diff/zero-padding-bsdiff/patch.lz4diff
+de0527c0d2d27f378cb79aec447172e0efcfff9cc45d0be05c313a87a2069280          17  puffin/deflates-sample1.bin
+649b17ae72a6d503a1176604d876923270cd467ae1d458a54e58575eda98766e          22  puffin/deflates-sample2.bin
+826cd5b1a815cda2d13c2ca5733a9f9e99e0030d27178f2e9d44e47d73d4a9a8         176  puffin/patch-1-to-2-zucchini.puf
+cb44443bb6312b8faac434d3bd7cf67419c78733b863a8c7ecf4815a071cb9bb         266  puffin/patch-1-to-2.puf
+20eef1e91c331d93f8d42f20b2875836aac05b2b2c96fb7d19e9a3a41043341f         185  puffin/patch-1-to-raw.puf
+bdbdce312f5762571faa17f3f4780235ed2c54f966c0f60dace1cddd2634f4f3           4  puffin/raw-11-22-33-44.bin
+193b1caac682a40ad87657e87e387e1b030013c700e79733bf56a8115324972f       29516  zucchini/annotation-jvm-new.dex
+2e49e0ab01d4a3f253d16bd305848b38aeec102ea7982dc4f641dcfa85bc7c25       28568  zucchini/annotation-jvm-old.dex
+764358162ba84969bd6ba9c6bdd7f67df8b6ee6a555e2529d9084cfe057b79e8        8286  zucchini/annotation-jvm.zuc
+bdf755e070b6cba4f0ea478130c261906c12c0f1fcd0a665effb24dda6db18b5      786788  zucchini/dex-large-new.dex
+c837542fb547d892cbc597a39951bc6b3b0398ec89ff76a472a5c0d720e05ae3      786788  zucchini/dex-large-old.dex
+ebad167e527b375967bef5932e7af4dd7317c4d905b4227f1ab5da6fdb2d4515       65758  zucchini/dex-large-unsafe16.zuc
+fef404d99db5d6e9570f6673a78a5a4d4dcf23616648812debd66d65947b5afc       65758  zucchini/dex-large.zuc
+63e76d95aaaa6bdcedf79b2a8f3b55736fb5e9899e021a6be5190fba2d820080         400  zucchini/dex-new.dex
+3b06060663ae19133d71d72a1f3b40d9bf4716fb4d6fc83d7ae039d01e80e945         400  zucchini/dex-old.dex
+88f7512d4fb07ef897804d370ab1db699104c8b72be3be36e29adb5970fed8d5         223  zucchini/dex.zuc
+2664d1c48bf0a2a2e7b3f8b1a9bd38e08055580adf42f2d53ef6abd7dcc65f30         280  zucchini/elf-arm32-new
+a5a51e66fb5f923113eeb1f5df5c020c715df6a16d691c5a6030e36d920c625c         280  zucchini/elf-arm32-old
+852f01e48651fbcd093f6eb2f075fc59feb470413e79e6f9ddc16b9f2cdcec4c         103  zucchini/elf-arm32.zuc
+5125780242c5b230291ba47102734e422e09255e66e6b711a0657aca8098b8b6         384  zucchini/elf-arm64-new
+d101a04d15a4b975f01d179fbf8b98771acdb31edb71dca4d8de40fa88189ecb         384  zucchini/elf-arm64-old
+0b6c484b0b8cfc2c22ff0257a1e3677e36948bb2f8062a099e88fa4cc4ddf9d7         104  zucchini/elf-arm64.zuc
+1e2080509d361c7e87f3434a3ed2f7a9be1b6972fcfb48fb531f0311e5820d7c        4680  zucchini/elf-new
+32ae88b0151c4afff7b9a88524a554ce517055257ebdd17329fb23fefde75c55        4680  zucchini/elf-old
+9d5187d155ff0acbb22118ade13032b20d6efc1ebfaf95c970e83d8d2f33b9cd         280  zucchini/elf-x86-new
+7eb3c69419c3221a489fa0ba12bfeb94d258f14212a8e108ee130a31c83dda3b         280  zucchini/elf-x86-old
+3bd7d0fc9454f38707d6af56ba9d1382d8a700e7dbda0f4955dcffc748b93915         103  zucchini/elf-x86.zuc
+7015ce4ab2589a48815f734366f01fa9c7553f06480274fd43e9ed85311afeaa         112  zucchini/elf.zuc
+ff55ebfb1b1889f3d0544b00dfabed96de8e4e4234e857043dba47a7a210d019           5  zucchini/noop-new.bin
+88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589           4  zucchini/noop-old.bin
+dec6c4f3e44a1ae18c48efb1c25e59288ecaad04997b8668ce2de0abcf3342d9          88  zucchini/noop.zuc
diff --git a/tests/fixtures/corpus/README.md b/tests/fixtures/corpus/README.md
new file mode 100644
index 0000000..ce6684f
--- /dev/null
+++ b/tests/fixtures/corpus/README.md
@@ -0,0 +1,8 @@
+# Fixture Corpus
+
+Opaque binary fixtures used by integration tests are consolidated into
+`opaque-fixtures.zip` to reduce repository fanout while preserving provenance.
+
+- `MANIFEST.txt` records SHA256, size, and archive path for each packed file.
+- `SHA256SUMS` pins the deterministic ZIP blob itself.
+- Text provenance files under `tests/fixtures/*` are intentionally retained.
diff --git a/tests/fixtures/corpus/SHA256SUMS b/tests/fixtures/corpus/SHA256SUMS
new file mode 100644
index 0000000..f62f861
--- /dev/null
+++ b/tests/fixtures/corpus/SHA256SUMS
@@ -0,0 +1 @@
+6652b1b2d2e1ab4719172a9405f7605f3c08dfec0958215f0f783e05196d4ba3  opaque-fixtures.zip
diff --git a/tests/fixtures/corpus/opaque-fixtures.zip b/tests/fixtures/corpus/opaque-fixtures.zip
new file mode 100644
index 0000000000000000000000000000000000000000..ef1a0bfbf59b6f7d626c860d02057435b8909662
GIT binary patch
literal 1822459
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

literal 0
HcmV?d00001

diff --git a/tests/fixtures/fec/fec-300-block.bin b/tests/fixtures/fec/fec-300-block.bin
deleted file mode 100644
index b7fbe454aea0022a3a893b3b678a976ede71b782..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 16384
zcmeI3jV}~n9LKw{s~tD5hoW@RC3liB&6t&!%4=~)C~v)ZiM+Ih8#`Te$(>|OGiKe`
zWycN2p(ym?CGyf1ZtRqo%4=~)DD-#KzJJ5B=Xrj=@Ava*_6d5$%&TyCyHjz{+$Epl
z=1V(0oY_I*pSd73zsFXx21?p@36JL!*Cfi2KkNO}1(wvPsa;0eGm<9iAbJZ+`Bwgd
zwM4x+Pdhu^X?BxSVsBSfJdNAO8QM6M_du;g=a<^c#z)pNV|U(XLVARFbma%ZZ(Pm{
zt8*~j_xhx#=1nrQJ2Wufx<I8{ZDUGNpGp~H+lm%%o6z&376S$){Q06fPgglBcQE$N
zW<Sr&U6JJKVRdXIt^ShWto{kJ`>nIgUg7u#G1V_-btOIY_l`DgvFfU6ea(CF-so*%
zcfO6NOrs!xU+JR1EHAXBd~B<C?DFocCDVER+Vi{nRhH`I*MikwWX)Pgr{}oeQpTbs
zjIZB`Sw|HtWvsJNkm!_8k3WgEec3OL=dGl)>lo=uo+VEbqJ;}YCr0iX-M^>Ncd4*Y
z=BCgo?MaB#>f_Sl<*DJ%Ee}^ZH(jhepm#h+w{41gPBhU?P6|9PTF>C9HVw;LYHvJQ
zs{SBWMQp9~<=8W2n#C>B3ishmMG?X4Q>(zT(`z+`#PG2-T$<r1tzrhQhs9B|r`V%2
z%ei-xCk=kmzcf6|K4RjcN+4#03y0PR0|F<ut^_x8y|mu77--xQKkW!1MpzUR9Bb@X
z8EUf)9vr(O=^bN(vdD#~ePRJMt{LZ#^T++i{m1){_aFa1{(sDWnEx>UWB$kfhy4%x
zKlXp*KgfTO{~`ZF{)_w<`9Jc1^grl-(Ep+TL;w3<^uK7AK^K5709^vQ1auMTBG6@^
z%Rm=`E(Bc)x)gLV=wi_2pvz$wz%GDY0=oou5$qz^Ww6U&7s4)tT?)Gtb}{VYf8Q?u
E3pP8s(f|Me

diff --git a/tests/fixtures/fec/fec-one-block.bin b/tests/fixtures/fec/fec-one-block.bin
deleted file mode 100644
index 59b361a..0000000
--- a/tests/fixtures/fec/fec-one-block.bin
+++ /dev/null
@@ -1 +0,0 @@
-Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�Ž�
\ No newline at end of file
diff --git a/tests/fixtures/lz4/lz4-no-postfix.lz4 b/tests/fixtures/lz4/lz4-no-postfix.lz4
deleted file mode 100644
index c635da170bdc86177413483ad902b18646ae61cf..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 768
zcmew_k(a7#mZ<9!WulvsT9R6no0*qcT#}iro0eHoQd*R%@0*#ET3nK^&LHuA;=0o>
zSe5K!DyMC}@RrMuL6?6H1H=2i)hC`Z$=gJhP2O<!75f|pDSkf&2L4w-neG)wAN`lH
z3@e_n_SAD0K}J2kQik^(OAp=uBWV^~(7WpR6UKN(X+A#&{<Vw@?^_q`zw=YfI3Txc
z`H_eJt}yEJ0#!H7-*fYuuz_z@`;vqAek(D_@B&r00ae$}*?H}=fUZ}1%ffxPe@tgG
z-~p<xnYr!q2VO1rl*W0xZ+v~qB+CO)&BVamukMmqH+#p`Pf^T<+@%a45f#U{>KR)v
Sy<fpBmjDR?hEXuWLI3~)c5lD{

diff --git a/tests/fixtures/lz4/lz4-no-postfix.raw b/tests/fixtures/lz4/lz4-no-postfix.raw
deleted file mode 100644
index fabd401..0000000
--- a/tests/fixtures/lz4/lz4-no-postfix.raw
+++ /dev/null
@@ -1,3 +0,0 @@
-ne-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6‘®Ëè"?\y–³Ðí
-istic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministicŽ«Èå<Yv“°Íêtone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-‹¨Åâÿ9Vs�­Êçnistic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministiˆ¥Âßü6Sp�ªÇä
stone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone…¢¿Üù3PmŠ§Äáþinistic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-determinist‚Ÿ¼Ùö0Mj‡¤ÁÞûestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestonœ¹Öó-Jg„¡¾Ûøministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-determinis|™¶Óð
*Gd�ž»Øõlestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestoy–³Ðí
-'Da~›¸Õòrministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-determiniv“°Íê$A^{˜µÒïilestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-
\ No newline at end of file
diff --git a/tests/fixtures/lz4/lz4hc9-no-postfix.lz4 b/tests/fixtures/lz4/lz4hc9-no-postfix.lz4
deleted file mode 100644
index 6c24b45279e4b9fbe194b34726148821e3c52d04..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1152
zcmew_5oMyAl3J2ll$)8CSzMBtteciuQBqozs_&bblUiJopO>m@mZ<Ba&LIAN_l>VY
z`aYR$ix1rWC2r!!pv$k$!0>Lz)ld97o@vbs_TKs~V(7=ff0#k<Kf~5b?|C%ck{jmk
zy8cB_Pxml`{eOl{=ihLuIVaT4+J5CDpSBrTZ2g&+Y|0L?Rnxaze8;Vk3>I5+@)@&&
zZB+S`jptr-s6zCvJocDD)+)SY;=0o>Sd}ut>XsdT@K?$_q_A)GiKk5RsX#F%2Il#J
zdEG0HKKd_H0_FQ<cPu@0|BqxIl<%F<x@iBMpJK&OzDH`){5?0n3Fkxku1WQCc3%4|
t0I~yQo>P3y%x#xH@WRZqkExut`NCT+pm|mS;4ott1*0J_8Uo~m005r}iYEX7

diff --git a/tests/fixtures/lz4/lz4hc9-no-postfix.raw b/tests/fixtures/lz4/lz4hc9-no-postfix.raw
deleted file mode 100644
index a6d68dfb8c6a7aff4c4fc42fa3944905fc3806f8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1536
zcmazt(M?G$NiE9F%*!k;$xPNw%d99VElSn*&CE$HF3HbJ)iq1h^@$={+3p)(h4g(g
z+ZG?V`%Bz}Qq!=wZO7G5{5qa#%?tM4`YvKflH0JDhQ+5_FTLl{bW3iSyX*QFK|P8C
z1k=(@=ihLuIVaT4+J5CDpEha1i)k8`$Xb8qC7ZHCY}NEF7vFJfP#&ikmaaMZj9I}p
zs(i}EbFVp6NlYOareR5MD~~;9khKagnYixs3sxm6BujKlmmPlaSIRu3uy6H=r%dvs
zCUSJsuw)rX`VY+OUUBr%e;I1zEHq0Y>EAEAW9gy$e<VrHr)Z{O$@P%*@14=QX#bs`
zVpJ&{P%VX|e~;9r`Fn1D6DGZ=K{X9aQ3FZ;u1WQCc3%4|K%Mdp#ZpN6cZ#o>x$W`?
eUNTBc6w|O2HIVdgA5%GP^M$uuR4Ss8Ed>C|fLXWz

diff --git a/tests/fixtures/lz4/zero-padding-layout.lz4 b/tests/fixtures/lz4/zero-padding-layout.lz4
deleted file mode 100644
index 8185bd833dcc04217a9fbcaba60b9fb963e79db8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 608
zcmXTQ&CJUzF3C*RP0Oq(DJ@FX_sz^nEiTE=OVu??)b(K)1=I_HuM$xvx+$q8sYL`r
zU7g|mQzm(v$g;^B&c0$-ag0-EVB_~=5aCy6V0i!Nzl>#A@r1Rfp0g<0MbBZ70?IJ(
z9|p?Y|08J@T+qAf_!CAs>xfqj>_8b|ehWs1_ji7Z83*KcEkE+`pR`42Jfk#!DTC1a
zo8N>De6!k@9K82i!Zc_tBL`5u5ZI1up9OTi(pwhpyZuAd$X|&`2B==}{pAn5TJ9;0
u^LF3(Dx~jIz{CkuFUa4<$nf;STP}5%#Jbr#u72Xz@!ZG6>BkTNPD=pD31yi8

diff --git a/tests/fixtures/lz4/zero-padding-layout.raw b/tests/fixtures/lz4/zero-padding-layout.raw
deleted file mode 100644
index 90c2247..0000000
--- a/tests/fixtures/lz4/zero-padding-layout.raw
+++ /dev/null
@@ -1,2 +0,0 @@
-rministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-determå<Yv“°Íê$A^e/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milâÿ9Vs�­Êç!>[deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterßü6Sp�ªÇä
;Xre/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/MiÜù3PmŠ§Äáþ8U-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deteÙö0Mj‡¤ÁÞû5Rure/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/MÖó-Jg„¡¾Ûø2O4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-detÓð
*Gd�ž»Øõ/Lture/Milestone-6a-LZ4-deterministic-fixture/Milestone-6a-LZ4-deterministic-fixture/Ðí
-'Da~›¸Õò,IZ4-deterministic-fixture/Mi
\ No newline at end of file
diff --git a/tests/fixtures/lz4diff/lz4-bsdiff/patch.lz4diff b/tests/fixtures/lz4diff/lz4-bsdiff/patch.lz4diff
deleted file mode 100644
index d4cbd11d27fd6eaaf7843a68425b247200022573..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 181
zcmeZ?GI8;Ab7Np&U<6_r1}+{hCJsg+Hh~5Xi3T<y6rNKsNU4c|Ay6d<XhA3j1{Mgz
zDJsL#&@oaiIMN_4`WgcR^8uF}0SBPm0tQ1KhAAgbe0?YwsNcO)X^w`6gud=;284!^
uuWP>p&2eBjz`($vz+ljzmFc?1V)rD?LoLnA*XHj4sT41AwFsC1vI+oLMJa6n

diff --git a/tests/fixtures/lz4diff/lz4hc9-bsdiff/patch.lz4diff b/tests/fixtures/lz4diff/lz4hc9-bsdiff/patch.lz4diff
deleted file mode 100644
index 71097745271a53ec43765312fd3cb39aaea4f3ca..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 185
zcmeZ?GI8;Ab7Np&U<6_X1};7>77iu>P9Zjd1|Eq9P9ZeDQ!q%miGd+dH3(=yC<X>L
z2*W8V!_v?(QY|<#;p(gk1_tH>4vz&KfCeit81gVoIdS6aL%~4(?wv|=G&~Hl&e|{_
wG}N_Qm;p67FkE0@;80*NIKwf^*<nxYNs)(6j=y9c+yJQ*FLJdAm;ka00HCNTGynhq

diff --git a/tests/fixtures/lz4diff/postfix-bsdiff/patch.lz4diff b/tests/fixtures/lz4diff/postfix-bsdiff/patch.lz4diff
deleted file mode 100644
index 065599364df4eb4a3c23548739bfe8e584dca612..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 366
zcmeZ?GI8;Ab7Np&U<Bf;3|u^1OdO0tYyu4&5)EuZM;O7}y^IjPl0x3%sej%FpLlXl
z|2W5&6Ay3KK8Ox}($y(be){!0zlnaST9X)^f<Y#l7#IQ#1Oa0R#lXM}VK_x)SQ<J;
zss%@GwcIWa6h7csA>hEk;Gn=@$ipz@#EGvD1q1cFcPh=%@Q9joySo9QVa4KSu0TT)
zSPw98Ffa%Joy?)Yptx1qaTeFH2^ELlc`WA=5*4XAu>hn+yvWreU;@ZabQfuX1VMlW
zLLn?Lh>N}ka*<08$VChbFkK{}ult$-p`qmK+V4Pf92gFO-D1$7mFc?1V)rD?LoLnA
K*XHj)bqE03vSr%<

diff --git a/tests/fixtures/lz4diff/raw-puffdiff/patch.lz4diff b/tests/fixtures/lz4diff/raw-puffdiff/patch.lz4diff
deleted file mode 100644
index 623ee4aa0f6834ffd36fff1c6c08b66a5c45d286..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 304
zcmeZ?GI8;Ab7Np&U<6_@1}+XR1|b#!K?y-22un;tOoA~W)Xfkm9mv5bq|U{{As}D`
zBm)GvfMkMzkPt{D0!UT}Xb7=#tY8$dkdT*B;bH<S^AHH&V&#~@2vo-eR#gBbSvgLC
zR4F<IySN!KGBR2KO$PxJ2*scXrJbTOEDaqa)q*20D(tRfU|>#gsNmyZa9~hiFl6&_
znAGpKe8q#$*A#`m>~S`d7cX+P2$%p;iO}~^A)c3kfyq(Si9-RXkAVrKSIJgcppAK2
nh@e<JL=Q+6LJ#|u(|HV_5MczWRg`dRdgrm6ONimu%-jP2Pq#Ud

diff --git a/tests/fixtures/lz4diff/raw-puffdiff/source.bin b/tests/fixtures/lz4diff/raw-puffdiff/source.bin
deleted file mode 100644
index 3bfad73a72fd1e3307444a8d7a66d2a7c0222dc9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 17
YcmWesN=`{iOJrp*W@bocVQ>ir03kmEUjP6A

diff --git a/tests/fixtures/lz4diff/raw-puffdiff/target.bin b/tests/fixtures/lz4diff/raw-puffdiff/target.bin
deleted file mode 100644
index a5ae9f565d494da1912b5ed3119fc6b8690e6083..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 22
dcmYdJNlHs(WiU=-WM%mEpOJ}~g*BOl0RTip1q1*9

diff --git a/tests/fixtures/lz4diff/zero-padding-bsdiff/patch.lz4diff b/tests/fixtures/lz4diff/zero-padding-bsdiff/patch.lz4diff
deleted file mode 100644
index 07a7a0e50a8e0a44407ef1b4296c30c8f11db778..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 202
zcmeZ?GI8;Ab7Np&U<6_V1}-r!CJsg+76Anb1tAU&1%U=Oi32PWj6yiXoq|EyO$_vb
zx<Nn}LNO>XLl{m`8J32Qk!rz_pAHtqGcd4SaL5pGU~phiU{IXQqS)ZvIW=}q>`9S_
zPR^%UPu3umA9wvI26WT|h66x@8aNaf6jtRr&e+v_^v*;-5f#IWHLeXH#o|S-76B7L
Gb^!oyFf4Zf

diff --git a/tests/fixtures/puffin/deflates-sample1.bin b/tests/fixtures/puffin/deflates-sample1.bin
deleted file mode 100644
index 3bfad73a72fd1e3307444a8d7a66d2a7c0222dc9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 17
YcmWesN=`{iOJrp*W@bocVQ>ir03kmEUjP6A

diff --git a/tests/fixtures/puffin/deflates-sample2.bin b/tests/fixtures/puffin/deflates-sample2.bin
deleted file mode 100644
index a5ae9f565d494da1912b5ed3119fc6b8690e6083..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 22
dcmYdJNlHs(WiU=-WM%mEpOJ}~g*BOl0RTip1q1*9

diff --git a/tests/fixtures/puffin/patch-1-to-2-zucchini.puf b/tests/fixtures/puffin/patch-1-to-2-zucchini.puf
deleted file mode 100644
index 948ff9dfb6b44e0cb7ef03408962e128d6c2a860..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 176
zcmWFtbu(mOU<l@56jJA6;Sdlo0+Im&TtG5GKu8EA5&<MD1T=(LIaV+VSV+iAsc<oY
zm3asRaItdCU<9gT0;?(jlB^sjK&liK7{xOf7>=CUyw^seJKag(g2;XU-__n>lZ#qk
ze|6I1t4I)@`#O8N$Fz*T%AQooz80Tv+f*6S=AXJ7_POomb#pVG8~q1aykj_me#tjD
O3p{rEr(V!lAqfEaA2FW*

diff --git a/tests/fixtures/puffin/patch-1-to-2.puf b/tests/fixtures/puffin/patch-1-to-2.puf
deleted file mode 100644
index 26659edfa475d86e35a8687c79394b7e4adfadeb..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 266
zcmWFtbu(mOU<l-36jJA6;Sdlo0+Im&TtG5GKu8EA5&<MD1T=(LIaV+VSV+iAsc<oY
zm3asRaItdCU<9gT0;?(jlB^sjK&lj-f?eE<7#SHYfTn|h34~%$gwjq?8J32Qk!rz_
z7ZrBbF)%PEI8^X)FgP$MFc`A=I85qyTfXAK=WB{WU-mc~$%_}cS_Di0sYK}es1VP~
zz`*1v>cpV{)W^UC(yL^vEYQY0EksZ(9-;@N3ZaMn%IQ1?1_nkTRA5k)aBF(!v7AeY
J;n&RE0|2lnHe>(*

diff --git a/tests/fixtures/puffin/patch-1-to-raw.puf b/tests/fixtures/puffin/patch-1-to-raw.puf
deleted file mode 100644
index fc95db46a4d76d9a23d8090f1122ca30e62496fc..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 185
zcmWFtbu(mOV9@7a6jJA6;Sdlo0+Im&TtG5GKu8EA5&<MD1T=(LIaV+VSV+iAF-fpE
z1-rNzF)}i00QG_ZAB19HfznP<8J32Qk!rz_yL#(&fr1VUE*uIB24^^pLQ*YuPtrWp
z(t0KPX9h@}c#*3`zyy#+gs$hSKK=m;6fiJwFfu5xC@?6_$}sj7wuwC{^3ch7-s<BY
E06fVi%K!iX

diff --git a/tests/fixtures/puffin/raw-11-22-33-44.bin b/tests/fixtures/puffin/raw-11-22-33-44.bin
deleted file mode 100644
index d215705..0000000
--- a/tests/fixtures/puffin/raw-11-22-33-44.bin
+++ /dev/null
@@ -1 +0,0 @@
-!,
\ No newline at end of file
diff --git a/tests/fixtures/zucchini/README.md b/tests/fixtures/zucchini/README.md
index 439b58b..642976c 100644
--- a/tests/fixtures/zucchini/README.md
+++ b/tests/fixtures/zucchini/README.md
@@ -3,6 +3,9 @@
 These fixtures use the BSD-3-Clause terms in `LICENSE`.
 `SHA256SUMS` records every binary fixture digest.
 
+The compact `annotation-jvm` DEX pair is retained as a native parity
+regression for annotation-heavy JVM metadata.
+
 The NoOp patch is the complete serialized fixture from the pinned upstream `patch_read_write_unittest.cc` field layout used by the Milestone 5a proof.
 
 The DEX and ELF fixtures were generated by the audited proof tooling from:
@@ -32,24 +35,3 @@ Malformed wrapper cases are synthesized in test code from two deterministic inpu
 
 - raw bytes `not a Brotli stream\n` (intentionally not Brotli), and
 - Brotli-compressed bytes of `not a zucchini patch` (valid Brotli, invalid inner patch).
-
-## Realistic DEX differential fixture
-
-`annotation-jvm-{old,new}.dex` + `annotation-jvm.zuc` are a small but complete
-real-world differential case: AndroidX `annotation-jvm` 1.8.1 -> 1.10.0
-`classes.dex` (28,568 -> 29,516 bytes), patched with the AOSP
-`external/zucchini` generator from the same pinned commits listed above.
-
-It is deliberately kept because it exercises two apply-path behaviours that the
-hand-built fixtures do not:
-
-- ranged Dalvik opcode families (`iget`/`iput`, `invoke-kind`, `cmp`/`if`),
-  whose native filters match the canonical range-start opcode rather than the
-  raw byte; and
-- the libstdc++ `std::sort` tie order inside
-  `PruneEquivalencesAndSortBySource`, on which the reference-delta stream
-  depends for equivalences that share a `src_offset`.
-
-The pure-Rust engine failed to apply this patch until both behaviours were
-ported, so it is a compact regression guard (161 equivalences, 2,044 reference
-deltas) that runs in milliseconds.
diff --git a/tests/fixtures/zucchini/SHA256SUMS b/tests/fixtures/zucchini/SHA256SUMS
index 5dfdc11..451cc98 100644
--- a/tests/fixtures/zucchini/SHA256SUMS
+++ b/tests/fixtures/zucchini/SHA256SUMS
@@ -1,7 +1,7 @@
+bdf755e070b6cba4f0ea478130c261906c12c0f1fcd0a665effb24dda6db18b5  dex-large-new.dex
 193b1caac682a40ad87657e87e387e1b030013c700e79733bf56a8115324972f  annotation-jvm-new.dex
 2e49e0ab01d4a3f253d16bd305848b38aeec102ea7982dc4f641dcfa85bc7c25  annotation-jvm-old.dex
 764358162ba84969bd6ba9c6bdd7f67df8b6ee6a555e2529d9084cfe057b79e8  annotation-jvm.zuc
-bdf755e070b6cba4f0ea478130c261906c12c0f1fcd0a665effb24dda6db18b5  dex-large-new.dex
 c837542fb547d892cbc597a39951bc6b3b0398ec89ff76a472a5c0d720e05ae3  dex-large-old.dex
 ebad167e527b375967bef5932e7af4dd7317c4d905b4227f1ab5da6fdb2d4515  dex-large-unsafe16.zuc
 fef404d99db5d6e9570f6673a78a5a4d4dcf23616648812debd66d65947b5afc  dex-large.zuc
diff --git a/tests/fixtures/zucchini/annotation-jvm-new.dex b/tests/fixtures/zucchini/annotation-jvm-new.dex
deleted file mode 100644
index 41134fb95ab6354da994b6bde001468c3b41177c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 29516
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
MAC!~b^fxj8FK>M8sQ>@~

diff --git a/tests/fixtures/zucchini/annotation-jvm-old.dex b/tests/fixtures/zucchini/annotation-jvm-old.dex
deleted file mode 100644
index 34834755d296dc94cee6fb6f0f3623344a83efaa..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 28568
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
Wn>-f#P)=>VNc}-M*-d|6?|%U=5t#D;

diff --git a/tests/fixtures/zucchini/annotation-jvm.zuc b/tests/fixtures/zucchini/annotation-jvm.zuc
deleted file mode 100644
index 6b2f47f100dde8ef902ef61b404d46e88d7c05c8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8286
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
J-c<P6{oi6Fg7p9Z

diff --git a/tests/fixtures/zucchini/dex-large-new.dex b/tests/fixtures/zucchini/dex-large-new.dex
deleted file mode 100644
index b7cc69be02b020c15ab4f3914718e04708a28b37..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 786788
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

diff --git a/tests/fixtures/zucchini/dex-large-old.dex b/tests/fixtures/zucchini/dex-large-old.dex
deleted file mode 100644
index e7e1b4b4692a70d36e9bbf0c35cfbe5c9334d46d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 786788
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

diff --git a/tests/fixtures/zucchini/dex-large-unsafe16.zuc b/tests/fixtures/zucchini/dex-large-unsafe16.zuc
deleted file mode 100644
index a451b84982b173d8b211a6a338ffd4a8feb29522..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 65758
zcmeIuze>YU7>D7ct^aCU+rdF`2ySi#5gZ-tC|$+1b#M>_5u8Qw798xYSOh0GM;F1t
z`!GMDUd3}D@A;CGWO&YQCX=!#ifP#?o_1#A><{D3tvt)h{bD~JomOR$lcS_+)_J=d
zR`oVLzikiq4~qNm_s^eEWAOEI^}Kg+a`^gjdEMQf&GYK~v7gU&dw;*Er&fJg1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oNAZ;9p>{n92-|q?xpmrDQo-Nmi4!q@AoMour%el8vOF
F`~pX}82<nO

diff --git a/tests/fixtures/zucchini/dex-large.zuc b/tests/fixtures/zucchini/dex-large.zuc
deleted file mode 100644
index bd78635bd6d287da2ee379b639ef21cb406f6b87..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 65758
zcmeIuJxT*n7>3cA#NU|2q_9vd20Oce2$mM63~9wSv9J&X5v)aV3l?T82EoeC(nhdw
zAI>YJa1ZAe&v)<4ohi=Q&16y*MKLYg#nbL=ocS=`+Rn4AoEP(Ccv_W3-W(@Yv(DSy
zpsL68{I)eXI4thJ-#>qbjsDlm)${(v=;-z1^18D#o9F8Mv6s*Gx_`f@cNPHx1PBly
zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF
z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk
z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs
z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ
zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U
zAV7cs0RjXF5FkK+009C72oU%u&|jR&Y#K>3SxT0Zm1H$pOV*QCvXQitPSQ;_lV0)*
DMe`W@

diff --git a/tests/fixtures/zucchini/dex-new.dex b/tests/fixtures/zucchini/dex-new.dex
deleted file mode 100644
index fdcb0a1ad48edf59837c23eae94e5e258ce4e1b9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 400
zcmYdEt>7{+Hf0FYd62b!-D^Ix3xeOCaj%#^Yf;+KmpAKHPGDqUC}3b<s0cF=0#aZg
z0u*BfvOwa@K->bvKp}<+Knw#Q{v03%(My2%3=kiI;<G^dArQX>;txO!0w8rDvp|>$
zh+%*Q$^glOFbKfpe?Yhl>^=cS`T1$q3_?CxiDilUIf;4c`u<5-smUeQ3|wG2J)lGq
z17jEib5Us?L>tgF&IXuKU?GtCd_c?vQ2@6OBo6a0NCV8zAQ~hG@;68x#0L494ax@j
dn@Is82l6`ukPT7;ayO#_gbfxDfUrT~3IG<oFa-br

diff --git a/tests/fixtures/zucchini/dex-old.dex b/tests/fixtures/zucchini/dex-old.dex
deleted file mode 100644
index dd86313be17af9f8f9190b20e8d41a5fc93b112e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 400
zcmYdEt>7{+Hf4CP8TzKL`eTCY^dC7Dnyqd-cb0lP`)N&@z{tQ*z`(#z5oRI;q`*J~
zD8>q8fy9}CxCMxTLJSjt7zRN6IY11emjLk@AU*=cXMyxXAbtzPAAlGHK<YqdfiM#g
z!vG7E0g?w{5P-@5fN&YueFBQ|^V6&ugnY6R%M$f-67$ma{gbj%lS`}_xWICHAPEM>
zFb3wL(maSZplO^9Fr&aiAoKZvm<yr+ZXZY-=3kHon4dv3NDkz0kUWSD@-rKh4e~dW
b0z?kvcLpFEqz2?}Mg<5PEFb`3gTfU6Z@Vrl

diff --git a/tests/fixtures/zucchini/dex.zuc b/tests/fixtures/zucchini/dex.zuc
deleted file mode 100644
index 0eda0acc86d71aaee248cd231a215b0320fb6091..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 223
zcmazlO-^QHU|^U4B(xcvFM(*Oi5GQ1VjuwG!)O=R2n9w4kbnb-P+$TQAD9$?WJ+oU
zmw~Y<LzvEkto7?&^O;=`{Pv7{#r#=|(vH5oS+^3T@-!nz6QdxIzyNSTux%jK49p;c
m1w^od2sRMG4k9=}1Sg2#0ukIGf(JzKf(Skk!4Dz?Km-8D-5O8;

diff --git a/tests/fixtures/zucchini/elf-arm32-new b/tests/fixtures/zucchini/elf-arm32-new
deleted file mode 100644
index 2d847c950ecf6a33ce31853bedd50b0e45600dab..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 280
zcmb<-^>JflWMqH=CI$@#Fi(Ji!2~F{04ia^pa2xtU|?oo0?Q|W#DQu+SOG|ZFe?zV
z05LKEn)MoJ%0s#T`d|!VqhP&~)QS=Yz2c1GlA@BtBxJp$uz~h~-Ngpd1awmZkWv6*
Y7=XEp9VoyI69m!?KrD#F2blu`09U>jL;wH)

diff --git a/tests/fixtures/zucchini/elf-arm32-old b/tests/fixtures/zucchini/elf-arm32-old
deleted file mode 100644
index ffadf72210379a5047a9bdc80114be0d621026dd..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 280
zcmb<-^>JflWMqH=CI$@#Fi(Ji!2~F{04ia^pa2xtU|?oo0?Q|W#DQu+SOG|ZFe?zV
z05KYP4K(GU+<$#A2C-4FUP)?234>m7MsZ0|Nn#S3UZS~-K$RfO2GRj^Qv#4u0Ad(`
Wxr-erzzh=v(hWc?h{Ok(0RjM51{XsB

diff --git a/tests/fixtures/zucchini/elf-arm32.zuc b/tests/fixtures/zucchini/elf-arm32.zuc
deleted file mode 100644
index ef284fc95d7fcf2f39f1d71f13a9eee9214cbfe2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 103
zcmazlO-^QHU|^5{5{ss<Tm+)krG3LeVjuwG!)RAWV<SceumG4~0!qvP5pVz!W@3hM
JA&Nj`4gfgp2W9{O

diff --git a/tests/fixtures/zucchini/elf-arm64-new b/tests/fixtures/zucchini/elf-arm64-new
deleted file mode 100644
index 67131d58780d6e8343f4d36d463b5885529e876f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 384
zcmb<-^>JfjWMqH=CWh?{V4eU(!~rUC07`=>2L=nE8V3eu1}3mtRwOxeW&_k{7|j4R
z7p9Jxfnkcg0`t`a%<<Pi7$y#<^-5AJN*MHtGm1-!N)nUc;#6XQoCm^eF!P}9Yk=|<
jVB%1k1&z-R<OBTx3<)SufY1w|TtO%eqoBb7<1zpMFclHM

diff --git a/tests/fixtures/zucchini/elf-arm64-old b/tests/fixtures/zucchini/elf-arm64-old
deleted file mode 100644
index 8ebf0873599d47124f3b1d9f0de4ebd8047bdc46..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 384
zcmb<-^>JfjWMqH=CWh?{V4eU(!~rUC07`=>2L=nE8V3eu1}3mtRwOxeW&_k{7|j4R
z7p9Jhfnkcg0`t`a%<<Pi7$y#<^-5AJN*MHtGm1-!N)nUc;#6XQoCm^eF!P}9Yk=|<
kVB%1k1&z-R<TC>?&>s+>0HGE@C<Z|&4WppJ0pl_N05260z5oCK

diff --git a/tests/fixtures/zucchini/elf-arm64.zuc b/tests/fixtures/zucchini/elf-arm64.zuc
deleted file mode 100644
index a9d24a6ab29b360930a7b543648cd771ad604e76..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 104
zcmazlO-^QHU|?tf5;{V&=7Q+w$t#0FVjuwG!)RAWGZRJzumG4~0?9K&<RK(Tm<cWd
KQ3O)e!w3M;`Uz(M

diff --git a/tests/fixtures/zucchini/elf-new b/tests/fixtures/zucchini/elf-new
deleted file mode 100755
index 06a022ad4a49730f8134d117dbb08aaa276bd894..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4680
zcmeHLu}T9$5Pf%ELc}7cje;Or*a!yfEJUu+%6~X6WYt0=<QCM*Z}2ZHE%QBAwthjJ
zxt%$aB>_o23%76P&Ah$4*X_Jr-CU<h0$nLC(PVkiP+<pp+u8vXI7do*2U*jb{go(E
zMZiy~DIyO9zoWyU<dF9%_Cp&K+dkn9%mH)2954sW0dv3{FbB*5bHE%h2h0I;;QtPM
z^F{o9dO`cytl!+omx{S9!_O=(ZZ$-LuHN6JVV5xH=|IHqD1TT;XMlqh{P7AN?&0=y
z?4Act@YUqbd6ea_uFIM-iruL46~TA}4C>cMUkwTUB;dV9-o5yR&saOzCnbB-)f4o;
zWxmnQF{HjYGYQ&MwR4z@{zJG8LVkLZ?+I=SFKG)?(Vw(T2>4s)7ms)N+<1M7{wONM
F`d_MhD;NL(

diff --git a/tests/fixtures/zucchini/elf-old b/tests/fixtures/zucchini/elf-old
deleted file mode 100755
index e6affdc917bf1ee5032186e14e1e08a38aaa924c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4680
zcmeHLF;2rk5F8sP3ZjUi0SO5~L4!mjItql`K*b*{M>bFdBE?rg#TR%6C1u`2Mav7q
z?%l3QPDDb~dy;Q<XLru_bhj^8H`i&BKv#-O_$)6x6?R~-tsOvtbELHQkon&1r$mt|
z0=`R45qTi^9X$>uhrCa57}}uN^$Bla4wwVxfH`0em;>g3IbaT$1LlA^U=ElAe|O-M
zFXFHB3);^XLw_UxRm^P}z7}zD%M%IudViOOUBaBF0};QY{9z%T0S?yi$7^^rliSnj
zq#jM-s@YxRP?qDiEnCVcZtBWa1dlZ^YM&omH70bkfcF}?=E<#m#=nz&QnE*VJwg9l
z<{RA{L+YzDlb}siyM(#u--O#B<YyrHp5UhNl6Ei`{Yl4!fWLKl@py;Njn{|hkD@}X
F{|1*{D+~Yt

diff --git a/tests/fixtures/zucchini/elf-x86-new b/tests/fixtures/zucchini/elf-x86-new
deleted file mode 100644
index 37eacaf23803d65f2d8a94c4493163726d97cb6a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 280
zcmb<-^>JflWMqH=CI)5(Fi(Ji!2~F{04ia^pa2xt0Ln6f<r6^SKs6w&0Hi>e6^L1Y
z7#X}^2l6K11`K*7sTCy*dc_&VB}FBPNyvIhVT0TZ!fYT-KsO}-DFq;g0hqf$&S8cL
P0_g@I7DVEM%m4uZSqB<(

diff --git a/tests/fixtures/zucchini/elf-x86-old b/tests/fixtures/zucchini/elf-x86-old
deleted file mode 100644
index af782f7d20676cbc1aee60230e6a57436c2b29b7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 280
zcmb<-^>JflWMqH=CI)5(Fi(Ji!2~F{04ia^pa2xt0Ln6f<r6^SKs6w&0Hi>e6^L1Y
z7#X}^2J$B01`K*7sTCy*dc_&VB}FBPNyvIhVT0TZ!fYT-KsO}-DFq;g0hqhkfdU{W
R!9W9$Aqe9DX^<Hp0034i8gBpq

diff --git a/tests/fixtures/zucchini/elf-x86.zuc b/tests/fixtures/zucchini/elf-x86.zuc
deleted file mode 100644
index cb6636799c9625c7ba47124500f32bca18d2e40a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 103
zcmazlO-^QHU|^5{5)(c}=YVLx?X${3VjuwG!)VtE3o}LrumG4~0!qvP5pVz!W@3hM
JA&Nj`4gi!x2%7)^

diff --git a/tests/fixtures/zucchini/elf.zuc b/tests/fixtures/zucchini/elf.zuc
deleted file mode 100644
index e50ae63228e013cfa6688c9c0077823273f635d7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 112
zcmazlO-^QHU|{eNVqnP0RJ;qK?Xr1)fW$xm#D~$Y6=o)k3}6{B!32~zp#qX+1L9VN
Y?Lbi$AdB(;PhqeEW{?~Rz?Cxq09r*16951J

diff --git a/tests/fixtures/zucchini/noop-new.bin b/tests/fixtures/zucchini/noop-new.bin
deleted file mode 100644
index dbfa1e1..0000000
--- a/tests/fixtures/zucchini/noop-new.bin
+++ /dev/null
@@ -1 +0,0 @@
-aXcde
\ No newline at end of file
diff --git a/tests/fixtures/zucchini/noop-old.bin b/tests/fixtures/zucchini/noop-old.bin
deleted file mode 100644
index 85df507..0000000
--- a/tests/fixtures/zucchini/noop-old.bin
+++ /dev/null
@@ -1 +0,0 @@
-abcd
\ No newline at end of file
diff --git a/tests/fixtures/zucchini/noop.zuc b/tests/fixtures/zucchini/noop.zuc
deleted file mode 100644
index e96505cd17b3f63c9f1268f150e2a76539c2d96e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 88
zcmazlO-^QHU|?VYV!^XbZ&`u#f&+q5ATbaCiGu)0+%Mn1fRO<#11DHOtW*%e2qL}#
HF&F><@Qw&&


From 830b30a09d0a9e3935cf87c4a87c162a9a4138d7 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sat, 12 Sep 2026 23:25:13 +0530
Subject: [PATCH 40/42] harden native artifact fetch and wheel pipeline

Signed-off-by: Akhil Narang <me@akhilnarang.dev>
---
 .github/workflows/release.yaml       |  76 +++++++++
 README.md                            |  27 ++-
 docs/zucchini-rust-port.md           | 209 +++++++----------------
 native/zucchini/ARTIFACT_LOCK.sha256 |   1 +
 scripts/fetch-native-artifact.py     | 171 +++++++++++++++++--
 tests/native_artifact_fetch_test.py  | 240 +++++++++++++++++++++++++++
 6 files changed, 560 insertions(+), 164 deletions(-)
 create mode 100644 tests/native_artifact_fetch_test.py

diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 4a9de04..b328b81 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -141,3 +141,79 @@ jobs:
             *.zip
           name: ${{ steps.get_version.outputs.value }}
           tag_name: ""
+
+  wheel-linux-abi3:
+    name: wheel manylinux2014 x86_64
+    runs-on: ubuntu-latest
+    container:
+      image: quay.io/pypa/manylinux2014_x86_64@sha256:493d2032114d757aaa761a9385ad8497f391503bf71acef9abeeb66682ca5d90
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install Python build tools
+        run: |
+          /opt/python/cp39-cp39/bin/python -m pip install --upgrade pip
+          /opt/python/cp39-cp39/bin/python -m pip install uv maturin auditwheel
+
+      - name: Validate, test, and build wheel in pinned manylinux
+        env:
+          PATH: /opt/python/cp39-cp39/bin:${{ env.PATH }}
+          OTADUMP_NATIVE_CACHE: /tmp/otadump-native-cache
+        run: |
+          set -euxo pipefail
+
+          cargo fmt --all -- --check
+          cargo check --locked
+          cargo test --locked --release --all-features
+          cargo clippy --locked --all-targets --all-features -- -D warnings
+
+          rm -rf "$OTADUMP_NATIVE_CACHE"
+          python3 scripts/fetch-native-artifact.py \
+            --bundle-lock native/zucchini/ARTIFACT_BUNDLE_LOCK.json \
+            --checksum-lock native/zucchini/ARTIFACT_LOCK.sha256 \
+            --out /tmp/otadump-native/linux-x86_64-gnu \
+            --cache "$OTADUMP_NATIVE_CACHE"
+          python3 tests/native_artifact_fetch_test.py
+
+          uv build --wheel
+          auditwheel show dist/*.whl
+          auditwheel repair --wheel-dir wheelhouse dist/*.whl
+
+          python -m venv /tmp/otadump-wheel-smoke
+          source /tmp/otadump-wheel-smoke/bin/activate
+          pip install wheelhouse/*.whl
+          python tests/python_smoke.py
+          python - <<'PY'
+          import pathlib
+          import otadump
+
+          extension = next(pathlib.Path(otadump.__file__).parent.glob("otadump*.so"))
+          print(extension)
+          PY
+
+          SO_PATH=$(python - <<'PY'
+          import pathlib
+          import otadump
+
+          extension = next(pathlib.Path(otadump.__file__).parent.glob("otadump*.so"))
+          print(extension)
+          PY
+          )
+          nm -gD "$SO_PATH" >/tmp/otadump-wheel.nm.txt
+          readelf -d "$SO_PATH" >/tmp/otadump-wheel.readelf.txt
+          ldd "$SO_PATH" >/tmp/otadump-wheel.ldd.txt
+
+      - name: Upload wheel artifacts
+        uses: actions/upload-artifact@v4.6.0
+        with:
+          name: python-wheel-manylinux2014-x86_64
+          path: |
+            dist/*.whl
+            wheelhouse/*.whl
+            /tmp/otadump-wheel.nm.txt
+            /tmp/otadump-wheel.readelf.txt
+            /tmp/otadump-wheel.ldd.txt
diff --git a/README.md b/README.md
index a1fd6fb..5dd320c 100644
--- a/README.md
+++ b/README.md
@@ -117,10 +117,33 @@ Build the Linux x86-64 GNU CLI with `cargo build --profile release-cli --bin ota
 (`release-cli` adds `panic = "abort"` on top of `release`; the plain `release`
 profile keeps unwinding so Python wheels can raise panics as exceptions).
 Build the ABI3 Python wheel with `uv build --wheel`.
-The wheel supports Python 3.9 and later and uses the build host's glibc baseline.
-Build release packages on the oldest Linux environment that you support.
+The wheel supports Python 3.9 and later and should be produced inside a
+manylinux2014 (manylinux_2_17) environment.
 Release archives and wheels include the notices for vendored Puffin and LZ4 code.
 
+### Native ZUCCHINI artifact fetch (Linux x86-64 GNU builds)
+
+Linux x86-64 GNU builds fetch a pinned native archive when `OTADUMP_NATIVE_DIR`
+is not set. The helper requires Python 3 and enforces an immutable
+`https://raw.githubusercontent.com/AndroidDumps/otadump/<commit>/...` URL from
+`native/zucchini/ARTIFACT_BUNDLE_LOCK.json`.
+
+- `OTADUMP_NATIVE_DIR`: bypass download/cache and use a fully materialized
+  directory containing `include/`, `lib/`, `licenses/`, and `provenance.txt`.
+- `OTADUMP_NATIVE_CACHE`: cache root for the pinned `tar.gz` bundle.
+- `OTADUMP_NATIVE_PRESEED`: local preseed source; either a directory (already
+  extracted tree) or a `.tar.gz` archive copied into cache before verification.
+- `OTADUMP_NATIVE_OFFLINE`: non-empty value disables network fetch. Builds fail
+  if cache/preseed is missing.
+
+Behavior summary:
+
+1. If output already exists, checksums are verified and reused.
+2. Concurrent fetches use a cache lock and unique staging directories; one
+   process atomically wins publication and all contenders verify the winner.
+3. Extraction rejects links/path traversal and rejects extra unpinned files or
+   directories outside the checksum lock.
+
 ## Contributors
 
 - [Kartik Sharma][crazystylus]
diff --git a/docs/zucchini-rust-port.md b/docs/zucchini-rust-port.md
index f40e3fa..2b2452c 100644
--- a/docs/zucchini-rust-port.md
+++ b/docs/zucchini-rust-port.md
@@ -1,145 +1,64 @@
-# Pure-Rust Zucchini apply port
-
-Status: implemented and verified byte-exact against every committed Zucchini
-fixture. This is now the only apply path.
-Scope: **apply only**, Android delta OTA element formats (`NoOp`, ELF
-x86/x86-64/AArch32/AArch64, DEX).
-
-## Motivation
-
-The original PR vendored AOSP `external/zucchini` plus `external/libchrome` and
-compiled them from `build.rs` (`src/zucchini.rs` called the
-`otadump_zucchini_apply` C ABI). otadump only ever *applies* patches, so almost
-all of that surface was unnecessary. The apply path is now safe Rust under
-`src/zucchini_pure/`, with no C++ and no libchrome.
-
-## What is implemented
-
-| Area | Source ported | File |
-| --- | --- | --- |
-| Ensemble patch format, varints, stream validation | `patch_reader.{h,cc}`, `patch_utils.h` | `patch.rs` |
-| CRC-32 | `crc32.cc` | `crc32.rs` |
-| Equivalence/extra-data/raw-delta/reference correction, `OffsetMapper`, `TargetPool` | `zucchini_apply.cc`, `equivalence_map.cc`, `target_pool.cc` | `engine.rs` |
-| NoOp element | `disassembler_no_op.cc` | `engine.rs` |
-| ELF parse, address translation, reloc/abs32, Intel + ARM rel32 finders | `disassembler_elf.cc`, `address_translator.cc`, `reloc_elf.cc`, `abs32_utils.cc`, `rel32_utils.cc`, `rel32_finder.cc` | `elf.rs` |
-| AArch32/AArch64 and THUMB2 instruction codecs | `arm_utils.cc` | `arm.rs` |
-| DEX header/map/code-item/item-list parsing and all 42 reference groups | `disassembler_dex.cc`, `type_dex.h` | `dex.rs` |
-| Android preflight hardening | legacy native FFI preflight behavior | `engine.rs` |
-| Little-endian helpers and bit fields | `buffer_view.h`, `algorithm.h` | `bytes.rs` |
-
-`Disassembler` (in `mod.rs`) is the only abstraction the engine needs: size,
-reference groups, ranged reads, and single-reference writes. ELF and DEX
-implement it; `make_disassembler` rejects non-Android formats
-(`UnsupportedElement`), matching the native FFI allow-list.
-
-## Verification
-
-`tests/zucchini_pure.rs` replays the committed fixtures byte-for-byte:
-
-- `noop.zuc` → `noop-new.bin`
-- `elf-x86.zuc`, `elf.zuc`, `elf-arm32.zuc`, `elf-arm64.zuc`
-- `dex.zuc`, `dex-large.zuc` (65,537 strings, 16-bit and 32-bit code refs)
-
-Negative/edge cases: garbage and truncated patches (`InvalidPatch`), a
-mismatched output size (`WrongOutputSize`), a malformed trailing reference-delta
-varint, cancellation, and `dex-large-unsafe16.zuc` (rejected by the ported
-Android preflight with `"android executable preflight failed"`).
-
-Unit regressions cover the DEX opcode table boundary, DEX payload bounds, the
-THUMB2 instruction-size advance, and ELF64 program-header bounds.
-
-The native `tests/delta_extraction.rs` suite (which exercises extraction through
-`zucchini::apply`) now runs against the pure implementation. The full suite
-passes with no C++ configured:
-
-```sh
-cargo test
-cargo clippy --all-targets --all-features -- -D warnings
-```
-
-## Audit fixes applied
-
-1. **Trailing reference-delta varints.** `Cursor::var_u32` no longer consumes
-   bytes on decode failure (mirroring `DecodeVarUInt`/`ParseVarUInt`), and
-   `apply_references_correction` now honors `reference_deltas_done` like native
-   `ReferenceDeltaSource::Done()`.
-2. **DEX opcode 0xFF.** The opcode-table range check widened to `u16`, so
-   `0xFF + 1` no longer wraps to 0. `const-method-type` now parses and its proto
-   reference is corrected.
-3. **THUMB2 advancement.** The scanner returns the decoded instruction size (4
-   for an unmatched 32-bit instruction) and the parser advances by it instead of
-   always stepping 2; it also avoids fetching past the region.
-4. **ELF64 program headers.** `p_offset`/`p_filesz` are summed and bounds-checked
-   as `u64` before narrowing to `offset_t`, so 2^32 offsets cannot truncate into
-   a small valid-looking segment.
-5. **DEX payload offsets.** The payload bound is measured against remaining
-   instruction units, not the whole code item.
-6. **Preflight sizes.** The preflight checks both the old and new disassembler
-   sizes.
-7. **Checked DEX map sizing.** Map-array sizes use checked multiplication, and
-   attacker-sized parser vectors use `try_reserve` instead of infallible
-   `with_capacity`.
-8. **DEX index read widths.** Index-based mappers derive their read width from
-   the group's declared reference width (differential testing against native
-   caught group 0; this also fixes the 32-bit annotations-directory ids in
-   groups 19/22/23, which were being read as 16-bit).
-
-## Cancellation and allocation
-
-`apply()` keeps its signature. `apply_with_cancel(old, patch, size, cancelled)`
-polls a `Fn() -> bool` and returns `Status::Cancelled`. Poll sites cover the
-old/new CRC chunk loops, element boundaries, raw-delta application, reference
-correction (per reference), and both preflight validators (per group and per
-equivalence). `src/zucchini.rs` exposes the same hook, and
-`run_op_zucchini` passes the extraction token and converts a cancelled apply
-back into the typed `ExtractionCancelled` error so the extraction layer unwinds
-cleanly. Cancellation is never folded into the preflight `ApplyError`.
-
-Every vector derived from attacker-controlled counts reserves with
-`try_reserve` (fallible) and surfaces `Status::AllocationFailure`; the patch
-parser also bounds `element_count` and `pool_count` by the remaining patch
-bytes before allocating. `Disassembler::read` is fallible end to end.
-
-## Performance
-
-DEX instructions are decoded once at parse time into a flat, location-sorted
-list. `analyze_element` then materialises each reference group once, and both
-preflight and apply binary-search that snapshot (`GroupRefCache`) instead of
-re-running `groups × equivalences × items` scans; preflight and apply share the
-same analysis for an element.
-
-Measured with a standalone harness on this machine (`-C opt-level=3`), five
-runs each, comparing the commit before the cache with the current tree:
-
-| Fixture | Before | After |
-| --- | --- | --- |
-| `dex` | ~0.013 ms/iter | ~0.009 ms/iter |
-| `dex-large` | ~6.4 ms/iter | ~6.0 ms/iter |
-| `elf` | ~0.019 ms/iter | ~0.018 ms/iter |
-
-The large DEX fixture has a single equivalence and is dominated by its 65k
-item-list walks, so the structural scan reduction mostly shows on the small
-fixture; many-equivalence partitions benefit more. `group_ref_cache_matches_ranged_reads`
-asserts the cached snapshot is byte-identical to fresh ranged reads for every
-group and range on the ELF/DEX fixtures.
-
-## Intentional behavioural and size deltas
-
-- **Stricter than upstream Zucchini by design.** The ported Android preflight
-  (`ValidateReferenceBoundaries`, `ValidateDexWriterWidths`,
-  `ValidateDexReferenceTargets`) rejects patches upstream would accept. This
-  matches the AndroidDumps native FFI exactly; `dex-large-unsafe16.zuc` is the
-  canonical case.
-- **Message alignment.** An old-file failure reports
-  `"android executable preflight failed"` and a final new-file mismatch reports
-  `"zucchini apply failed"`, matching the native FFI's ordering.
-- **Size.** The vendored C++ boundary is 2.4 MB of source (37 C/C++ files) and
-  produces a 14,559,914-byte debug static archive including the libchrome slice.
-  The pure-Rust module compiles to a 244,312-byte object (≈127 KB of text) at
-  `-C opt-level=2`. The default `build.rs` now builds only protobuf and the
-  small C lz4 library.
-
-## Remaining work
-
-1. **Non-Android formats (Win32, ZTF).** Not emitted by Android payloads and
-   intentionally rejected.
+# Native ZUCCHINI artifact architecture
+
+Status: active for Linux x86-64 GNU builds.
+
+## Overview
+
+`otadump` links a prebuilt `libotadump_zucchini.a` archive for Linux x86-64 GNU
+targets and keeps all other targets on the pure-Rust delta stack without the
+native bridge.
+
+The artifact is pinned by:
+
+- `native/zucchini/ARTIFACT_BUNDLE_LOCK.json` (immutable commit URL + archive digest)
+- `native/zucchini/ARTIFACT_LOCK.sha256` (per-file digest lock inside the extracted tree)
+
+`build.rs` invokes `scripts/fetch-native-artifact.py` unless
+`OTADUMP_NATIVE_DIR` is set.
+
+## Security and integrity guarantees
+
+The fetch helper enforces:
+
+1. HTTPS-only URL policy.
+2. Exact host policy: `raw.githubusercontent.com`.
+3. Exact immutable path policy:
+   `/AndroidDumps/otadump/<commit>/native/artifacts/zucchini/zucchini-linux-x86_64-gnu.tar.gz`.
+4. Download timeout and max-size bounds.
+5. Archive digest verification before extraction.
+6. Tar safety checks: no traversal, no symlinks/hardlinks, files/dirs only.
+7. Strict extracted-tree verification: no extra files/directories outside the
+   checksum lock's expected structure.
+
+## Concurrency model
+
+Concurrent builds sharing `OTADUMP_NATIVE_CACHE` coordinate through a fetch lock
+keyed by bundle digest.
+
+- Only one process writes the cached archive at a time.
+- Each process stages extraction into a unique temp directory.
+- Publication uses atomic rename; one contender wins.
+- Losers verify the published tree and continue.
+
+This avoids partial publication and keeps cache/output deterministic under
+parallel runners.
+
+## Offline and preseed behavior
+
+- `OTADUMP_NATIVE_OFFLINE=1`: network disabled; build requires cached or
+  preseeded artifact.
+- `OTADUMP_NATIVE_PRESEED=/path/to/archive.tar.gz`: copies the archive into the
+  cache before checksum verification.
+- `OTADUMP_NATIVE_PRESEED=/path/to/tree`: verifies and publishes a fully
+  materialized extracted tree.
+
+## Test coverage
+
+`tests/native_artifact_fetch_test.py` covers:
+
+- parallel fetch/publish contention
+- URL policy rejections
+- strict extra-file rejection
+- checksum tamper rejection
+- traversal rejection
+- offline-with-empty-cache rejection
diff --git a/native/zucchini/ARTIFACT_LOCK.sha256 b/native/zucchini/ARTIFACT_LOCK.sha256
index cea32a8..b795a88 100644
--- a/native/zucchini/ARTIFACT_LOCK.sha256
+++ b/native/zucchini/ARTIFACT_LOCK.sha256
@@ -1,4 +1,5 @@
 2f7138dd9ff6b0d4cb081536b3a8a16cb5c3ff09ee96d73f6351e8cae0d6a99c  lib/libotadump_zucchini.a
+53aabfa70f3c3061b63017a8d7c5e82bf62aab22c68b6189fdc1c8f99927c31b  SHA256SUMS
 11696b3b8d3dc920e2375d98fd95028cd32c6c1ea86b082d6f800e00fb357703  include/zucchini_ffi.h
 845022e0c1db1abb41a6ba4cd3c4b674ec290f3359d9d3c78ae558d4c0ed9308  licenses/LICENSE.zucchini
 a0a33d4ad9d6a62311eae87175db1bad4686a8d6a0edd47ac1584be7569d67e4  provenance.txt
diff --git a/scripts/fetch-native-artifact.py b/scripts/fetch-native-artifact.py
index 8712557..d4ad8ef 100755
--- a/scripts/fetch-native-artifact.py
+++ b/scripts/fetch-native-artifact.py
@@ -8,7 +8,44 @@
 import sys
 import tarfile
 import tempfile
+import time
 import urllib.request
+import uuid
+from urllib.parse import urlsplit
+
+
+DOWNLOAD_TIMEOUT_SECONDS = 30
+DOWNLOAD_MAX_BYTES = 256 * 1024 * 1024
+LOCK_WAIT_SECONDS = 120
+LOCK_POLL_SECONDS = 0.05
+
+
+class FileLock:
+    def __init__(self, path: pathlib.Path, timeout_seconds: float) -> None:
+        self.path = path
+        self.timeout_seconds = timeout_seconds
+        self.fd = -1
+
+    def __enter__(self) -> "FileLock":
+        deadline = time.monotonic() + self.timeout_seconds
+        while True:
+            try:
+                self.fd = os.open(self.path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+                os.write(self.fd, f"{os.getpid()}\n".encode("ascii"))
+                return self
+            except FileExistsError:
+                if time.monotonic() >= deadline:
+                    raise RuntimeError(f"timed out waiting for lock: {self.path}")
+                time.sleep(LOCK_POLL_SECONDS)
+
+    def __exit__(self, _exc_type, _exc, _tb) -> None:
+        if self.fd >= 0:
+            os.close(self.fd)
+            self.fd = -1
+        try:
+            self.path.unlink()
+        except FileNotFoundError:
+            pass
 
 
 def sha256_file(path: pathlib.Path) -> str:
@@ -30,7 +67,60 @@ def parse_sha256_lock(path: pathlib.Path) -> dict[str, str]:
     return checksums
 
 
+def validate_bundle_url(url: str, commit: str) -> None:
+    if len(commit) != 40 or any(ch not in "0123456789abcdef" for ch in commit):
+        raise RuntimeError(f"bundle lock commit must be a lowercase 40-char hex SHA: {commit}")
+    parsed = urlsplit(url)
+    if parsed.scheme != "https":
+        raise RuntimeError(f"native artifact URL must use HTTPS: {url}")
+    if parsed.hostname != "raw.githubusercontent.com":
+        raise RuntimeError(
+            "native artifact URL host must be raw.githubusercontent.com: "
+            f"{parsed.hostname or '<missing>'}"
+        )
+    if parsed.query or parsed.fragment:
+        raise RuntimeError("native artifact URL must not include query parameters or fragments")
+    expected_path = (
+        f"/AndroidDumps/otadump/{commit}/native/artifacts/zucchini/"
+        "zucchini-linux-x86_64-gnu.tar.gz"
+    )
+    if parsed.path != expected_path:
+        raise RuntimeError(
+            "native artifact URL path must match the immutable commit artifact path: "
+            f"expected {expected_path}, got {parsed.path}"
+        )
+
+
 def verify_tree(root: pathlib.Path, checksums: dict[str, str]) -> None:
+    expected_files = set(checksums)
+    allowed_dirs = {"."}
+    for relpath in checksums:
+        parent = pathlib.PurePosixPath(relpath).parent
+        while True:
+            allowed_dirs.add(parent.as_posix())
+            if parent == pathlib.PurePosixPath("."):
+                break
+            parent = parent.parent
+
+    discovered_files = set()
+    for candidate in root.rglob("*"):
+        relpath = candidate.relative_to(root).as_posix()
+        if candidate.is_symlink():
+            raise RuntimeError(f"links are not allowed in native artifact tree: {relpath}")
+        if candidate.is_dir():
+            if relpath not in allowed_dirs:
+                raise RuntimeError(f"unexpected native artifact directory: {relpath}")
+            continue
+        if not candidate.is_file():
+            raise RuntimeError(f"unsupported native artifact entry type: {relpath}")
+        if relpath not in expected_files:
+            raise RuntimeError(f"unexpected native artifact file: {relpath}")
+        discovered_files.add(relpath)
+
+    missing = sorted(expected_files - discovered_files)
+    if missing:
+        raise RuntimeError(f"missing native artifact files: {', '.join(missing)}")
+
     for relpath, expected in checksums.items():
         target = root / relpath
         if not target.is_file():
@@ -55,6 +145,35 @@ def safe_extract(archive: pathlib.Path, destination: pathlib.Path) -> None:
         tar.extractall(destination)
 
 
+def download_archive(url: str, archive_path: pathlib.Path) -> None:
+    with urllib.request.urlopen(url, timeout=DOWNLOAD_TIMEOUT_SECONDS) as response:
+        header_length = response.headers.get("Content-Length")
+        if header_length is not None:
+            try:
+                if int(header_length) > DOWNLOAD_MAX_BYTES:
+                    raise RuntimeError(
+                        "native artifact archive is too large: "
+                        f"{header_length} bytes exceeds {DOWNLOAD_MAX_BYTES}"
+                    )
+            except ValueError:
+                pass
+        with tempfile.NamedTemporaryFile(delete=False, dir=archive_path.parent) as handle:
+            total = 0
+            while True:
+                chunk = response.read(1024 * 1024)
+                if not chunk:
+                    break
+                total += len(chunk)
+                if total > DOWNLOAD_MAX_BYTES:
+                    raise RuntimeError(
+                        "native artifact archive is too large: "
+                        f"streamed {total} bytes exceeds {DOWNLOAD_MAX_BYTES}"
+                    )
+                handle.write(chunk)
+            temp_name = handle.name
+    pathlib.Path(temp_name).replace(archive_path)
+
+
 def main() -> int:
     parser = argparse.ArgumentParser()
     parser.add_argument("--bundle-lock", required=True)
@@ -64,6 +183,7 @@ def main() -> int:
     args = parser.parse_args()
 
     bundle_lock = json.loads(pathlib.Path(args.bundle_lock).read_text(encoding="utf-8"))
+    validate_bundle_url(bundle_lock["url"], bundle_lock["commit"])
     checksums = parse_sha256_lock(pathlib.Path(args.checksum_lock))
     out_dir = pathlib.Path(args.out)
 
@@ -74,6 +194,7 @@ def main() -> int:
     cache_root = pathlib.Path(args.cache)
     cache_root.mkdir(parents=True, exist_ok=True)
     archive_path = cache_root / f"{bundle_lock['sha256']}.tar.gz"
+    fetch_lock = cache_root / f".{bundle_lock['sha256']}.fetch.lock"
 
     preseed = os.environ.get("OTADUMP_NATIVE_PRESEED")
     offline = os.environ.get("OTADUMP_NATIVE_OFFLINE")
@@ -83,25 +204,33 @@ def main() -> int:
         if preseed_path.is_dir():
             verify_tree(preseed_path, checksums)
             out_dir.parent.mkdir(parents=True, exist_ok=True)
-            if out_dir.exists():
-                shutil.rmtree(out_dir)
-            shutil.copytree(preseed_path, out_dir)
+            staging = out_dir.with_name(f"{out_dir.name}.tmp-{os.getpid()}-{uuid.uuid4().hex}")
+            if staging.exists():
+                shutil.rmtree(staging)
+            shutil.copytree(preseed_path, staging)
+            try:
+                os.replace(staging, out_dir)
+            except OSError:
+                if staging.exists():
+                    shutil.rmtree(staging)
+                if out_dir.is_dir():
+                    verify_tree(out_dir, checksums)
+                    return 0
+                raise
             return 0
         if not preseed_path.is_file():
             raise RuntimeError(f"OTADUMP_NATIVE_PRESEED path does not exist: {preseed_path}")
-        shutil.copy2(preseed_path, archive_path)
 
-    if not archive_path.is_file():
-        if offline:
-            raise RuntimeError(
-                "offline native artifact mode is enabled but cache is empty; "
-                "set OTADUMP_NATIVE_PRESEED or unset OTADUMP_NATIVE_OFFLINE"
-            )
-        with urllib.request.urlopen(bundle_lock["url"]) as response:
-            with tempfile.NamedTemporaryFile(delete=False, dir=cache_root) as handle:
-                handle.write(response.read())
-                temp_name = handle.name
-        pathlib.Path(temp_name).replace(archive_path)
+    with FileLock(fetch_lock, LOCK_WAIT_SECONDS):
+        if preseed and pathlib.Path(preseed).is_file():
+            shutil.copy2(pathlib.Path(preseed), archive_path)
+        if not archive_path.is_file():
+            if offline:
+                raise RuntimeError(
+                    "offline native artifact mode is enabled but cache is empty; "
+                    "set OTADUMP_NATIVE_PRESEED or unset OTADUMP_NATIVE_OFFLINE"
+                )
+            download_archive(bundle_lock["url"], archive_path)
 
     archive_digest = sha256_file(archive_path)
     if archive_digest != bundle_lock["sha256"]:
@@ -118,11 +247,19 @@ def main() -> int:
         verify_tree(extracted, checksums)
 
         out_dir.parent.mkdir(parents=True, exist_ok=True)
-        staging = out_dir.with_name(out_dir.name + ".tmp")
+        staging = out_dir.with_name(f"{out_dir.name}.tmp-{os.getpid()}-{uuid.uuid4().hex}")
         if staging.exists():
             shutil.rmtree(staging)
         shutil.copytree(extracted, staging)
-        os.replace(staging, out_dir)
+        try:
+            os.replace(staging, out_dir)
+        except OSError:
+            if staging.exists():
+                shutil.rmtree(staging)
+            if out_dir.is_dir():
+                verify_tree(out_dir, checksums)
+                return 0
+            raise
 
     return 0
 
diff --git a/tests/native_artifact_fetch_test.py b/tests/native_artifact_fetch_test.py
new file mode 100644
index 0000000..21a1e80
--- /dev/null
+++ b/tests/native_artifact_fetch_test.py
@@ -0,0 +1,240 @@
+import concurrent.futures
+import hashlib
+import json
+import os
+import pathlib
+import subprocess
+import tarfile
+import tempfile
+import unittest
+from typing import Optional
+
+
+REPO_ROOT = pathlib.Path(__file__).resolve().parents[1]
+FETCH_SCRIPT = REPO_ROOT / "scripts" / "fetch-native-artifact.py"
+
+
+def sha256_file(path: pathlib.Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def write_tree(root: pathlib.Path, entries: dict[str, bytes]) -> None:
+    for relpath, content in entries.items():
+        target = root / relpath
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_bytes(content)
+
+
+def write_bundle(
+    root: pathlib.Path,
+    entries: dict[str, bytes],
+    *,
+    include_extra_file: bool = False,
+    include_traversal_entry: bool = False,
+) -> pathlib.Path:
+    extract_root = root / "linux-x86_64-gnu"
+    write_tree(extract_root, entries)
+    if include_extra_file:
+        (extract_root / "rogue.txt").write_text("rogue", encoding="utf-8")
+    archive = root / "bundle.tar.gz"
+    with tarfile.open(archive, "w:gz") as tar:
+        tar.add(extract_root, arcname="linux-x86_64-gnu")
+        if include_traversal_entry:
+            attack = root / "attack.txt"
+            attack.write_text("attack", encoding="utf-8")
+            tar.add(attack, arcname="../attack.txt")
+    return archive
+
+
+def write_locks(
+    root: pathlib.Path,
+    archive: pathlib.Path,
+    *,
+    url: str,
+    sha_override: Optional[str] = None,
+) -> tuple[pathlib.Path, pathlib.Path]:
+    checksums = {
+        "lib/libotadump_zucchini.a": b"archive-bytes\n",
+        "SHA256SUMS": b"sha-entry\n",
+        "include/zucchini_ffi.h": b"#pragma once\n",
+        "licenses/LICENSE.zucchini": b"license\n",
+        "provenance.txt": b"provenance\n",
+    }
+    lock_path = root / "ARTIFACT_LOCK.sha256"
+    lines = []
+    for relpath, content in checksums.items():
+        lines.append(f"{hashlib.sha256(content).hexdigest()}  {relpath}")
+    lock_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    digest = sha_override or sha256_file(archive)
+    bundle = {
+        "schema": 1,
+        "commit": "9534f6e24296b1682d53cdac19da0b81fc97fcbc",
+        "url": url,
+        "sha256": digest,
+        "extract_root": "linux-x86_64-gnu",
+    }
+    bundle_path = root / "ARTIFACT_BUNDLE_LOCK.json"
+    bundle_path.write_text(json.dumps(bundle), encoding="utf-8")
+    return bundle_path, lock_path
+
+
+class NativeArtifactFetchTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tempdir = tempfile.TemporaryDirectory()
+        self.root = pathlib.Path(self.tempdir.name)
+        self.entries = {
+            "lib/libotadump_zucchini.a": b"archive-bytes\n",
+            "SHA256SUMS": b"sha-entry\n",
+            "include/zucchini_ffi.h": b"#pragma once\n",
+            "licenses/LICENSE.zucchini": b"license\n",
+            "provenance.txt": b"provenance\n",
+        }
+        self.valid_url = (
+            "https://raw.githubusercontent.com/AndroidDumps/otadump/"
+            "9534f6e24296b1682d53cdac19da0b81fc97fcbc/native/artifacts/zucchini/"
+            "zucchini-linux-x86_64-gnu.tar.gz"
+        )
+
+    def tearDown(self) -> None:
+        self.tempdir.cleanup()
+
+    def run_fetch(
+        self,
+        bundle_lock: pathlib.Path,
+        checksum_lock: pathlib.Path,
+        out_dir: pathlib.Path,
+        cache_dir: pathlib.Path,
+        extra_env: Optional[dict[str, str]] = None,
+    ) -> subprocess.CompletedProcess[str]:
+        env = os.environ.copy()
+        env.pop("OTADUMP_NATIVE_PRESEED", None)
+        env.pop("OTADUMP_NATIVE_OFFLINE", None)
+        env.pop("OTADUMP_NATIVE_CACHE", None)
+        if extra_env:
+            env.update(extra_env)
+        return subprocess.run(
+            [
+                "python3",
+                str(FETCH_SCRIPT),
+                "--bundle-lock",
+                str(bundle_lock),
+                "--checksum-lock",
+                str(checksum_lock),
+                "--out",
+                str(out_dir),
+                "--cache",
+                str(cache_dir),
+            ],
+            text=True,
+            capture_output=True,
+            env=env,
+            check=False,
+        )
+
+    def test_parallel_fetches_share_cache_and_atomic_winner(self) -> None:
+        archive = write_bundle(self.root, self.entries)
+        bundle_lock, checksum_lock = write_locks(self.root, archive, url=self.valid_url)
+        out_dir = self.root / "out" / "linux-x86_64-gnu"
+        cache_dir = self.root / "cache"
+
+        def run_once() -> subprocess.CompletedProcess[str]:
+            return self.run_fetch(
+                bundle_lock,
+                checksum_lock,
+                out_dir,
+                cache_dir,
+                {"OTADUMP_NATIVE_PRESEED": str(archive)},
+            )
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=8) as pool:
+            results = list(pool.map(lambda _index: run_once(), range(8)))
+
+        for result in results:
+            self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertTrue((out_dir / "lib" / "libotadump_zucchini.a").is_file())
+        leftovers = [entry.name for entry in out_dir.parent.iterdir() if ".tmp-" in entry.name]
+        self.assertEqual(leftovers, [])
+
+    def test_url_policy_rejects_non_https(self) -> None:
+        archive = write_bundle(self.root, self.entries)
+        bundle_lock, checksum_lock = write_locks(self.root, archive, url=self.valid_url.replace("https://", "http://"))
+        result = self.run_fetch(bundle_lock, checksum_lock, self.root / "out" / "dir", self.root / "cache")
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("must use HTTPS", result.stderr)
+
+    def test_url_policy_rejects_unpinned_host_path(self) -> None:
+        archive = write_bundle(self.root, self.entries)
+        bad_url = "https://github.com/AndroidDumps/otadump/archive/refs/heads/mainline.tar.gz"
+        bundle_lock, checksum_lock = write_locks(self.root, archive, url=bad_url)
+        result = self.run_fetch(bundle_lock, checksum_lock, self.root / "out" / "dir", self.root / "cache")
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("host must be raw.githubusercontent.com", result.stderr)
+
+    def test_strict_tree_verification_rejects_extra_unpinned_file(self) -> None:
+        preseed_dir = self.root / "preseed"
+        write_tree(preseed_dir, self.entries)
+        (preseed_dir / "extra.bin").write_bytes(b"x")
+        archive = write_bundle(self.root, self.entries)
+        bundle_lock, checksum_lock = write_locks(self.root, archive, url=self.valid_url)
+        result = self.run_fetch(
+            bundle_lock,
+            checksum_lock,
+            self.root / "out" / "dir",
+            self.root / "cache",
+            {"OTADUMP_NATIVE_PRESEED": str(preseed_dir)},
+        )
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("unexpected native artifact file", result.stderr)
+
+    def test_tampered_archive_fails_checksum_lock(self) -> None:
+        archive = write_bundle(self.root, self.entries)
+        bundle_lock, checksum_lock = write_locks(
+            self.root,
+            archive,
+            url=self.valid_url,
+            sha_override="0" * 64,
+        )
+        result = self.run_fetch(
+            bundle_lock,
+            checksum_lock,
+            self.root / "out" / "dir",
+            self.root / "cache",
+            {"OTADUMP_NATIVE_PRESEED": str(archive)},
+        )
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("archive checksum mismatch", result.stderr)
+
+    def test_traversal_entry_is_rejected(self) -> None:
+        archive = write_bundle(self.root, self.entries, include_traversal_entry=True)
+        bundle_lock, checksum_lock = write_locks(self.root, archive, url=self.valid_url)
+        result = self.run_fetch(
+            bundle_lock,
+            checksum_lock,
+            self.root / "out" / "dir",
+            self.root / "cache",
+            {"OTADUMP_NATIVE_PRESEED": str(archive)},
+        )
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("unsafe entry", result.stderr)
+
+    def test_offline_requires_cache_or_preseed(self) -> None:
+        archive = write_bundle(self.root, self.entries)
+        bundle_lock, checksum_lock = write_locks(self.root, archive, url=self.valid_url)
+        result = self.run_fetch(
+            bundle_lock,
+            checksum_lock,
+            self.root / "out" / "dir",
+            self.root / "cache",
+            {"OTADUMP_NATIVE_OFFLINE": "1"},
+        )
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("offline native artifact mode is enabled but cache is empty", result.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

From 8c50a0aefdbfcfe482156df4cc2206dd7d8d20cc Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sun, 13 Sep 2026 00:01:42 +0530
Subject: [PATCH 41/42] Prune test corpus and consolidate delta/runtime helpers

---
 scripts/fetch-native-artifact.py              |   49 +-
 src/bsdiff.rs                                 |   18 +-
 src/lib.rs                                    |   84 +-
 src/lz4.rs                                    |  185 +-
 src/lz4diff.rs                                |    6 +-
 src/puffin/patch.rs                           |   20 +-
 tests/delta_extraction.rs                     | 2022 +----------------
 tests/fixture_corpus.rs                       |   30 -
 tests/fixtures/corpus/MANIFEST.txt            |   46 -
 tests/fixtures/corpus/README.md               |    8 -
 tests/fixtures/corpus/SHA256SUMS              |    1 -
 tests/fixtures/corpus/opaque-fixtures.zip     |  Bin 1822459 -> 0 bytes
 tests/fixtures/fec/LICENSE                    |  202 --
 tests/fixtures/fec/README.md                  |   15 -
 tests/fixtures/fec/SHA256SUMS                 |    2 -
 tests/fixtures/lz4/LICENSE                    |   25 -
 tests/fixtures/lz4/README.md                  |   14 -
 tests/fixtures/lz4/SHA256SUMS                 |    7 -
 tests/fixtures/lz4diff/LICENSE.lz4            |   25 -
 tests/fixtures/lz4diff/LICENSE.puffin         |   27 -
 tests/fixtures/lz4diff/README.md              |   29 -
 tests/fixtures/lz4diff/SHA256SUMS             |    7 -
 tests/fixtures/puffin/README.md               |    6 +-
 tests/fixtures/puffin/SHA256SUMS              |    3 -
 tests/fixtures/puffin/deflates-sample1.bin    |  Bin 0 -> 17 bytes
 tests/fixtures/puffin/deflates-sample2.bin    |  Bin 0 -> 22 bytes
 .../fixtures/puffin/patch-1-to-2-zucchini.puf |  Bin 0 -> 176 bytes
 tests/fixtures/zucchini/LICENSE               |   29 -
 tests/fixtures/zucchini/README.md             |   37 -
 tests/fixtures/zucchini/SHA256SUMS            |   25 -
 tests/native_artifact_fetch_test.py           |  126 +-
 tests/python_smoke.py                         |   41 +-
 32 files changed, 213 insertions(+), 2876 deletions(-)
 delete mode 100644 tests/fixture_corpus.rs
 delete mode 100644 tests/fixtures/corpus/MANIFEST.txt
 delete mode 100644 tests/fixtures/corpus/README.md
 delete mode 100644 tests/fixtures/corpus/SHA256SUMS
 delete mode 100644 tests/fixtures/corpus/opaque-fixtures.zip
 delete mode 100644 tests/fixtures/fec/LICENSE
 delete mode 100644 tests/fixtures/fec/README.md
 delete mode 100644 tests/fixtures/fec/SHA256SUMS
 delete mode 100644 tests/fixtures/lz4/LICENSE
 delete mode 100644 tests/fixtures/lz4/README.md
 delete mode 100644 tests/fixtures/lz4/SHA256SUMS
 delete mode 100644 tests/fixtures/lz4diff/LICENSE.lz4
 delete mode 100644 tests/fixtures/lz4diff/LICENSE.puffin
 delete mode 100644 tests/fixtures/lz4diff/README.md
 delete mode 100644 tests/fixtures/lz4diff/SHA256SUMS
 create mode 100644 tests/fixtures/puffin/deflates-sample1.bin
 create mode 100644 tests/fixtures/puffin/deflates-sample2.bin
 create mode 100644 tests/fixtures/puffin/patch-1-to-2-zucchini.puf
 delete mode 100644 tests/fixtures/zucchini/LICENSE
 delete mode 100644 tests/fixtures/zucchini/README.md
 delete mode 100644 tests/fixtures/zucchini/SHA256SUMS

diff --git a/scripts/fetch-native-artifact.py b/scripts/fetch-native-artifact.py
index d4ad8ef..daee375 100755
--- a/scripts/fetch-native-artifact.py
+++ b/scripts/fetch-native-artifact.py
@@ -174,6 +174,24 @@ def download_archive(url: str, archive_path: pathlib.Path) -> None:
     pathlib.Path(temp_name).replace(archive_path)
 
 
+def publish_tree(source: pathlib.Path, out_dir: pathlib.Path, checksums: dict[str, str]) -> int:
+    out_dir.parent.mkdir(parents=True, exist_ok=True)
+    staging = out_dir.with_name(f"{out_dir.name}.tmp-{os.getpid()}-{uuid.uuid4().hex}")
+    if staging.exists():
+        shutil.rmtree(staging)
+    shutil.copytree(source, staging)
+    try:
+        os.replace(staging, out_dir)
+    except OSError:
+        if staging.exists():
+            shutil.rmtree(staging)
+        if out_dir.is_dir():
+            verify_tree(out_dir, checksums)
+            return 0
+        raise
+    return 0
+
+
 def main() -> int:
     parser = argparse.ArgumentParser()
     parser.add_argument("--bundle-lock", required=True)
@@ -203,21 +221,7 @@ def main() -> int:
         preseed_path = pathlib.Path(preseed)
         if preseed_path.is_dir():
             verify_tree(preseed_path, checksums)
-            out_dir.parent.mkdir(parents=True, exist_ok=True)
-            staging = out_dir.with_name(f"{out_dir.name}.tmp-{os.getpid()}-{uuid.uuid4().hex}")
-            if staging.exists():
-                shutil.rmtree(staging)
-            shutil.copytree(preseed_path, staging)
-            try:
-                os.replace(staging, out_dir)
-            except OSError:
-                if staging.exists():
-                    shutil.rmtree(staging)
-                if out_dir.is_dir():
-                    verify_tree(out_dir, checksums)
-                    return 0
-                raise
-            return 0
+            return publish_tree(preseed_path, out_dir, checksums)
         if not preseed_path.is_file():
             raise RuntimeError(f"OTADUMP_NATIVE_PRESEED path does not exist: {preseed_path}")
 
@@ -246,20 +250,7 @@ def main() -> int:
             raise RuntimeError(f"missing artifact root after extraction: {bundle_lock['extract_root']}")
         verify_tree(extracted, checksums)
 
-        out_dir.parent.mkdir(parents=True, exist_ok=True)
-        staging = out_dir.with_name(f"{out_dir.name}.tmp-{os.getpid()}-{uuid.uuid4().hex}")
-        if staging.exists():
-            shutil.rmtree(staging)
-        shutil.copytree(extracted, staging)
-        try:
-            os.replace(staging, out_dir)
-        except OSError:
-            if staging.exists():
-                shutil.rmtree(staging)
-            if out_dir.is_dir():
-                verify_tree(out_dir, checksums)
-                return 0
-            raise
+        return publish_tree(extracted, out_dir, checksums)
 
     return 0
 
diff --git a/src/bsdiff.rs b/src/bsdiff.rs
index ecdd85a..6255ee6 100644
--- a/src/bsdiff.rs
+++ b/src/bsdiff.rs
@@ -12,7 +12,7 @@
 
 use std::io::Read;
 
-use anyhow::{Result, bail, ensure};
+use anyhow::{Result, anyhow, bail, ensure};
 
 enum Algorithm {
     None,
@@ -22,6 +22,22 @@ enum Algorithm {
 
 type ParsedPatch = (i64, Vec<u8>, Vec<u8>, Vec<u8>);
 
+pub fn validate_output_len(patch: &[u8], expected: usize) -> Result<()> {
+    ensure!(patch.len() >= 32, "Patch data too short");
+    ensure!(
+        &patch[..8] == b"BSDIFF40" || &patch[..5] == b"BSDF2",
+        "Invalid BSDIFF/BSDF2 magic header"
+    );
+    let encoded = u64::from_le_bytes(
+        patch[24..32].try_into().map_err(|_| anyhow!("Invalid BSDIFF output length field"))?,
+    );
+    ensure!(encoded & (1 << 63) == 0, "Negative output length in patch header");
+    let actual =
+        usize::try_from(encoded).map_err(|_| anyhow!("Patch output length is too large"))?;
+    ensure!(actual == expected, "Patch output length mismatch: expected {expected}, got {actual}");
+    Ok(())
+}
+
 fn algorithm_from_byte(value: u8) -> Result<Algorithm> {
     match value {
         0 => Ok(Algorithm::None),
diff --git a/src/lib.rs b/src/lib.rs
index 8fd1d8d..a7b018a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -266,7 +266,6 @@ impl<'a> ExtractOptions<'a> {
                 let task = Task {
                     payload: &payload,
                     block_size,
-                    verify: self.verify,
                     update,
                     source,
                     op_idx: AtomicUsize::new(0),
@@ -728,8 +727,8 @@ fn extract_operation_data<'a>(payload: &'a Payload<'a>, op: &InstallOperation) -
     payload.data.get(offset..end).context("Data range exceeds payload size")
 }
 
-fn verify_hash(
-    data: &[u8],
+fn verify_hash_chunks<'a>(
+    chunks: impl IntoIterator<Item = &'a [u8]>,
     expected: Option<&[u8]>,
     label: &str,
     cancellation_token: &CancellationToken,
@@ -739,7 +738,7 @@ fn verify_hash(
         return Ok(());
     };
     let mut context = digest::Context::new(&digest::SHA256);
-    for chunk in data.chunks(VERIFY_CHUNK_SIZE) {
+    for chunk in chunks {
         cancellation_token.check()?;
         context.update(chunk);
     }
@@ -753,6 +752,15 @@ fn verify_hash(
     Ok(())
 }
 
+fn verify_hash(
+    data: &[u8],
+    expected: Option<&[u8]>,
+    label: &str,
+    cancellation_token: &CancellationToken,
+) -> Result<()> {
+    verify_hash_chunks(data.chunks(VERIFY_CHUNK_SIZE), expected, label, cancellation_token)
+}
+
 fn verify_hash_over_ranges(
     data: &[u8],
     ranges: &[Range<usize>],
@@ -760,25 +768,8 @@ fn verify_hash_over_ranges(
     label: &str,
     cancellation_token: &CancellationToken,
 ) -> Result<()> {
-    cancellation_token.check()?;
-    let Some(expected) = expected else {
-        return Ok(());
-    };
-    let mut context = digest::Context::new(&digest::SHA256);
-    for range in ranges {
-        for chunk in data[range.clone()].chunks(VERIFY_CHUNK_SIZE) {
-            cancellation_token.check()?;
-            context.update(chunk);
-        }
-    }
-    let actual = context.finish();
-    ensure!(
-        actual.as_ref() == expected,
-        "{label} hash mismatch: expected {}, got {}",
-        hex::encode(expected),
-        hex::encode(actual.as_ref())
-    );
-    Ok(())
+    let chunks = ranges.iter().flat_map(|range| data[range.clone()].chunks(VERIFY_CHUNK_SIZE));
+    verify_hash_chunks(chunks, expected, label, cancellation_token)
 }
 
 fn paths_alias(source: &Path, destination: &Path) -> Result<bool> {
@@ -824,7 +815,6 @@ impl Default for ExtractOptions<'_> {
 struct Task<'a> {
     payload: &'a Payload<'a>,
     block_size: usize,
-    verify: bool,
 
     update: &'a PartitionUpdate,
     source: Option<SourcePartition>,
@@ -992,16 +982,7 @@ impl Task<'_> {
         let output = zucchini::apply_with_cancel(&source, &patch, expected_output_len, || {
             self.cancellation_token.is_cancelled()
         })
-        .map_err(|error| {
-            // Preserve cooperative cancellation as a typed error so the
-            // extraction layer can unwind cleanly; anything else is a patch
-            // failure.
-            if error.status() == zucchini::Status::Cancelled {
-                anyhow::Error::new(ExtractionCancelled)
-            } else {
-                anyhow::anyhow!("ZUCCHINI apply failed: {error}")
-            }
-        })?;
+        .map_err(map_zucchini_apply_error)?;
         self.cancellation_token.check()?;
         self.write_exact(&output, dst_extents)
     }
@@ -1132,16 +1113,7 @@ impl Task<'_> {
     }
 
     fn extract_data<'a>(&'a self, op: &InstallOperation) -> Result<&'a [u8]> {
-        let data = extract_operation_data(self.payload, op)?;
-        self.verify_op(op, data)?;
-        Ok(data)
-    }
-
-    fn verify_op(&self, op: &InstallOperation, data: &[u8]) -> Result<()> {
-        if !self.verify {
-            return Ok(());
-        }
-        verify_hash(data, op.data_sha256_hash.as_deref(), "Input", self.cancellation_token)
+        extract_operation_data(self.payload, op)
     }
 
     fn increment_progress(&self) {
@@ -1158,6 +1130,14 @@ fn lz4diff_error(error: Error) -> Error {
     }
 }
 
+fn map_zucchini_apply_error(error: zucchini::Error) -> Error {
+    if error.status() == zucchini::Status::Cancelled {
+        Error::new(ExtractionCancelled)
+    } else {
+        anyhow::anyhow!("ZUCCHINI apply failed: {error}")
+    }
+}
+
 pub(crate) fn decode_zucchini_patch(
     compressed_patch: &[u8],
     cancellation_token: &CancellationToken,
@@ -1248,20 +1228,6 @@ fn increment_progress(
     }
 }
 
-fn validate_bsdiff_output_len(patch: &[u8], expected: usize) -> Result<()> {
-    ensure!(patch.len() >= 32, "Patch data too short");
-    ensure!(
-        &patch[..8] == b"BSDIFF40" || &patch[..5] == b"BSDF2",
-        "Invalid BSDIFF/BSDF2 magic header"
-    );
-    let encoded =
-        u64::from_le_bytes(patch[24..32].try_into().context("Invalid BSDIFF output length field")?);
-    ensure!(encoded & (1 << 63) == 0, "Negative output length in patch header");
-    let actual = usize::try_from(encoded).context("Patch output length is too large")?;
-    ensure!(actual == expected, "Patch output length mismatch: expected {expected}, got {actual}");
-    Ok(())
-}
-
 #[inline]
 fn offtin(buf: [u8; 8]) -> i64 {
     let y = i64::from_le_bytes(buf);
@@ -1274,7 +1240,7 @@ pub(crate) fn apply_bsdiff(
     expected_output_len: usize,
     cancellation_token: &CancellationToken,
 ) -> Result<Vec<u8>> {
-    validate_bsdiff_output_len(patch, expected_output_len)?;
+    bsdiff::validate_output_len(patch, expected_output_len)?;
     cancellation_token.check()?;
     puffin::validate_bsdiff_resources(patch, expected_output_len, cancellation_token)?;
     cancellation_token.check()?;
diff --git a/src/lz4.rs b/src/lz4.rs
index a70f6e8..5f60c52 100644
--- a/src/lz4.rs
+++ b/src/lz4.rs
@@ -309,194 +309,33 @@ unsafe extern "C" {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::collections::HashMap;
-    use std::fs::File;
-    use std::sync::OnceLock;
-
-    use zip::ZipArchive;
-
-    static FIXTURES: OnceLock<HashMap<String, Vec<u8>>> = OnceLock::new();
-
-    fn fixture(path: &str) -> Vec<u8> {
-        FIXTURES
-            .get_or_init(|| {
-                let file = File::open("tests/fixtures/corpus/opaque-fixtures.zip").unwrap();
-                let mut archive = ZipArchive::new(file).unwrap();
-                let mut fixtures = HashMap::with_capacity(archive.len());
-                for index in 0..archive.len() {
-                    let mut member = archive.by_index(index).unwrap();
-                    let mut bytes = Vec::new();
-                    std::io::copy(&mut member, &mut bytes).unwrap();
-                    fixtures.insert(member.name().to_string(), bytes);
-                }
-                fixtures
-            })
-            .get(path)
-            .unwrap_or_else(|| panic!("missing fixture in corpus zip: {path}"))
-            .clone()
-    }
-
-    #[test]
-    fn matches_frozen_lz4_reference() {
-        let raw = fixture("lz4/lz4-no-postfix.raw");
-        let expected = fixture("lz4/lz4-no-postfix.lz4");
-
-        let compressed = compress_dest_size(&raw, expected.len(), false).unwrap();
-        assert_eq!(compressed, expected);
-        assert_eq!(decompress_safe_partial(&expected, raw.len()).unwrap(), raw);
-    }
-
-    #[test]
-    fn matches_frozen_lz4hc9_reference() {
-        let raw = fixture("lz4/lz4hc9-no-postfix.raw");
-        let expected = fixture("lz4/lz4hc9-no-postfix.lz4");
-
-        let compressed = compress_hc_dest_size(&raw, expected.len(), 9, false).unwrap();
-        assert_eq!(compressed, expected);
-        assert_eq!(decompress_safe_partial(&expected, raw.len()).unwrap(), raw);
-    }
-
-    #[test]
-    fn matches_frozen_zero_padding_layout() {
-        let raw = fixture("lz4/zero-padding-layout.raw");
-        let expected = fixture("lz4/zero-padding-layout.lz4");
-        let (raw_block, compressed_raw) = raw.split_at(32);
-        let (expected_raw, expected_compressed) = expected.split_at(32);
-
-        assert_eq!(raw_block, expected_raw);
-        let compressed =
-            compress_dest_size(compressed_raw, expected_compressed.len(), true).unwrap();
-        assert_eq!(compressed, expected_compressed);
-
-        let first_byte = compressed.iter().position(|byte| *byte != 0).unwrap();
-        assert_eq!(
-            decompress_safe_partial(&compressed[first_byte..], compressed_raw.len()).unwrap(),
-            compressed_raw
-        );
-    }
 
     #[test]
-    fn round_trip_synthetic_data() {
-        let mut raw = Vec::with_capacity(2048);
-        for i in 0..2048 {
-            raw.push((i % 37) as u8);
-        }
-        let output_size = 512;
-        let compressed = compress_dest_size(&raw, output_size, false).unwrap();
-        assert_eq!(compressed.len(), output_size);
+    fn compress_and_decompress_round_trip() {
+        let raw = (0..2048).map(|i| (i % 37) as u8).collect::<Vec<_>>();
+        let compressed = compress_dest_size(&raw, 512, false).unwrap();
         let decompressed = decompress_safe_partial(&compressed, raw.len()).unwrap();
         assert_eq!(decompressed, raw);
     }
 
     #[test]
-    fn round_trip_hc_levels() {
-        let mut raw = Vec::with_capacity(2048);
-        for i in 0..2048 {
-            raw.push((i % 37) as u8);
-        }
-        let output_size = 512;
-        for level in [HC_LEVEL_MIN, 6, 9, HC_LEVEL_MAX] {
-            let compressed = compress_hc_dest_size(&raw, output_size, level, false).unwrap();
-            assert_eq!(compressed.len(), output_size);
-            let decompressed = decompress_safe_partial(&compressed, raw.len()).unwrap();
-            assert_eq!(decompressed, raw);
-        }
-    }
-
-    #[test]
-    fn rejects_invalid_compression_levels() {
-        let raw = fixture("lz4/lz4-no-postfix.raw");
-        assert_eq!(
-            compress_hc_dest_size(&raw, 512, HC_LEVEL_MIN - 1, false).unwrap_err().status(),
-            Status::InvalidArgument
-        );
-        assert_eq!(
-            compress_hc_dest_size(&raw, 512, HC_LEVEL_MAX + 1, false).unwrap_err().status(),
-            Status::InvalidArgument
-        );
-    }
-
-    #[test]
-    fn rejects_zero_or_oversized_inputs() {
-        let raw = fixture("lz4/lz4-no-postfix.raw");
-        let expected = fixture("lz4/lz4-no-postfix.lz4");
-
-        assert_eq!(
-            compress_dest_size(&[], 512, false).unwrap_err().status(),
-            Status::InvalidArgument
-        );
-        assert_eq!(
-            compress_dest_size(&raw, 0, false).unwrap_err().status(),
-            Status::InvalidArgument
-        );
-        assert_eq!(
-            compress_dest_size(&raw, MAX_INPUT_SIZE + 1, false).unwrap_err().status(),
-            Status::InvalidArgument
-        );
-        assert_eq!(
-            decompress_safe_partial(&[], 512).unwrap_err().status(),
-            Status::InvalidArgument
-        );
-        assert_eq!(
-            decompress_safe_partial(&expected, 0).unwrap_err().status(),
-            Status::InvalidArgument
-        );
-        assert_eq!(
-            decompress_safe_partial(&expected, MAX_INPUT_SIZE + 1).unwrap_err().status(),
-            Status::InvalidArgument
-        );
+    fn zero_padding_round_trip() {
+        let raw = vec![0x5a; 1024];
+        let compressed = compress_dest_size(&raw, 64, true).unwrap();
+        let start = compressed.iter().position(|byte| *byte != 0).unwrap();
+        let decompressed = decompress_safe_partial(&compressed[start..], raw.len()).unwrap();
+        assert_eq!(decompressed, raw);
     }
 
     #[test]
-    fn rejects_stored_not_smaller_than_raw() {
-        let raw = fixture("lz4/lz4-no-postfix.raw");
+    fn invalid_sizes_return_invalid_argument() {
         assert_eq!(
-            compress_dest_size(&raw, raw.len(), false).unwrap_err().status(),
+            compress_dest_size(&[], 32, false).unwrap_err().status(),
             Status::InvalidArgument
         );
         assert_eq!(
-            compress_dest_size(&raw, raw.len() + 10, false).unwrap_err().status(),
+            decompress_safe_partial(&[1, 2, 3], 0).unwrap_err().status(),
             Status::InvalidArgument
         );
-        assert_eq!(
-            decompress_safe_partial(&raw, raw.len() / 2).unwrap_err().status(),
-            Status::InvalidArgument
-        );
-    }
-
-    #[test]
-    fn fails_on_corrupted_decompression_input() {
-        let raw = fixture("lz4/lz4-no-postfix.raw");
-        let expected = fixture("lz4/lz4-no-postfix.lz4");
-        let mut corrupted = expected.clone();
-        corrupted[0] = 0xff;
-        corrupted[1] = 0xff;
-        assert_eq!(
-            decompress_safe_partial(&corrupted, raw.len()).unwrap_err().status(),
-            Status::DecompressionFailed
-        );
-    }
-
-    #[test]
-    fn fails_on_decompression_size_mismatch() {
-        let raw = fixture("lz4/lz4-no-postfix.raw");
-        let expected = fixture("lz4/lz4-no-postfix.lz4");
-        let compressed_end = expected.iter().rposition(|byte| *byte != 0).map_or(0, |i| i + 1);
-        assert_eq!(
-            decompress_safe_partial(&expected[..compressed_end], raw.len() + 256)
-                .unwrap_err()
-                .status(),
-            Status::DecompressionFailed
-        );
-    }
-
-    #[test]
-    fn fails_when_output_budget_too_small() {
-        let raw = fixture("lz4/lz4-no-postfix.raw");
-        let error = compress_dest_size(&raw, 16, false).unwrap_err();
-        assert!(
-            error.status() == Status::CompressionDivergence
-                || error.status() == Status::CompressionFailed
-        );
     }
 }
diff --git a/src/lz4diff.rs b/src/lz4diff.rs
index 54caea0..754ce3f 100644
--- a/src/lz4diff.rs
+++ b/src/lz4diff.rs
@@ -5,9 +5,7 @@ use anyhow::{Context as _, Result, bail, ensure};
 use prost::Message as _;
 use ring::digest;
 
-use crate::{
-    CancellationToken, is_cancellation, lz4, puffin, validate_bsdiff_output_len, zucchini,
-};
+use crate::{CancellationToken, bsdiff, is_cancellation, lz4, puffin, zucchini};
 
 const MAGIC: &[u8; 7] = b"LZ4DIFF";
 const FRAMING_SIZE: usize = 16;
@@ -477,7 +475,7 @@ fn validate_info<'a>(
                     "LZ4DIFF destination block {index} postfix patch requires a SHA-256 hash"
                 );
                 ensure_below_bound(postfix_bspatch.len(), "postfix patch")?;
-                validate_bsdiff_output_len(postfix_bspatch, compressed_length)
+                bsdiff::validate_output_len(postfix_bspatch, compressed_length)
                     .with_context(|| format!("LZ4DIFF destination block {index} postfix patch"))?;
                 puffin::validate_bsdiff_resources(
                     postfix_bspatch,
diff --git a/src/puffin/patch.rs b/src/puffin/patch.rs
index ef51767..6dcb311 100644
--- a/src/puffin/patch.rs
+++ b/src/puffin/patch.rs
@@ -401,6 +401,8 @@ fn validate_inner_bsdiff_resources(
     output_size: usize,
     cancellation_token: &CancellationToken,
 ) -> Result<()> {
+    crate::bsdiff::validate_output_len(patch, output_size)
+        .map_err(|error| Error::Bsdiff(error.to_string()))?;
     let header = patch
         .get(..32)
         .ok_or_else(|| Error::Bsdiff("patch data is shorter than 32 bytes".into()))?;
@@ -446,6 +448,14 @@ fn validate_inner_bsdiff_resources(
     Ok(())
 }
 
+fn map_cancelled_to_zucchini(error: anyhow::Error) -> Error {
+    if is_cancellation(error.as_ref()) {
+        Error::Cancelled(ExtractionCancelled)
+    } else {
+        Error::Zucchini(error.to_string())
+    }
+}
+
 pub(crate) fn validate_bsdiff_resources(
     patch: &[u8],
     output_size: usize,
@@ -511,14 +521,8 @@ pub fn apply(
             }
         })?
     } else {
-        let zucchini_patch =
-            decode_zucchini_patch(raw_patch, cancellation_token).map_err(|error| {
-                if is_cancellation(error.as_ref()) {
-                    Error::Cancelled(ExtractionCancelled)
-                } else {
-                    Error::Zucchini(error.to_string())
-                }
-            })?;
+        let zucchini_patch = decode_zucchini_patch(raw_patch, cancellation_token)
+            .map_err(map_cancelled_to_zucchini)?;
         check_cancelled(cancellation_token)?;
         let destination =
             zucchini::apply(&puffed_source, &zucchini_patch, header.destination.puff_length)
diff --git a/tests/delta_extraction.rs b/tests/delta_extraction.rs
index 8604b61..83dcbd6 100644
--- a/tests/delta_extraction.rs
+++ b/tests/delta_extraction.rs
@@ -1,16 +1,11 @@
 use std::fs;
-#[cfg(otadump_zucchini)]
-use std::io::Write;
-use std::path::Path;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::path::{Path, PathBuf};
 
-use otadump::{CancellationToken, ExtractOptions, ProgressReporter, is_cancellation};
+use otadump::ExtractOptions;
 use prost::Message;
 use ring::digest;
 use tempfile::TempDir;
 
-mod fixture_corpus;
-
 #[derive(Clone, PartialEq, Message)]
 struct Extent {
     #[prost(uint64, optional, tag = "1")]
@@ -59,20 +54,6 @@ struct PartitionUpdate {
     new_partition_info: Option<PartitionInfo>,
     #[prost(message, repeated, tag = "8")]
     operations: Vec<InstallOperation>,
-    #[prost(message, optional, tag = "10")]
-    hash_tree_data_extent: Option<Extent>,
-    #[prost(message, optional, tag = "11")]
-    hash_tree_extent: Option<Extent>,
-    #[prost(string, optional, tag = "12")]
-    hash_tree_algorithm: Option<String>,
-    #[prost(bytes = "vec", optional, tag = "13")]
-    hash_tree_salt: Option<Vec<u8>>,
-    #[prost(message, optional, tag = "14")]
-    fec_data_extent: Option<Extent>,
-    #[prost(message, optional, tag = "15")]
-    fec_extent: Option<Extent>,
-    #[prost(uint32, optional, tag = "16")]
-    fec_roots: Option<u32>,
 }
 
 #[derive(Clone, PartialEq, Message)]
@@ -85,1982 +66,179 @@ struct DeltaArchiveManifest {
     partitions: Vec<PartitionUpdate>,
 }
 
-#[derive(Clone, Copy, PartialEq, Message)]
-struct Lz4diffAlgorithm {
-    #[prost(int32, tag = "1")]
-    algorithm_type: i32,
-    #[prost(int32, tag = "2")]
-    level: i32,
-}
-
-#[derive(Clone, PartialEq, Message)]
-struct Lz4diffBlock {
-    #[prost(uint64, tag = "1")]
-    uncompressed_offset: u64,
-    #[prost(uint64, tag = "2")]
-    uncompressed_length: u64,
-    #[prost(uint64, tag = "3")]
-    compressed_length: u64,
-    #[prost(bytes = "vec", tag = "4")]
-    sha256_hash: Vec<u8>,
-    #[prost(bytes = "vec", tag = "5")]
-    postfix_bspatch: Vec<u8>,
-}
-
-#[derive(Clone, PartialEq, Message)]
-struct Lz4diffCompressionInfo {
-    #[prost(message, optional, tag = "1")]
-    algo: Option<Lz4diffAlgorithm>,
-    #[prost(message, repeated, tag = "2")]
-    block_info: Vec<Lz4diffBlock>,
-    #[prost(bool, tag = "3")]
-    zero_padding_enabled: bool,
-}
-
-#[derive(Clone, PartialEq, Message)]
-struct Lz4diffHeader {
-    #[prost(message, optional, tag = "1")]
-    src_info: Option<Lz4diffCompressionInfo>,
-    #[prost(message, optional, tag = "2")]
-    dst_info: Option<Lz4diffCompressionInfo>,
-    #[prost(int32, tag = "3")]
-    inner_type: i32,
-}
-
 fn sha256(bytes: &[u8]) -> Vec<u8> {
     digest::digest(&digest::SHA256, bytes).as_ref().to_vec()
 }
 
-// Hand-authored BSDIFF40 and BSDF2 fixtures. The test data is covered by this
-// project's MIT license and was not generated by the patch implementation.
-const BSDIFF40_PATCH: &[u8] = &[
-    66, 83, 68, 73, 70, 70, 52, 48, 41, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0,
-    0, 0, 0, 0, 66, 90, 104, 57, 49, 65, 89, 38, 83, 89, 184, 173, 85, 59, 0, 0, 2, 96, 0, 64, 64,
-    8, 0, 32, 0, 48, 204, 12, 245, 5, 206, 46, 228, 138, 112, 161, 33, 113, 90, 170, 118, 66, 90,
-    104, 57, 49, 65, 89, 38, 83, 89, 168, 46, 248, 254, 0, 0, 2, 192, 0, 192, 0, 2, 0, 32, 0, 48,
-    128, 103, 161, 185, 11, 185, 34, 156, 40, 72, 84, 23, 124, 127, 0, 66, 90, 104, 57, 23, 114,
-    69, 56, 80, 144, 0, 0, 0, 0,
-];
-const BROTLI_BSDF2_PATCH: &[u8] = &[
-    66, 83, 68, 70, 50, 2, 2, 2, 12, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0,
-    0, 0, 0, 31, 23, 0, 248, 167, 0, 16, 98, 141, 0, 160, 0, 143, 3, 128, 0, 0, 245, 245, 0, 0, 0,
-    0, 3, 63,
-];
-const BROTLI_INVALID_HEADER_PATCH: &[u8] = &[
-    66, 83, 68, 70, 50, 2, 2, 2, 12, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0,
-    0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-];
-
-#[cfg(otadump_zucchini)]
-fn brotli_compress(bytes: &[u8]) -> Vec<u8> {
-    let mut compressed = Vec::new();
-    {
-        let mut writer = brotli::CompressorWriter::new(&mut compressed, 4096, 9, 20);
-        writer.write_all(bytes).unwrap();
-    }
-    compressed
+fn extent(start_block: u64, num_blocks: u64) -> Extent {
+    Extent { start_block: Some(start_block), num_blocks: Some(num_blocks) }
 }
 
-#[cfg(otadump_zucchini)]
-fn zucchini_brotli_patch(name: &str) -> Vec<u8> {
-    let patch = fixture_corpus::read(&format!("zucchini/{name}.zuc"));
-    brotli_compress(&patch)
+fn partition_info(bytes: &[u8]) -> PartitionInfo {
+    PartitionInfo { size: Some(bytes.len() as u64), hash: Some(sha256(bytes)) }
 }
 
-#[cfg(otadump_zucchini)]
-fn malformed_brotli_stream() -> Vec<u8> {
-    b"not a Brotli stream\n".to_vec()
+fn write_payload(path: &Path, manifest: DeltaArchiveManifest, data: &[u8]) {
+    let manifest = manifest.encode_to_vec();
+    let mut payload = Vec::with_capacity(24 + manifest.len() + data.len());
+    payload.extend_from_slice(b"CrAU");
+    payload.extend_from_slice(&2u64.to_be_bytes());
+    payload.extend_from_slice(&(manifest.len() as u64).to_be_bytes());
+    payload.extend_from_slice(&0u32.to_be_bytes());
+    payload.extend_from_slice(&manifest);
+    payload.extend_from_slice(data);
+    fs::write(path, payload).unwrap();
 }
 
-#[cfg(otadump_zucchini)]
-fn malformed_inner_zucchini_patch() -> Vec<u8> {
-    brotli_compress(b"not a zucchini patch")
+fn puffin_fixture(name: &str) -> Vec<u8> {
+    let path = PathBuf::from("tests/fixtures/puffin").join(name);
+    fs::read(path).unwrap()
 }
 
-#[cfg(otadump_zucchini)]
-fn truncated_zucchini_patch(name: &str) -> Vec<u8> {
-    let mut patch = zucchini_brotli_patch(name);
-    patch.truncate(patch.len() - 1);
-    patch
-}
+#[test]
+fn full_replace_payload_extracts_expected_partition() {
+    let temporary = TempDir::new().unwrap();
+    let output_dir = temporary.path().join("output");
+    let expected = b"full payload data";
+    let operation = InstallOperation {
+        operation_type: 0,
+        data_offset: Some(0),
+        data_length: Some(expected.len() as u64),
+        dst_extents: vec![extent(0, 2)],
+        data_sha256_hash: Some(sha256(expected)),
+        ..Default::default()
+    };
+    let mut padded = expected.to_vec();
+    padded.resize(32, 0);
+    let manifest = DeltaArchiveManifest {
+        block_size: Some(16),
+        minor_version: Some(0),
+        partitions: vec![PartitionUpdate {
+            partition_name: "vendor".into(),
+            old_partition_info: None,
+            new_partition_info: Some(partition_info(&padded)),
+            operations: vec![operation],
+        }],
+    };
+    let payload = temporary.path().join("payload.bin");
+    write_payload(&payload, manifest, expected);
 
-fn lz4_reference(name: &str) -> Vec<u8> {
-    fixture_corpus::read(&format!("lz4/{name}"))
-}
+    ExtractOptions::new().extract(&payload, &output_dir).unwrap();
 
-fn lz4diff_fixture_case(name: &str) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
-    let patch = fixture_corpus::read(&format!("lz4diff/{name}/patch.lz4diff"));
-    let (source, target) = match name {
-        "lz4-bsdiff" => {
-            let block = lz4_reference("lz4-no-postfix.lz4");
-            (block.clone(), block)
-        }
-        "lz4hc9-bsdiff" => {
-            let block = lz4_reference("lz4hc9-no-postfix.lz4");
-            (block.clone(), block)
-        }
-        "zero-padding-bsdiff" => {
-            let block = lz4_reference("zero-padding-layout.lz4");
-            (block.clone(), block)
-        }
-        "postfix-bsdiff" => {
-            let source = lz4_reference("lz4-no-postfix.lz4");
-            let mut target = source.clone();
-            target[23] ^= 0x5a;
-            (source, target)
-        }
-        "raw-puffdiff" => (
-            fixture_corpus::read("lz4diff/raw-puffdiff/source.bin"),
-            fixture_corpus::read("lz4diff/raw-puffdiff/target.bin"),
-        ),
-        _ => panic!("unknown LZ4DIFF fixture {name}"),
-    };
-    (source, target, patch)
+    assert_eq!(fs::read(output_dir.join("vendor.img")).unwrap(), padded);
 }
 
-fn run_lz4diff_bytes(
-    source: &[u8],
-    target: &[u8],
-    patch: &[u8],
-    operation_type: i32,
-) -> Result<Vec<u8>, String> {
+#[test]
+fn source_copy_keeps_source_immutable_and_respects_extent_order() {
     let temporary = TempDir::new().unwrap();
     let source_dir = temporary.path().join("source");
     let output_dir = temporary.path().join("output");
     fs::create_dir(&source_dir).unwrap();
+    let source = b"AAAABBBBCCCCDDDD";
     fs::write(source_dir.join("system.img"), source).unwrap();
-
+    let expected = b"AAAACCCC";
+    let operation = InstallOperation {
+        operation_type: 4,
+        src_extents: vec![extent(2, 1), extent(0, 1)],
+        src_length: Some(8),
+        dst_extents: vec![extent(1, 1), extent(0, 1)],
+        dst_length: Some(8),
+        src_sha256_hash: Some(sha256(b"CCCCAAAA")),
+        ..Default::default()
+    };
     let manifest = DeltaArchiveManifest {
-        block_size: Some(1),
-        minor_version: Some(9),
+        block_size: Some(4),
+        minor_version: Some(2),
         partitions: vec![PartitionUpdate {
             partition_name: "system".into(),
             old_partition_info: Some(partition_info(source)),
-            new_partition_info: Some(partition_info(target)),
-            operations: vec![InstallOperation {
-                operation_type,
-                data_offset: Some(0),
-                data_length: Some(patch.len() as u64),
-                src_extents: vec![extent(0, source.len() as u64)],
-                src_length: Some(source.len() as u64),
-                dst_extents: vec![extent(0, target.len() as u64)],
-                dst_length: Some(target.len() as u64),
-                data_sha256_hash: Some(sha256(patch)),
-                src_sha256_hash: Some(sha256(source)),
-            }],
-            ..Default::default()
+            new_partition_info: Some(partition_info(expected)),
+            operations: vec![operation],
         }],
     };
     let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, patch);
-
-    match ExtractOptions::new().source_dir(&source_dir).extract(&payload, &output_dir) {
-        Ok(()) => {
-            assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-            assert_eq!(fs::read_dir(&output_dir).unwrap().count(), 1);
-            Ok(fs::read(output_dir.join("system.img")).unwrap())
-        }
-        Err(error) => {
-            assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-            assert!(!output_dir.join("system.img").exists());
-            assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
-            Err(error.to_string())
-        }
-    }
-}
-
-fn run_lz4diff_extraction(name: &str, operation_type: i32) -> Result<Vec<u8>, String> {
-    let (source, target, patch) = lz4diff_fixture_case(name);
-    run_lz4diff_bytes(&source, &target, &patch, operation_type)
-}
+    write_payload(&payload, manifest, &[]);
 
-fn rewrite_lz4diff_header(patch: &[u8], change: impl FnOnce(&mut Lz4diffHeader)) -> Vec<u8> {
-    let header_size = u32::from_be_bytes(patch[11..15].try_into().unwrap()) as usize;
-    let mut header = Lz4diffHeader::decode(&patch[16..16 + header_size]).unwrap();
-    change(&mut header);
-    let header = header.encode_to_vec();
-    let mut changed = Vec::with_capacity(16 + header.len() + patch.len() - 16 - header_size);
-    changed.extend_from_slice(b"LZ4DIFF");
-    changed.extend_from_slice(&1u32.to_be_bytes());
-    changed.extend_from_slice(&(header.len() as u32).to_be_bytes());
-    changed.push(0);
-    changed.extend_from_slice(&header);
-    changed.extend_from_slice(&patch[16 + header_size..]);
-    changed
-}
+    ExtractOptions::new().source_dir(&source_dir).extract(&payload, &output_dir).unwrap();
 
-#[test]
-fn lz4diff_operations_reconstruct_frozen_targets() {
-    for (name, operation_type) in [
-        ("lz4-bsdiff", 12),
-        ("lz4hc9-bsdiff", 12),
-        ("zero-padding-bsdiff", 12),
-        ("postfix-bsdiff", 12),
-        ("raw-puffdiff", 13),
-    ] {
-        let (_, expected, _) = lz4diff_fixture_case(name);
-        let output = run_lz4diff_extraction(name, operation_type).unwrap();
-        assert_eq!(output, expected, "fixture {name}");
-    }
+    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), expected);
+    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
 }
 
 #[test]
-fn malformed_lz4diff_data_fails_without_publication_or_process_failure() {
-    let (source, target, valid) = lz4diff_fixture_case("postfix-bsdiff");
-
-    let mut bad_magic = valid.clone();
-    bad_magic[0] = b'X';
-    let mut bad_version = valid.clone();
-    bad_version[7..11].copy_from_slice(&2u32.to_be_bytes());
-    let mut bad_padding = valid.clone();
-    bad_padding[15] = 1;
-    let mut overrun = valid.clone();
-    overrun[11..15].copy_from_slice(&u32::MAX.to_be_bytes());
-    let malformed_proto =
-        [b"LZ4DIFF".as_slice(), &1u32.to_be_bytes(), &1u32.to_be_bytes(), &[0, 0x80]].concat();
-    let mut nested_header = vec![0x23; 101];
-    nested_header.extend(std::iter::repeat_n(0x24, 101));
-    let mut excessive_nesting = Vec::new();
-    excessive_nesting.extend_from_slice(b"LZ4DIFF");
-    excessive_nesting.extend_from_slice(&1u32.to_be_bytes());
-    excessive_nesting.extend_from_slice(&(nested_header.len() as u32).to_be_bytes());
-    excessive_nesting.push(0);
-    excessive_nesting.extend_from_slice(&nested_header);
-    excessive_nesting.push(0);
-    let unknown_algorithm = rewrite_lz4diff_header(&valid, |header| {
-        header.dst_info.as_mut().unwrap().algo.as_mut().unwrap().algorithm_type = 99;
-    });
-    let missing_algorithm = rewrite_lz4diff_header(&valid, |header| {
-        header.src_info.as_mut().unwrap().algo = None;
-    });
-    let bad_hc_level = rewrite_lz4diff_header(&valid, |header| {
-        let algo = header.dst_info.as_mut().unwrap().algo.as_mut().unwrap();
-        algo.algorithm_type = 2;
-        algo.level = 13;
-    });
-    let unknown_inner = rewrite_lz4diff_header(&valid, |header| header.inner_type = 7);
-    let unsorted = rewrite_lz4diff_header(&valid, |header| {
-        header.src_info.as_mut().unwrap().block_info[0].uncompressed_offset = 1;
-    });
-    let out_of_bound = rewrite_lz4diff_header(&valid, |header| {
-        header.src_info.as_mut().unwrap().block_info[0].uncompressed_length = u64::MAX;
-    });
-    let invalid_physical = rewrite_lz4diff_header(&valid, |header| {
-        let block = &mut header.src_info.as_mut().unwrap().block_info[0];
-        block.compressed_length = block.uncompressed_length + 1;
-    });
-    let short_hash = rewrite_lz4diff_header(&valid, |header| {
-        header.dst_info.as_mut().unwrap().block_info[0].sha256_hash.pop();
-    });
-    let wrong_hash = rewrite_lz4diff_header(&valid, |header| {
-        header.dst_info.as_mut().unwrap().block_info[0].sha256_hash[0] ^= 1;
-    });
-    let missing_postfix_hash = rewrite_lz4diff_header(&valid, |header| {
-        header.dst_info.as_mut().unwrap().block_info[0].sha256_hash.clear();
-    });
-    let malformed_postfix = rewrite_lz4diff_header(&valid, |header| {
-        header.dst_info.as_mut().unwrap().block_info[0].postfix_bspatch[0] = b'X';
-    });
-    let source_only_metadata = rewrite_lz4diff_header(&valid, |header| {
-        header.src_info.as_mut().unwrap().block_info[0].sha256_hash = vec![0; 32];
-    });
-
-    for (patch, expected_error) in [
-        (bad_magic, "invalid LZ4DIFF magic"),
-        (bad_version, "unsupported LZ4DIFF version"),
-        (bad_padding, "framing padding byte is not zero"),
-        (overrun, "protobuf header exceeds the maximum size"),
-        (malformed_proto, "truncated LZ4DIFF protobuf varint"),
-        (excessive_nesting, "protobuf recursion limit exceeded"),
-        (unknown_algorithm, "unknown LZ4DIFF destination compression algorithm"),
-        (missing_algorithm, "LZ4DIFF source algorithm is missing"),
-        (bad_hc_level, "LZ4HC level must be"),
-        (unknown_inner, "unknown LZ4DIFF inner patch type"),
-        (unsorted, "source blocks are not contiguous"),
-        (out_of_bound, "source uncompressed stream exceeds"),
-        (invalid_physical, "physical length exceeds its raw length"),
-        (short_hash, "SHA-256 hash must be empty or 32 bytes"),
-        (wrong_hash, "reference recompression hash mismatch"),
-        (missing_postfix_hash, "postfix patch requires a SHA-256 hash"),
-        (malformed_postfix, "postfix patch"),
-        (source_only_metadata, "contains destination-only metadata"),
-    ] {
-        let error = run_lz4diff_bytes(&source, &target, &patch, 12).unwrap_err();
-        assert!(error.contains(expected_error), "unexpected error: {error}");
-    }
-
-    let mismatched_inner = rewrite_lz4diff_header(&valid, |header| header.inner_type = 1);
-    let error = run_lz4diff_bytes(&source, &target, &mismatched_inner, 12).unwrap_err();
-    assert!(error.contains("operation type does not match"), "unexpected error: {error}");
-}
-
-fn run_puffdiff_extraction(source: &[u8], target: &[u8], patch: &[u8]) -> Result<Vec<u8>, String> {
+fn missing_source_image_fails_without_publishing_output() {
     let temporary = TempDir::new().unwrap();
     let source_dir = temporary.path().join("source");
     let output_dir = temporary.path().join("output");
     fs::create_dir(&source_dir).unwrap();
-
-    let source_split = source.len() / 2;
-    let mut source_partition = Vec::with_capacity(source.len() + 1);
-    source_partition.extend_from_slice(&source[..source_split]);
-    source_partition.push(0xa5);
-    source_partition.extend_from_slice(&source[source_split..]);
-    fs::write(source_dir.join("system.img"), &source_partition).unwrap();
-
-    let target_split = target.len() / 2;
+    let operation = InstallOperation {
+        operation_type: 4,
+        src_extents: vec![extent(0, 1)],
+        dst_extents: vec![extent(0, 1)],
+        ..Default::default()
+    };
     let manifest = DeltaArchiveManifest {
-        block_size: Some(1),
-        minor_version: Some(5),
+        block_size: Some(4),
+        minor_version: Some(2),
         partitions: vec![PartitionUpdate {
-            partition_name: "system".into(),
-            old_partition_info: Some(partition_info(&source_partition)),
-            new_partition_info: Some(partition_info(target)),
-            operations: vec![InstallOperation {
-                operation_type: 9,
-                data_offset: Some(0),
-                data_length: Some(patch.len() as u64),
-                src_extents: vec![
-                    extent(0, source_split as u64),
-                    extent((source_split + 1) as u64, (source.len() - source_split) as u64),
-                ],
-                src_length: Some(source.len() as u64),
-                dst_extents: vec![
-                    extent(0, target_split as u64),
-                    extent(target_split as u64, (target.len() - target_split) as u64),
-                ],
-                dst_length: Some(target.len() as u64),
-                data_sha256_hash: Some(sha256(patch)),
-                src_sha256_hash: Some(sha256(source)),
-            }],
-            ..Default::default()
+            partition_name: "boot".into(),
+            old_partition_info: Some(partition_info(b"base")),
+            new_partition_info: Some(partition_info(b"base")),
+            operations: vec![operation],
         }],
     };
     let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, patch);
+    write_payload(&payload, manifest, &[]);
 
-    match ExtractOptions::new()
+    let error = ExtractOptions::new()
         .source_dir(&source_dir)
-        .num_threads(2)
         .extract(&payload, &output_dir)
-    {
-        Ok(()) => {
-            assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source_partition);
-            assert_eq!(fs::read_dir(&output_dir).unwrap().count(), 1);
-            Ok(fs::read(output_dir.join("system.img")).unwrap())
-        }
-        Err(error) => {
-            assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source_partition);
-            assert!(!output_dir.join("system.img").exists());
-            assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
-            Err(error.to_string())
-        }
-    }
-}
-
-fn puffin_fixture(name: &str) -> Vec<u8> {
-    fixture_corpus::read(&format!("puffin/{name}"))
-}
-
-fn with_puffin_patch_type(patch: &[u8], patch_type: u8) -> Vec<u8> {
-    let header_len = u32::from_be_bytes(patch[4..8].try_into().unwrap()) as usize;
-    let mut changed = Vec::with_capacity(patch.len() + 2);
-    changed.extend_from_slice(&patch[..8 + header_len]);
-    changed.extend_from_slice(&[0x20, patch_type]);
-    changed.extend_from_slice(&patch[8 + header_len..]);
-    changed[4..8].copy_from_slice(&((header_len + 2) as u32).to_be_bytes());
-    changed
-}
-
-fn with_puffin_inner_patch(patch: &[u8], inner_patch: &[u8]) -> Vec<u8> {
-    let header_len = u32::from_be_bytes(patch[4..8].try_into().unwrap()) as usize;
-    let mut changed = Vec::with_capacity(8 + header_len + inner_patch.len());
-    changed.extend_from_slice(&patch[..8 + header_len]);
-    changed.extend_from_slice(inner_patch);
-    changed
-}
+        .unwrap_err()
+        .to_string();
 
-#[test]
-fn puffdiff_bsdiff_reconstructs_pinned_puffin_goldens() {
-    let source = puffin_fixture("deflates-sample1.bin");
-    for (patch_name, target_name) in [
-        ("patch-1-to-2.puf", "deflates-sample2.bin"),
-        ("patch-1-to-raw.puf", "raw-11-22-33-44.bin"),
-    ] {
-        let patch = puffin_fixture(patch_name);
-        let target = puffin_fixture(target_name);
-        let output = run_puffdiff_extraction(&source, &target, &patch).unwrap();
-        assert_eq!(output, target);
-    }
+    assert!(error.contains("Unable to open source partition image"), "unexpected error: {error}");
+    assert!(!output_dir.join("boot.img").exists());
+    assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
 }
 
-#[test]
 #[cfg(otadump_zucchini)]
-fn puffdiff_zucchini_reconstructs_pinned_puffin_golden() {
-    let source = puffin_fixture("deflates-sample1.bin");
-    let target = puffin_fixture("deflates-sample2.bin");
-    let patch = puffin_fixture("patch-1-to-2-zucchini.puf");
-
-    let output = run_puffdiff_extraction(&source, &target, &patch).unwrap();
-
-    assert_eq!(output, target);
-}
-
-#[test]
-fn malformed_puffdiff_data_fails_without_publication_or_process_failure() {
-    let source = puffin_fixture("deflates-sample1.bin");
-    let target = puffin_fixture("deflates-sample2.bin");
-    let valid_patch = puffin_fixture("patch-1-to-2.puf");
-
-    let mut bad_magic = valid_patch.clone();
-    bad_magic[..4].copy_from_slice(b"BAD!");
-
-    let truncated_proto = [b"PUF1".as_slice(), &1u32.to_be_bytes(), &[0x80]].concat();
-
-    let mut non_byte_puff = valid_patch.clone();
-    let puff_length = non_byte_puff
-        .windows(6)
-        .position(|window| window == [0x12, 0x04, 0x08, 0x10, 0x10, 0x58])
-        .unwrap()
-        + 5;
-    non_byte_puff[puff_length] += 1;
-
-    let mut overlapping_deflates = valid_patch.clone();
-    let second_deflate_offset = overlapping_deflates
-        .windows(6)
-        .position(|window| window == [0x0a, 0x04, 0x08, 0x50, 0x10, 0x0a])
-        .unwrap()
-        + 3;
-    overlapping_deflates[second_deflate_offset] = 0x40;
-
-    let mut bad_inner_bsdiff = valid_patch.clone();
-    let header_len = u32::from_be_bytes(bad_inner_bsdiff[4..8].try_into().unwrap()) as usize;
-    bad_inner_bsdiff[8 + header_len] = b'X';
-
-    for (patch, expected_error) in [
-        (bad_magic, "missing PUF1 magic"),
-        (truncated_proto, "truncated protobuf varint"),
-        (non_byte_puff, "puff extent is not byte-aligned"),
-        (overlapping_deflates, "deflate extents overlap or are unsorted"),
-        (bad_inner_bsdiff, "inner BSDIFF patch is invalid"),
-        (with_puffin_patch_type(&valid_patch, 2), "unsupported PUFFDIFF patch type 2"),
-    ] {
-        let error = run_puffdiff_extraction(&source, &target, &patch).unwrap_err();
-        assert!(error.contains(expected_error), "unexpected error: {error}");
-    }
-
-    let short_target = &target[..target.len() - 1];
-    let error = run_puffdiff_extraction(&source, short_target, &valid_patch).unwrap_err();
-    assert!(error.contains("destination raw size mismatch"), "unexpected error: {error}");
-}
-
 #[test]
-#[cfg(otadump_zucchini)]
-fn malformed_puffdiff_zucchini_fails_without_publication_or_process_failure() {
+fn puffdiff_zucchini_golden_reconstructs_and_keeps_source() {
     let source = puffin_fixture("deflates-sample1.bin");
     let target = puffin_fixture("deflates-sample2.bin");
-    let valid_patch = puffin_fixture("patch-1-to-2-zucchini.puf");
-    let malformed_zucchini = malformed_inner_zucchini_patch();
-
-    for (patch, expected_error) in [
-        (
-            with_puffin_inner_patch(&valid_patch, b"not a Brotli stream\n"),
-            "Unable to decode ZUCCHINI Brotli patch",
-        ),
-        (
-            with_puffin_inner_patch(&valid_patch, &malformed_zucchini),
-            "inner ZUCCHINI patch is invalid: apply failed: invalid ensemble patch",
-        ),
-    ] {
-        let error = run_puffdiff_extraction(&source, &target, &patch).unwrap_err();
-        assert!(error.contains(expected_error), "unexpected error: {error}");
-    }
-}
-
-#[cfg(otadump_zucchini)]
-fn assert_zucchini_fixture(name: &str, extension: &str) {
-    let old = fixture_corpus::read(&format!("zucchini/{name}-old{extension}"));
-    let expected = fixture_corpus::read(&format!("zucchini/{name}-new{extension}"));
-    let patch = fixture_corpus::read(&format!("zucchini/{name}.zuc"));
-    let output = otadump::zucchini::apply(&old, &patch, expected.len()).unwrap();
-    assert_eq!(output, expected);
-}
+    let patch = puffin_fixture("patch-1-to-2-zucchini.puf");
 
-#[cfg(otadump_zucchini)]
-fn assert_zucchini_extraction(name: &str, extension: &str) {
-    let old = fixture_corpus::read(&format!("zucchini/{name}-old{extension}"));
-    let target = fixture_corpus::read(&format!("zucchini/{name}-new{extension}"));
-    let patch = zucchini_brotli_patch(name);
     let temporary = TempDir::new().unwrap();
     let source_dir = temporary.path().join("source");
     let output_dir = temporary.path().join("output");
     fs::create_dir(&source_dir).unwrap();
-
-    let old_split = old.len() / 2;
-    let mut source = Vec::with_capacity(old.len() + 1);
-    source.extend_from_slice(&old[..old_split]);
-    source.push(0xa5);
-    source.extend_from_slice(&old[old_split..]);
     fs::write(source_dir.join("system.img"), &source).unwrap();
 
-    let target_split = target.len() / 2;
-    let mut expected = Vec::with_capacity(target.len() + 1);
-    expected.extend_from_slice(&target[..target_split]);
-    expected.push(0);
-    expected.extend_from_slice(&target[target_split..]);
     let manifest = DeltaArchiveManifest {
         block_size: Some(1),
-        minor_version: Some(8),
+        minor_version: Some(5),
         partitions: vec![PartitionUpdate {
             partition_name: "system".into(),
             old_partition_info: Some(partition_info(&source)),
-            new_partition_info: Some(partition_info(&expected)),
+            new_partition_info: Some(partition_info(&target)),
             operations: vec![InstallOperation {
-                operation_type: 11,
+                operation_type: 9,
                 data_offset: Some(0),
                 data_length: Some(patch.len() as u64),
-                src_extents: vec![
-                    extent(0, old_split as u64),
-                    extent((old_split + 1) as u64, (old.len() - old_split) as u64),
-                ],
-                src_length: Some(old.len() as u64),
-                dst_extents: vec![
-                    extent(0, target_split as u64),
-                    extent((target_split + 1) as u64, (target.len() - target_split) as u64),
-                ],
+                src_extents: vec![extent(0, source.len() as u64)],
+                src_length: Some(source.len() as u64),
+                dst_extents: vec![extent(0, target.len() as u64)],
                 dst_length: Some(target.len() as u64),
                 data_sha256_hash: Some(sha256(&patch)),
-                src_sha256_hash: Some(sha256(&old)),
+                src_sha256_hash: Some(sha256(&source)),
             }],
-            ..Default::default()
         }],
     };
     let payload = temporary.path().join("payload.bin");
     write_payload(&payload, manifest, &patch);
 
-    ExtractOptions::new()
-        .source_dir(&source_dir)
-        .num_threads(2)
-        .extract(&payload, &output_dir)
-        .unwrap();
-
-    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), expected);
-    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-    assert_eq!(fs::read_dir(&output_dir).unwrap().count(), 1);
-}
-
-#[cfg(otadump_zucchini)]
-fn assert_zucchini_extraction_fails(patch: &[u8], expected_error: &str) {
-    let temporary = TempDir::new().unwrap();
-    let source_dir = temporary.path().join("source");
-    let output_dir = temporary.path().join("output");
-    fs::create_dir(&source_dir).unwrap();
-    let source = b"abcd";
-    fs::write(source_dir.join("system.img"), source).unwrap();
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(1),
-        minor_version: Some(8),
-        partitions: vec![PartitionUpdate {
-            partition_name: "system".into(),
-            old_partition_info: Some(partition_info(source)),
-            new_partition_info: Some(partition_info(source)),
-            operations: vec![InstallOperation {
-                operation_type: 11,
-                data_offset: Some(0),
-                data_length: Some(patch.len() as u64),
-                src_extents: vec![extent(0, source.len() as u64)],
-                src_length: Some(source.len() as u64),
-                dst_extents: vec![extent(0, source.len() as u64)],
-                dst_length: Some(source.len() as u64),
-                data_sha256_hash: Some(sha256(patch)),
-                src_sha256_hash: Some(sha256(source)),
-            }],
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, patch);
-
-    let error = ExtractOptions::new()
-        .source_dir(&source_dir)
-        .num_threads(2)
-        .extract(&payload, &output_dir)
-        .unwrap_err()
-        .to_string();
+    ExtractOptions::new().source_dir(&source_dir).extract(&payload, &output_dir).unwrap();
 
-    assert!(error.contains(expected_error), "unexpected error: {error}");
+    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), target);
     assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-    assert!(!output_dir.join("system.img").exists());
-    assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
-}
-
-#[test]
-#[cfg(otadump_zucchini)]
-fn zucchini_wrapper_applies_android_formats_exactly() {
-    assert_zucchini_fixture("noop", ".bin");
-    assert_zucchini_fixture("dex", ".dex");
-    assert_zucchini_fixture("elf-x86", "");
-    assert_zucchini_fixture("elf", "");
-    assert_zucchini_fixture("elf-arm32", "");
-    assert_zucchini_fixture("elf-arm64", "");
-}
-
-#[test]
-#[cfg(otadump_zucchini)]
-fn zucchini_operations_reconstruct_android_formats_exactly() {
-    for (name, extension) in [
-        ("noop", ".bin"),
-        ("dex", ".dex"),
-        ("elf-x86", ""),
-        ("elf", ""),
-        ("elf-arm32", ""),
-        ("elf-arm64", ""),
-    ] {
-        assert_zucchini_extraction(name, extension);
-    }
-}
-
-#[test]
-#[cfg(otadump_zucchini)]
-fn zucchini_operation_rejects_malformed_outer_brotli_without_publication() {
-    for patch in [malformed_brotli_stream(), truncated_zucchini_patch("noop")] {
-        assert_zucchini_extraction_fails(&patch, "Unable to decode ZUCCHINI Brotli patch");
-    }
-}
-
-#[test]
-#[cfg(otadump_zucchini)]
-fn zucchini_operation_rejects_malformed_inner_patch_without_publication() {
-    let malformed = malformed_inner_zucchini_patch();
-    assert_zucchini_extraction_fails(&malformed, "ZUCCHINI apply failed: invalid ensemble patch");
-}
-
-#[test]
-#[cfg(otadump_zucchini)]
-fn zucchini_wrapper_applies_large_dex_jumbo_reference() {
-    assert_zucchini_fixture("dex-large", ".dex");
-}
-
-#[test]
-#[cfg(otadump_zucchini)]
-fn zucchini_wrapper_matches_annotation_jvm_parity_golden() {
-    assert_zucchini_fixture("annotation-jvm", ".dex");
-}
-
-#[test]
-#[cfg(otadump_zucchini)]
-fn zucchini_wrapper_rejects_unsafe_large_dex_string16_reference() {
-    let old = fixture_corpus::read("zucchini/dex-large-old.dex");
-    let patch = fixture_corpus::read("zucchini/dex-large-unsafe16.zuc");
-    let expected_size = fixture_corpus::read("zucchini/dex-large-new.dex").len();
-    let error = otadump::zucchini::apply(&old, &patch, expected_size).unwrap_err();
-    assert_eq!(error.status(), otadump::zucchini::Status::ApplyError);
-    assert_eq!(error.to_string(), "android executable preflight failed");
-}
-
-#[test]
-#[cfg(otadump_zucchini)]
-fn zucchini_wrapper_returns_owned_error_for_malformed_patch() {
-    let error = otadump::zucchini::apply(b"abcd", b"not a patch", 5).unwrap_err();
-    assert_eq!(error.status(), otadump::zucchini::Status::InvalidPatch);
-    assert_eq!(error.to_string(), "invalid ensemble patch");
-}
-
-fn extent(start_block: u64, num_blocks: u64) -> Extent {
-    Extent { start_block: Some(start_block), num_blocks: Some(num_blocks) }
-}
-
-fn write_payload(path: &Path, manifest: DeltaArchiveManifest, data: &[u8]) {
-    let manifest = manifest.encode_to_vec();
-    let mut payload = Vec::with_capacity(24 + manifest.len() + data.len());
-    payload.extend_from_slice(b"CrAU");
-    payload.extend_from_slice(&2u64.to_be_bytes());
-    payload.extend_from_slice(&(manifest.len() as u64).to_be_bytes());
-    payload.extend_from_slice(&0u32.to_be_bytes());
-    payload.extend_from_slice(&manifest);
-    payload.extend_from_slice(data);
-    fs::write(path, payload).unwrap();
-}
-
-fn partition_info(bytes: &[u8]) -> PartitionInfo {
-    PartitionInfo { size: Some(bytes.len() as u64), hash: Some(sha256(bytes)) }
-}
-
-#[test]
-fn source_copy_reconstructs_noncontiguous_extents_without_modifying_source() {
-    let temporary = TempDir::new().unwrap();
-    let source_dir = temporary.path().join("source");
-    let output_dir = temporary.path().join("output");
-    fs::create_dir(&source_dir).unwrap();
-    let source = b"AAAABBBBCCCCDDDD";
-    fs::write(source_dir.join("system.img"), source).unwrap();
-    let expected = b"AAAACCCC";
-    let operation = InstallOperation {
-        operation_type: 4,
-        src_extents: vec![extent(2, 1), extent(0, 1)],
-        src_length: Some(8),
-        dst_extents: vec![extent(1, 1), extent(0, 1)],
-        dst_length: Some(8),
-        src_sha256_hash: Some(sha256(b"CCCCAAAA")),
-        ..Default::default()
-    };
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(4),
-        minor_version: Some(2),
-        partitions: vec![PartitionUpdate {
-            partition_name: "system".into(),
-            old_partition_info: Some(partition_info(source)),
-            new_partition_info: Some(partition_info(expected)),
-            operations: vec![operation],
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, &[]);
-
-    ExtractOptions::new()
-        .source_dir(&source_dir)
-        .num_threads(2)
-        .extract(&payload, &output_dir)
-        .unwrap();
-
-    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), expected);
-    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-}
-
-#[test]
-fn source_bsdiff_reconstructs_bsdiff40_without_modifying_source() {
-    let temporary = TempDir::new().unwrap();
-    let source_dir = temporary.path().join("source");
-    let output_dir = temporary.path().join("output");
-    fs::create_dir(&source_dir).unwrap();
-    let source = b"abcdefgh";
-    let expected = b"abXYefgh";
-    fs::write(source_dir.join("system.img"), source).unwrap();
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(1),
-        minor_version: Some(2),
-        partitions: vec![PartitionUpdate {
-            partition_name: "system".into(),
-            old_partition_info: Some(partition_info(source)),
-            new_partition_info: Some(partition_info(expected)),
-            operations: vec![InstallOperation {
-                operation_type: 5,
-                data_offset: Some(0),
-                data_length: Some(BSDIFF40_PATCH.len() as u64),
-                src_extents: vec![extent(0, source.len() as u64)],
-                src_length: Some(source.len() as u64),
-                dst_extents: vec![extent(0, expected.len() as u64)],
-                dst_length: Some(expected.len() as u64),
-                data_sha256_hash: Some(sha256(BSDIFF40_PATCH)),
-                src_sha256_hash: Some(sha256(source)),
-            }],
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, BSDIFF40_PATCH);
-
-    ExtractOptions::new()
-        .source_dir(&source_dir)
-        .num_threads(2)
-        .extract(&payload, &output_dir)
-        .unwrap();
-
-    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), expected);
-    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-}
-
-#[test]
-fn brotli_bsdiff_reconstructs_bsdf2_without_modifying_source() {
-    let temporary = TempDir::new().unwrap();
-    let source_dir = temporary.path().join("source");
-    let output_dir = temporary.path().join("output");
-    fs::create_dir(&source_dir).unwrap();
-    let source = b"abcdefgh";
-    let expected = b"abXYefgh";
-    fs::write(source_dir.join("system.img"), source).unwrap();
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(1),
-        minor_version: Some(4),
-        partitions: vec![PartitionUpdate {
-            partition_name: "system".into(),
-            old_partition_info: Some(partition_info(source)),
-            new_partition_info: Some(partition_info(expected)),
-            operations: vec![InstallOperation {
-                operation_type: 10,
-                data_offset: Some(0),
-                data_length: Some(BROTLI_BSDF2_PATCH.len() as u64),
-                src_extents: vec![extent(0, source.len() as u64)],
-                src_length: Some(source.len() as u64),
-                dst_extents: vec![extent(0, expected.len() as u64)],
-                dst_length: Some(expected.len() as u64),
-                data_sha256_hash: Some(sha256(BROTLI_BSDF2_PATCH)),
-                src_sha256_hash: Some(sha256(source)),
-            }],
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, BROTLI_BSDF2_PATCH);
-
-    ExtractOptions::new()
-        .source_dir(&source_dir)
-        .num_threads(2)
-        .extract(&payload, &output_dir)
-        .unwrap();
-
-    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), expected);
-    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-}
-
-#[test]
-fn uncompressed_bsdf2_negative_seek_adds_diff_byte() {
-    let mut patch = Vec::new();
-    // BSDF2 magic + uncompressed flags (0 for control, diff, extra)
-    patch.extend_from_slice(b"BSDF2\x00\x00\x00");
-    patch.extend_from_slice(&72u64.to_le_bytes()); // control stream len: 3 tuples * 24
-    patch.extend_from_slice(&3u64.to_le_bytes()); // diff stream len: 3
-    patch.extend_from_slice(&3u64.to_le_bytes()); // new_size: 3
-
-    // Tuple 1: add=1, copy=0, seek=-2 (in-bounds source addition at oldpos=0; seek to -1)
-    patch.extend_from_slice(&1u64.to_le_bytes());
-    patch.extend_from_slice(&0u64.to_le_bytes());
-    let seek_neg2: u64 = 2 | (1 << 63); // offtin sign-magnitude -2
-    patch.extend_from_slice(&seek_neg2.to_le_bytes());
-
-    // Tuple 2: add=1, copy=0, seek=10 (negative oldpos=-1 treated as zero; seek to 10)
-    patch.extend_from_slice(&1u64.to_le_bytes());
-    patch.extend_from_slice(&0u64.to_le_bytes());
-    patch.extend_from_slice(&10u64.to_le_bytes());
-
-    // Tuple 3: add=1, copy=0, seek=0 (out-of-range oldpos=10 treated as zero)
-    patch.extend_from_slice(&1u64.to_le_bytes());
-    patch.extend_from_slice(&0u64.to_le_bytes());
-    patch.extend_from_slice(&0u64.to_le_bytes());
-
-    // Diff stream: 3 bytes
-    let diff_byte1: u8 = 0x01;
-    let diff_byte2: u8 = 0x42;
-    let diff_byte3: u8 = 0x24;
-    patch.push(diff_byte1);
-    patch.push(diff_byte2);
-    patch.push(diff_byte3);
-
-    let temporary = TempDir::new().unwrap();
-    let source_dir = temporary.path().join("source");
-    let output_dir = temporary.path().join("output");
-    fs::create_dir(&source_dir).unwrap();
-    let source = b"Z";
-    fs::write(source_dir.join("system.img"), source).unwrap();
-
-    let expected = [b'Z'.wrapping_add(diff_byte1), diff_byte2, diff_byte3];
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(1),
-        minor_version: Some(4),
-        partitions: vec![PartitionUpdate {
-            partition_name: "system".into(),
-            old_partition_info: Some(partition_info(source)),
-            new_partition_info: Some(partition_info(&expected)),
-            operations: vec![InstallOperation {
-                operation_type: 5, // SOURCE_BSDIFF
-                data_offset: Some(0),
-                data_length: Some(patch.len() as u64),
-                src_extents: vec![extent(0, source.len() as u64)],
-                src_length: Some(source.len() as u64),
-                dst_extents: vec![extent(0, expected.len() as u64)],
-                dst_length: Some(expected.len() as u64),
-                data_sha256_hash: Some(sha256(&patch)),
-                src_sha256_hash: Some(sha256(source)),
-            }],
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, &patch);
-
-    ExtractOptions::new()
-        .source_dir(&source_dir)
-        .num_threads(1)
-        .extract(&payload, &output_dir)
-        .unwrap();
-
-    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), expected);
-    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-}
-
-#[test]
-fn malformed_bsdiff_headers_fail_cleanly_and_remove_staging() {
-    for (operation_type, patch, expected_error) in [
-        (5, &[0; 32][..], "SOURCE_BSDIFF patch is invalid"),
-        (10, BROTLI_INVALID_HEADER_PATCH, "BROTLI_BSDIFF patch is invalid"),
-    ] {
-        let temporary = TempDir::new().unwrap();
-        let source_dir = temporary.path().join("source");
-        let output_dir = temporary.path().join("output");
-        fs::create_dir(&source_dir).unwrap();
-        let source = b"abcdefgh";
-        fs::write(source_dir.join("system.img"), source).unwrap();
-        let manifest = DeltaArchiveManifest {
-            block_size: Some(1),
-            minor_version: Some(4),
-            partitions: vec![PartitionUpdate {
-                partition_name: "system".into(),
-                old_partition_info: Some(partition_info(source)),
-                new_partition_info: Some(partition_info(b"abXYefgh")),
-                operations: vec![InstallOperation {
-                    operation_type,
-                    data_offset: Some(0),
-                    data_length: Some(patch.len() as u64),
-                    src_extents: vec![extent(0, source.len() as u64)],
-                    src_length: Some(source.len() as u64),
-                    dst_extents: vec![extent(0, source.len() as u64)],
-                    dst_length: Some(source.len() as u64),
-                    data_sha256_hash: Some(sha256(patch)),
-                    src_sha256_hash: Some(sha256(source)),
-                }],
-                ..Default::default()
-            }],
-        };
-        let payload = temporary.path().join("payload.bin");
-        write_payload(&payload, manifest, patch);
-
-        let error = ExtractOptions::new()
-            .source_dir(&source_dir)
-            .num_threads(2)
-            .extract(&payload, &output_dir)
-            .unwrap_err()
-            .to_string();
-
-        assert!(error.contains(expected_error), "unexpected error: {error}");
-        assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-        assert!(!output_dir.join("system.img").exists());
-        assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
-    }
-}
-
-#[test]
-fn source_validation_rejects_wrong_base_before_creating_output() {
-    let temporary = TempDir::new().unwrap();
-    let source_dir = temporary.path().join("source");
-    let output_dir = temporary.path().join("output");
-    fs::create_dir(&source_dir).unwrap();
-    fs::write(source_dir.join("boot.img"), b"bad!").unwrap();
-    let operation = InstallOperation {
-        operation_type: 4,
-        src_extents: vec![extent(0, 1)],
-        dst_extents: vec![extent(0, 1)],
-        ..Default::default()
-    };
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(4),
-        minor_version: Some(2),
-        partitions: vec![PartitionUpdate {
-            partition_name: "boot".into(),
-            old_partition_info: Some(partition_info(b"good")),
-            new_partition_info: Some(partition_info(b"good")),
-            operations: vec![operation],
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, &[]);
-
-    let error = ExtractOptions::new()
-        .source_dir(&source_dir)
-        .extract(&payload, &output_dir)
-        .unwrap_err()
-        .to_string();
-
-    assert!(error.contains("Source partition hash mismatch"));
-    assert!(!output_dir.join("boot.img").exists());
-}
-
-#[test]
-fn padded_source_uses_declared_prefix_without_modifying_tail() {
-    let temporary = TempDir::new().unwrap();
-    let source_dir = temporary.path().join("source");
-    let output_dir = temporary.path().join("output");
-    fs::create_dir(&source_dir).unwrap();
-    let declared_source = b"base";
-    let source = b"basefooter";
-    fs::write(source_dir.join("system.img"), source).unwrap();
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(4),
-        minor_version: Some(2),
-        partitions: vec![PartitionUpdate {
-            partition_name: "system".into(),
-            old_partition_info: Some(partition_info(declared_source)),
-            new_partition_info: Some(partition_info(declared_source)),
-            operations: vec![InstallOperation {
-                operation_type: 4,
-                src_extents: vec![extent(0, 1)],
-                src_length: Some(4),
-                dst_extents: vec![extent(0, 1)],
-                dst_length: Some(4),
-                src_sha256_hash: Some(sha256(declared_source)),
-                ..Default::default()
-            }],
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, &[]);
-
-    ExtractOptions::new().source_dir(&source_dir).extract(&payload, &output_dir).unwrap();
-
-    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), declared_source);
-    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-}
-
-#[test]
-fn source_shorter_than_declared_size_fails_cleanly() {
-    let temporary = TempDir::new().unwrap();
-    let source_dir = temporary.path().join("source");
-    let output_dir = temporary.path().join("output");
-    fs::create_dir(&source_dir).unwrap();
-    let source = b"bas";
-    fs::write(source_dir.join("system.img"), source).unwrap();
-    let declared_source = b"base";
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(4),
-        minor_version: Some(2),
-        partitions: vec![PartitionUpdate {
-            partition_name: "system".into(),
-            old_partition_info: Some(partition_info(declared_source)),
-            new_partition_info: Some(partition_info(declared_source)),
-            operations: vec![InstallOperation {
-                operation_type: 4,
-                src_extents: vec![extent(0, 1)],
-                dst_extents: vec![extent(0, 1)],
-                ..Default::default()
-            }],
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, &[]);
-
-    let error = ExtractOptions::new()
-        .source_dir(&source_dir)
-        .extract(&payload, &output_dir)
-        .unwrap_err()
-        .to_string();
-
-    assert!(error.contains("Source partition size mismatch"), "unexpected error: {error}");
-    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-    assert!(!output_dir.join("system.img").exists());
-}
-
-#[test]
-fn source_extent_cannot_enter_padding_beyond_declared_size() {
-    let temporary = TempDir::new().unwrap();
-    let source_dir = temporary.path().join("source");
-    let output_dir = temporary.path().join("output");
-    fs::create_dir(&source_dir).unwrap();
-    let declared_source = b"base";
-    let source = b"basefoot";
-    fs::write(source_dir.join("system.img"), source).unwrap();
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(4),
-        minor_version: Some(2),
-        partitions: vec![PartitionUpdate {
-            partition_name: "system".into(),
-            old_partition_info: Some(partition_info(declared_source)),
-            new_partition_info: Some(partition_info(declared_source)),
-            operations: vec![InstallOperation {
-                operation_type: 4,
-                src_extents: vec![extent(1, 1)],
-                src_length: Some(4),
-                dst_extents: vec![extent(0, 1)],
-                dst_length: Some(4),
-                src_sha256_hash: Some(sha256(b"foot")),
-                ..Default::default()
-            }],
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, &[]);
-
-    let error = ExtractOptions::new()
-        .source_dir(&source_dir)
-        .extract(&payload, &output_dir)
-        .unwrap_err()
-        .to_string();
-
-    assert!(error.contains("Invalid source extents"), "unexpected error: {error}");
-    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-    assert!(!output_dir.join("system.img").exists());
-}
-
-#[test]
-fn delta_operation_without_source_directory_fails_clearly() {
-    let temporary = TempDir::new().unwrap();
-    let output_dir = temporary.path().join("output");
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(4),
-        minor_version: Some(2),
-        partitions: vec![PartitionUpdate {
-            partition_name: "boot".into(),
-            old_partition_info: Some(partition_info(b"base")),
-            new_partition_info: Some(partition_info(b"base")),
-            operations: vec![InstallOperation {
-                operation_type: 4,
-                src_extents: vec![extent(0, 1)],
-                dst_extents: vec![extent(0, 1)],
-                ..Default::default()
-            }],
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, &[]);
-
-    let error = ExtractOptions::new().extract(&payload, &output_dir).unwrap_err().to_string();
-
-    assert!(error.contains("require a source directory"));
-    assert!(!output_dir.join("boot.img").exists());
-}
-
-#[test]
-fn malformed_partition_layouts_fail_without_escaping_or_leaving_partial_images() {
-    for (name, operations, expected_error) in [
-        (
-            "../escape",
-            vec![InstallOperation {
-                operation_type: 0,
-                data_offset: Some(0),
-                data_length: Some(4),
-                dst_extents: vec![extent(0, 1)],
-                ..Default::default()
-            }],
-            "Unsafe partition name",
-        ),
-        (
-            "system",
-            vec![
-                InstallOperation {
-                    operation_type: 0,
-                    data_offset: Some(0),
-                    data_length: Some(4),
-                    dst_extents: vec![extent(0, 1)],
-                    ..Default::default()
-                },
-                InstallOperation {
-                    operation_type: 0,
-                    data_offset: Some(4),
-                    data_length: Some(4),
-                    dst_extents: vec![extent(0, 1)],
-                    ..Default::default()
-                },
-            ],
-            "Destination extents overlap",
-        ),
-    ] {
-        let temporary = TempDir::new().unwrap();
-        let output_dir = temporary.path().join("output");
-        let target = b"data";
-        let manifest = DeltaArchiveManifest {
-            block_size: Some(4),
-            minor_version: Some(0),
-            partitions: vec![PartitionUpdate {
-                partition_name: name.into(),
-                old_partition_info: None,
-                new_partition_info: Some(partition_info(target)),
-                operations,
-                ..Default::default()
-            }],
-        };
-        let payload = temporary.path().join("payload.bin");
-        write_payload(&payload, manifest, b"datadata");
-
-        let error = ExtractOptions::new().extract(&payload, &output_dir).unwrap_err().to_string();
-
-        assert!(error.contains(expected_error), "unexpected error: {error}");
-        assert!(!temporary.path().join("escape.img").exists());
-        assert!(!output_dir.join("system.img").exists());
-    }
-}
-
-#[test]
-fn full_replace_payload_remains_compatible() {
-    let temporary = TempDir::new().unwrap();
-    let output_dir = temporary.path().join("output");
-    let expected = b"full payload data";
-    let operation = InstallOperation {
-        operation_type: 0,
-        data_offset: Some(0),
-        data_length: Some(expected.len() as u64),
-        dst_extents: vec![extent(0, 2)],
-        data_sha256_hash: Some(sha256(expected)),
-        ..Default::default()
-    };
-    let mut padded = expected.to_vec();
-    padded.resize(32, 0);
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(16),
-        minor_version: Some(0),
-        partitions: vec![PartitionUpdate {
-            partition_name: "vendor".into(),
-            old_partition_info: None,
-            new_partition_info: Some(partition_info(&padded)),
-            operations: vec![operation],
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, expected);
-
-    ExtractOptions::new().extract(&payload, &output_dir).unwrap();
-
-    assert_eq!(fs::read(output_dir.join("vendor.img")).unwrap(), padded);
-}
-
-#[test]
-fn omitted_verity_tree_is_generated_in_aosp_top_down_order() {
-    const LEAF_HASHES: [[u8; 32]; 5] = [
-        [
-            0x2b, 0xbf, 0x03, 0x32, 0xe3, 0x58, 0xa6, 0xa5, 0xdd, 0xc7, 0x3e, 0xa7, 0x1e, 0x75,
-            0xdc, 0x83, 0xf5, 0x8f, 0xec, 0xfc, 0x25, 0x4a, 0x4e, 0x7d, 0x41, 0x33, 0x86, 0x95,
-            0x8b, 0xd9, 0xe0, 0x00,
-        ],
-        [
-            0x24, 0x59, 0x0e, 0xd6, 0xcb, 0x84, 0x1e, 0xa2, 0xe5, 0xd8, 0x39, 0xe7, 0xc6, 0x3d,
-            0xb6, 0x9b, 0x75, 0x50, 0xb4, 0x88, 0x60, 0x7a, 0xf2, 0x52, 0x75, 0x53, 0x0a, 0x5e,
-            0x62, 0xce, 0x21, 0x7c,
-        ],
-        [
-            0xf1, 0x06, 0x4b, 0x13, 0x33, 0x00, 0xf3, 0x86, 0x53, 0x23, 0x3e, 0x15, 0x04, 0x99,
-            0x74, 0x81, 0xa0, 0x0b, 0xa8, 0xa1, 0x17, 0xd2, 0x0e, 0xd6, 0xae, 0x58, 0xc6, 0x75,
-            0x8e, 0x69, 0x39, 0xcc,
-        ],
-        [
-            0xda, 0x97, 0xb2, 0x05, 0xf9, 0xe7, 0xa3, 0xad, 0x12, 0x0d, 0xf3, 0xb2, 0x03, 0x14,
-            0xe2, 0x07, 0x1b, 0xb0, 0xfb, 0x0f, 0x87, 0x0f, 0x95, 0x21, 0xe0, 0xb2, 0xf9, 0x89,
-            0x1e, 0xe6, 0x9b, 0xe8,
-        ],
-        [
-            0xa7, 0xd9, 0xa0, 0xf7, 0xbf, 0xe5, 0xfa, 0x24, 0x7c, 0x32, 0x31, 0x87, 0x01, 0x9d,
-            0x01, 0x25, 0xf6, 0x93, 0xf0, 0xcd, 0xf4, 0x70, 0x93, 0xa2, 0xf1, 0x39, 0x2b, 0x3f,
-            0x57, 0xb9, 0xfb, 0x0b,
-        ],
-    ];
-    const UPPER_HASHES: [[u8; 32]; 2] = [
-        [
-            0x73, 0x55, 0xdf, 0xc2, 0xeb, 0x76, 0xd2, 0xb4, 0x0d, 0x27, 0xe3, 0x8c, 0x41, 0x40,
-            0x35, 0xa2, 0x7c, 0x5a, 0x8c, 0x95, 0x90, 0x2d, 0xdf, 0x77, 0xbb, 0x87, 0x69, 0x46,
-            0x96, 0xd6, 0x1b, 0x91,
-        ],
-        [
-            0xfe, 0xb1, 0x40, 0xb5, 0x15, 0x40, 0xbf, 0x36, 0x30, 0x8d, 0xce, 0x5c, 0x31, 0x08,
-            0x45, 0xe4, 0x12, 0x51, 0x2e, 0xc6, 0x53, 0xf9, 0x2b, 0x4e, 0x31, 0x09, 0x30, 0x7f,
-            0xab, 0x5e, 0x16, 0xe1,
-        ],
-    ];
-
-    let temporary = TempDir::new().unwrap();
-    let output_dir = temporary.path().join("output");
-    let block_size = 128usize;
-    let mut data = Vec::with_capacity(5 * block_size);
-    for byte in [0x11, 0x22, 0x33, 0x44, 0x55] {
-        data.extend(std::iter::repeat_n(byte, block_size));
-    }
-    let mut expected_tree = Vec::with_capacity(3 * block_size);
-    expected_tree.extend(UPPER_HASHES.into_iter().flatten());
-    expected_tree.resize(block_size, 0);
-    expected_tree.extend(LEAF_HASHES[..4].iter().flatten());
-    expected_tree.extend(LEAF_HASHES[4]);
-    expected_tree.resize(3 * block_size, 0);
-    let mut expected = data.clone();
-    expected.extend_from_slice(&expected_tree);
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(block_size as u32),
-        minor_version: Some(6),
-        partitions: vec![PartitionUpdate {
-            partition_name: "vendor".into(),
-            old_partition_info: None,
-            new_partition_info: Some(partition_info(&expected)),
-            operations: vec![InstallOperation {
-                operation_type: 0,
-                data_offset: Some(0),
-                data_length: Some(data.len() as u64),
-                dst_extents: vec![extent(0, 5)],
-                dst_length: Some(data.len() as u64),
-                data_sha256_hash: Some(sha256(&data)),
-                ..Default::default()
-            }],
-            hash_tree_data_extent: Some(extent(0, 5)),
-            hash_tree_extent: Some(extent(5, 3)),
-            hash_tree_algorithm: Some("sha256".into()),
-            hash_tree_salt: Some(b"verity-test-salt".to_vec()),
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, &data);
-
-    ExtractOptions::new().num_threads(4).extract(&payload, &output_dir).unwrap();
-
-    let actual = fs::read(output_dir.join("vendor.img")).unwrap();
-    assert_eq!(&actual[5 * block_size..], expected_tree);
-    assert_eq!(actual, expected);
-}
-
-#[test]
-fn malformed_verity_layouts_fail_without_leaving_staging_files() {
-    for (tree_extent, operations, expected_error) in [
-        (
-            extent(5, 2),
-            vec![InstallOperation {
-                operation_type: 0,
-                data_offset: Some(0),
-                data_length: Some(5 * 128),
-                dst_extents: vec![extent(0, 5)],
-                ..Default::default()
-            }],
-            "Hash tree size mismatch",
-        ),
-        (
-            extent(5, 3),
-            vec![
-                InstallOperation {
-                    operation_type: 0,
-                    data_offset: Some(0),
-                    data_length: Some(5 * 128),
-                    dst_extents: vec![extent(0, 5)],
-                    ..Default::default()
-                },
-                InstallOperation {
-                    operation_type: 6,
-                    dst_extents: vec![extent(5, 1)],
-                    ..Default::default()
-                },
-            ],
-            "Hash tree extent overlaps destination extents",
-        ),
-    ] {
-        let temporary = TempDir::new().unwrap();
-        let output_dir = temporary.path().join("output");
-        let data = vec![0x5a; 5 * 128];
-        let manifest = DeltaArchiveManifest {
-            block_size: Some(128),
-            minor_version: Some(6),
-            partitions: vec![PartitionUpdate {
-                partition_name: "vendor".into(),
-                new_partition_info: Some(partition_info(&vec![0; 8 * 128])),
-                operations,
-                hash_tree_data_extent: Some(extent(0, 5)),
-                hash_tree_extent: Some(tree_extent),
-                hash_tree_algorithm: Some("sha256".into()),
-                hash_tree_salt: Some(vec![0x23; 32]),
-                ..Default::default()
-            }],
-        };
-        let payload = temporary.path().join("payload.bin");
-        write_payload(&payload, manifest, &data);
-
-        let error = ExtractOptions::new().extract(&payload, &output_dir).unwrap_err().to_string();
-
-        assert!(error.contains(expected_error), "unexpected error: {error}");
-        assert!(!output_dir.join("vendor.img").exists());
-        assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
-    }
-}
-
-#[test]
-fn fec_extents_match_android_reference_vectors() {
-    for (blocks, fixture, roots) in
-        [(1usize, "fec-one-block.bin", None), (300usize, "fec-300-block.bin", Some(2))]
-    {
-        let temporary = TempDir::new().unwrap();
-        let output_dir = temporary.path().join("output");
-        let data = if blocks == 1 {
-            vec![1; 4096]
-        } else {
-            (0..blocks * 4096)
-                .map(|index| ((index % 4096) * 37 + (index / 4096) * 53 + 13) as u8)
-                .collect()
-        };
-        let fec = fixture_corpus::read(&format!("fec/{fixture}"));
-        let mut target = data.clone();
-        target.extend_from_slice(&fec);
-        let manifest = DeltaArchiveManifest {
-            block_size: Some(4096),
-            minor_version: Some(6),
-            partitions: vec![PartitionUpdate {
-                partition_name: "vendor".into(),
-                new_partition_info: Some(partition_info(&target)),
-                operations: vec![InstallOperation {
-                    operation_type: 0,
-                    data_offset: Some(0),
-                    data_length: Some(data.len() as u64),
-                    dst_extents: vec![extent(0, blocks as u64)],
-                    ..Default::default()
-                }],
-                fec_data_extent: Some(extent(0, blocks as u64)),
-                fec_extent: Some(extent(blocks as u64, (fec.len() / 4096) as u64)),
-                fec_roots: roots,
-                ..Default::default()
-            }],
-        };
-        let payload = temporary.path().join("payload.bin");
-        write_payload(&payload, manifest, &data);
-
-        ExtractOptions::new().extract(&payload, &output_dir).unwrap();
-
-        assert_eq!(fs::read(output_dir.join("vendor.img")).unwrap(), target);
-        assert_eq!(fs::read_dir(&output_dir).unwrap().count(), 1);
-    }
-}
-
-#[test]
-fn malformed_fec_metadata_fails_without_publishing_an_image() {
-    for (
-        data_extent,
-        storage_extent,
-        roots,
-        partition_blocks,
-        operation_blocks,
-        hash_tree,
-        error,
-    ) in [
-        (Some(extent(0, 1)), None, Some(2), 3, 1, false, "FEC data and storage"),
-        (Some(extent(0, 1)), Some(extent(1, 2)), Some(0), 3, 1, false, "FEC roots"),
-        (Some(extent(0, 1)), Some(extent(1, 2)), Some(255), 3, 1, false, "FEC roots"),
-        (Some(extent(0, 1)), Some(extent(1, 1)), Some(2), 2, 1, false, "FEC size mismatch"),
-        (
-            Some(extent(0, 1)),
-            Some(extent(0, 2)),
-            Some(2),
-            2,
-            1,
-            false,
-            "FEC storage extent must follow",
-        ),
-        (
-            Some(extent(2, 1)),
-            Some(extent(0, 2)),
-            Some(2),
-            3,
-            1,
-            false,
-            "FEC storage extent must follow",
-        ),
-        (
-            Some(extent(0, 1)),
-            Some(extent(2, 2)),
-            Some(2),
-            3,
-            1,
-            false,
-            "FEC storage extent exceeds partition size",
-        ),
-        (
-            Some(extent(0, 1)),
-            Some(extent(1, 2)),
-            Some(2),
-            3,
-            3,
-            false,
-            "FEC storage extent overlaps destination extents",
-        ),
-        (
-            Some(extent(0, 1)),
-            Some(extent(1, 2)),
-            Some(2),
-            3,
-            1,
-            true,
-            "FEC storage extent overlaps hash tree extent",
-        ),
-        (
-            Some(extent(0, 1)),
-            Some(extent(1, 2)),
-            Some(2),
-            4,
-            1,
-            true,
-            "FEC storage extent overlaps hash tree data extent",
-        ),
-    ] {
-        let temporary = TempDir::new().unwrap();
-        let output_dir = temporary.path().join("output");
-        let data = vec![0x5a; operation_blocks * 4096];
-        let mut update = PartitionUpdate {
-            partition_name: "vendor".into(),
-            new_partition_info: Some(partition_info(&vec![0; partition_blocks * 4096])),
-            operations: vec![InstallOperation {
-                operation_type: 0,
-                data_offset: Some(0),
-                data_length: Some(data.len() as u64),
-                dst_extents: vec![extent(0, operation_blocks as u64)],
-                ..Default::default()
-            }],
-            fec_data_extent: data_extent,
-            fec_extent: storage_extent,
-            fec_roots: roots,
-            ..Default::default()
-        };
-        if hash_tree {
-            if partition_blocks == 4 {
-                update.hash_tree_data_extent = Some(extent(0, 3));
-                update.hash_tree_extent = Some(extent(3, 1));
-            } else {
-                update.hash_tree_data_extent = Some(extent(0, 1));
-                update.hash_tree_extent = Some(extent(1, 1));
-            }
-            update.hash_tree_algorithm = Some("sha256".into());
-        }
-        let manifest = DeltaArchiveManifest {
-            block_size: Some(4096),
-            minor_version: Some(6),
-            partitions: vec![update],
-        };
-        let payload = temporary.path().join("payload.bin");
-        write_payload(&payload, manifest, &data);
-
-        let actual = ExtractOptions::new().extract(&payload, &output_dir).unwrap_err().to_string();
-
-        assert!(actual.contains(error), "unexpected error: {actual}");
-        assert!(!output_dir.join("vendor.img").exists());
-        assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
-    }
-}
-
-#[test]
-fn verified_partitions_are_promoted_after_all_succeed() {
-    let temporary = TempDir::new().unwrap();
-    let output_dir = temporary.path().join("output");
-    let boot = b"boot";
-    let vendor = b"vend";
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(4),
-        minor_version: Some(0),
-        partitions: vec![
-            PartitionUpdate {
-                partition_name: "boot".into(),
-                old_partition_info: None,
-                new_partition_info: Some(partition_info(boot)),
-                operations: vec![InstallOperation {
-                    operation_type: 0,
-                    data_offset: Some(0),
-                    data_length: Some(4),
-                    dst_extents: vec![extent(0, 1)],
-                    ..Default::default()
-                }],
-                ..Default::default()
-            },
-            PartitionUpdate {
-                partition_name: "vendor".into(),
-                old_partition_info: None,
-                new_partition_info: Some(partition_info(vendor)),
-                operations: vec![InstallOperation {
-                    operation_type: 0,
-                    data_offset: Some(4),
-                    data_length: Some(4),
-                    dst_extents: vec![extent(0, 1)],
-                    ..Default::default()
-                }],
-                ..Default::default()
-            },
-        ],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, b"bootvend");
-
-    ExtractOptions::new().extract(&payload, &output_dir).unwrap();
-
-    assert_eq!(fs::read(output_dir.join("boot.img")).unwrap(), boot);
-    assert_eq!(fs::read(output_dir.join("vendor.img")).unwrap(), vendor);
-}
-
-#[test]
-fn no_clobber_rejects_existing_destination_without_modifying_source() {
-    let temporary = TempDir::new().unwrap();
-    let source_dir = temporary.path().join("source");
-    let output_dir = temporary.path().join("output");
-    fs::create_dir(&source_dir).unwrap();
-    fs::create_dir(&output_dir).unwrap();
-    let source = b"base";
-    let existing = b"keep";
-    fs::write(source_dir.join("system.img"), source).unwrap();
-    fs::write(output_dir.join("system.img"), existing).unwrap();
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(4),
-        minor_version: Some(2),
-        partitions: vec![PartitionUpdate {
-            partition_name: "system".into(),
-            old_partition_info: Some(partition_info(source)),
-            new_partition_info: Some(partition_info(source)),
-            operations: vec![InstallOperation {
-                operation_type: 4,
-                src_extents: vec![extent(0, 1)],
-                dst_extents: vec![extent(0, 1)],
-                ..Default::default()
-            }],
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, &[]);
-
-    let error = ExtractOptions::new()
-        .source_dir(&source_dir)
-        .extract(&payload, &output_dir)
-        .unwrap_err()
-        .to_string();
-
-    assert!(error.contains("already exists"));
-    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), existing);
-    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-    assert_eq!(fs::read_dir(&output_dir).unwrap().count(), 1);
-}
-
-#[test]
-fn verification_failure_preserves_existing_destinations_with_overwrite() {
-    let temporary = TempDir::new().unwrap();
-    let output_dir = temporary.path().join("output");
-    fs::create_dir(&output_dir).unwrap();
-    fs::write(output_dir.join("boot.img"), b"oldb").unwrap();
-    fs::write(output_dir.join("vendor.img"), b"oldv").unwrap();
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(4),
-        minor_version: Some(0),
-        partitions: vec![
-            PartitionUpdate {
-                partition_name: "boot".into(),
-                old_partition_info: None,
-                new_partition_info: Some(partition_info(b"boot")),
-                operations: vec![InstallOperation {
-                    operation_type: 0,
-                    data_offset: Some(0),
-                    data_length: Some(4),
-                    dst_extents: vec![extent(0, 1)],
-                    ..Default::default()
-                }],
-                ..Default::default()
-            },
-            PartitionUpdate {
-                partition_name: "vendor".into(),
-                old_partition_info: None,
-                new_partition_info: Some(partition_info(b"bad!")),
-                operations: vec![InstallOperation {
-                    operation_type: 0,
-                    data_offset: Some(4),
-                    data_length: Some(4),
-                    dst_extents: vec![extent(0, 1)],
-                    ..Default::default()
-                }],
-                ..Default::default()
-            },
-        ],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, b"bootvend");
-
-    let error = ExtractOptions::new()
-        .overwrite(true)
-        .extract(&payload, &output_dir)
-        .unwrap_err()
-        .to_string();
-
-    assert!(error.contains("Output verification failed"));
-    assert_eq!(fs::read(output_dir.join("boot.img")).unwrap(), b"oldb");
-    assert_eq!(fs::read(output_dir.join("vendor.img")).unwrap(), b"oldv");
-    assert_eq!(fs::read_dir(&output_dir).unwrap().count(), 2);
-}
-
-#[test]
-fn partition_selection_does_not_require_unselected_delta_sources() {
-    let temporary = TempDir::new().unwrap();
-    let output_dir = temporary.path().join("output");
-    let expected = b"boot";
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(4),
-        minor_version: Some(2),
-        partitions: vec![
-            PartitionUpdate {
-                partition_name: "boot".into(),
-                old_partition_info: None,
-                new_partition_info: Some(partition_info(expected)),
-                operations: vec![InstallOperation {
-                    operation_type: 0,
-                    data_offset: Some(0),
-                    data_length: Some(4),
-                    dst_extents: vec![extent(0, 1)],
-                    ..Default::default()
-                }],
-                ..Default::default()
-            },
-            PartitionUpdate {
-                partition_name: "system".into(),
-                old_partition_info: Some(partition_info(b"base")),
-                new_partition_info: Some(partition_info(b"base")),
-                operations: vec![InstallOperation {
-                    operation_type: 4,
-                    src_extents: vec![extent(0, 1)],
-                    dst_extents: vec![extent(0, 1)],
-                    ..Default::default()
-                }],
-                ..Default::default()
-            },
-        ],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, expected);
-
-    ExtractOptions::new().partitions(["boot"]).extract(&payload, &output_dir).unwrap();
-
-    assert_eq!(fs::read(output_dir.join("boot.img")).unwrap(), expected);
-    assert!(!output_dir.join("system.img").exists());
-}
-
-struct CancellingReporter {
-    cancellation_token: CancellationToken,
-    cancelled: AtomicBool,
-}
-
-impl ProgressReporter for CancellingReporter {
-    fn report_progress(&self, progress: f64) {
-        if progress > 0.0 && !self.cancelled.swap(true, Ordering::AcqRel) {
-            self.cancellation_token.cancel();
-        }
-    }
-}
-
-#[test]
-fn cancellation_cleans_staging_without_promoting_or_modifying_source() {
-    let temporary = TempDir::new().unwrap();
-    let source_dir = temporary.path().join("source");
-    let output_dir = temporary.path().join("output");
-    fs::create_dir(&source_dir).unwrap();
-    fs::create_dir(&output_dir).unwrap();
-    let source = (0..128).map(|byte| byte as u8).collect::<Vec<_>>();
-    fs::write(source_dir.join("system.img"), &source).unwrap();
-    let existing = b"existing destination";
-    fs::write(output_dir.join("system.img"), existing).unwrap();
-    let operations = (0..32)
-        .map(|block| InstallOperation {
-            operation_type: 4,
-            src_extents: vec![extent(block, 1)],
-            src_length: Some(4),
-            dst_extents: vec![extent(block, 1)],
-            dst_length: Some(4),
-            ..Default::default()
-        })
-        .collect();
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(4),
-        minor_version: Some(2),
-        partitions: vec![PartitionUpdate {
-            partition_name: "system".into(),
-            old_partition_info: Some(partition_info(&source)),
-            new_partition_info: Some(partition_info(&source)),
-            operations,
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, &[]);
-    let cancellation_token = CancellationToken::new();
-    let reporter = CancellingReporter {
-        cancellation_token: cancellation_token.clone(),
-        cancelled: AtomicBool::new(false),
-    };
-
-    let error = ExtractOptions::new()
-        .source_dir(&source_dir)
-        .overwrite(true)
-        .num_threads(4)
-        .progress_reporter(&reporter)
-        .cancellation_token(&cancellation_token)
-        .extract(&payload, &output_dir)
-        .unwrap_err();
-
-    assert!(is_cancellation(error.as_ref()));
-    assert_eq!(fs::read(output_dir.join("system.img")).unwrap(), existing);
-    assert_eq!(fs::read(source_dir.join("system.img")).unwrap(), source);
-    assert!(
-        fs::read_dir(&output_dir).unwrap().all(|entry| !entry
-            .unwrap()
-            .file_name()
-            .to_string_lossy()
-            .starts_with(".otadump-"))
-    );
-}
-
-#[test]
-fn cli_extraction_error_exits_nonzero_and_reports_diagnostic() {
-    use std::process::Command;
-
-    let temporary = TempDir::new().unwrap();
-    let payload = temporary.path().join("payload.bin");
-    let output_dir = temporary.path().join("output");
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(4),
-        minor_version: Some(2),
-        partitions: vec![PartitionUpdate {
-            partition_name: "boot".into(),
-            old_partition_info: Some(partition_info(b"base")),
-            new_partition_info: Some(partition_info(b"base")),
-            operations: vec![InstallOperation {
-                operation_type: 4,
-                src_extents: vec![extent(0, 1)],
-                dst_extents: vec![extent(0, 1)],
-                ..Default::default()
-            }],
-            ..Default::default()
-        }],
-    };
-    write_payload(&payload, manifest, &[]);
-
-    let output = Command::new(env!("CARGO_BIN_EXE_otadump"))
-        .arg(&payload)
-        .arg("--output-dir")
-        .arg(&output_dir)
-        .output()
-        .unwrap();
-    let stderr = String::from_utf8_lossy(&output.stderr);
-
-    assert_eq!(output.status.code(), Some(1), "CLI did not exit with code 1; stderr: {stderr}");
-    assert!(
-        stderr.contains("require a source directory"),
-        "missing extraction diagnostic: {stderr}"
-    );
-}
-
-#[cfg(unix)]
-#[test]
-fn cli_sigint_exits_130_after_cleaning_staging() {
-    use std::process::{Command, Stdio};
-    use std::time::{Duration, Instant};
-
-    let temporary = TempDir::new().unwrap();
-    let source_dir = temporary.path().join("source");
-    let output_dir = temporary.path().join("output");
-    fs::create_dir(&source_dir).unwrap();
-    let block_size = 256usize;
-    let block_count = 65_536usize;
-    let source = vec![0x5a; block_size * block_count];
-    let source_path = source_dir.join("system.img");
-    fs::write(&source_path, &source).unwrap();
-    let operations = (0..block_count)
-        .map(|block| InstallOperation {
-            operation_type: 4,
-            src_extents: vec![extent(block as u64, 1)],
-            src_length: Some(block_size as u64),
-            dst_extents: vec![extent(block as u64, 1)],
-            dst_length: Some(block_size as u64),
-            ..Default::default()
-        })
-        .collect();
-    let manifest = DeltaArchiveManifest {
-        block_size: Some(block_size as u32),
-        minor_version: Some(2),
-        partitions: vec![PartitionUpdate {
-            partition_name: "system".into(),
-            old_partition_info: Some(partition_info(&source)),
-            new_partition_info: Some(partition_info(&source)),
-            operations,
-            ..Default::default()
-        }],
-    };
-    let payload = temporary.path().join("payload.bin");
-    write_payload(&payload, manifest, &[]);
-
-    let mut child = Command::new(env!("CARGO_BIN_EXE_otadump"))
-        .arg(&payload)
-        .arg("--output-dir")
-        .arg(&output_dir)
-        .arg("--source-dir")
-        .arg(&source_dir)
-        .stdout(Stdio::null())
-        .stderr(Stdio::null())
-        .spawn()
-        .unwrap();
-    let deadline = Instant::now() + Duration::from_secs(10);
-    loop {
-        let staging_exists = output_dir.exists()
-            && fs::read_dir(&output_dir)
-                .unwrap()
-                .any(|entry| entry.unwrap().file_name().to_string_lossy().starts_with(".otadump-"));
-        if staging_exists {
-            break;
-        }
-        assert!(child.try_wait().unwrap().is_none(), "CLI finished before SIGINT");
-        assert!(Instant::now() < deadline, "staging directory was not created");
-        std::thread::yield_now();
-    }
-    let signal_status =
-        Command::new("kill").arg("-INT").arg(child.id().to_string()).status().unwrap();
-    assert!(signal_status.success());
-    let exit_deadline = Instant::now() + Duration::from_secs(10);
-    let status = loop {
-        if let Some(status) = child.try_wait().unwrap() {
-            break status;
-        }
-        if Instant::now() >= exit_deadline {
-            child.kill().unwrap();
-            child.wait().unwrap();
-            panic!("CLI did not finish cleanup after SIGINT");
-        }
-        std::thread::sleep(Duration::from_millis(1));
-    };
-
-    assert_eq!(status.code(), Some(130));
-    assert!(!output_dir.join("system.img").exists());
-    assert_eq!(sha256(&fs::read(source_path).unwrap()), sha256(&source));
-    assert!(fs::read_dir(&output_dir).unwrap().next().is_none());
-}
-
-#[cfg(unix)]
-#[test]
-fn source_and_destination_aliases_are_rejected_without_modifying_the_source() {
-    use std::os::unix::fs::symlink;
-
-    for link in ["hard", "symbolic"] {
-        let temporary = TempDir::new().unwrap();
-        let source_dir = temporary.path().join("source");
-        let output_dir = temporary.path().join("output");
-        fs::create_dir(&source_dir).unwrap();
-        fs::create_dir(&output_dir).unwrap();
-        let source_path = source_dir.join("system.img");
-        let source = b"base";
-        fs::write(&source_path, source).unwrap();
-        let destination_path = output_dir.join("system.img");
-        if link == "hard" {
-            fs::hard_link(&source_path, &destination_path).unwrap();
-        } else {
-            symlink(&source_path, &destination_path).unwrap();
-        }
-
-        let manifest = DeltaArchiveManifest {
-            block_size: Some(4),
-            minor_version: Some(2),
-            partitions: vec![PartitionUpdate {
-                partition_name: "system".into(),
-                old_partition_info: Some(partition_info(source)),
-                new_partition_info: Some(partition_info(source)),
-                operations: vec![InstallOperation {
-                    operation_type: 4,
-                    src_extents: vec![extent(0, 1)],
-                    dst_extents: vec![extent(0, 1)],
-                    ..Default::default()
-                }],
-                ..Default::default()
-            }],
-        };
-        let payload = temporary.path().join("payload.bin");
-        write_payload(&payload, manifest, &[]);
-
-        let error = ExtractOptions::new()
-            .source_dir(&source_dir)
-            .overwrite(true)
-            .extract(&payload, &output_dir)
-            .unwrap_err()
-            .to_string();
-
-        assert!(error.contains("refer to the same file"));
-        assert_eq!(fs::read(&source_path).unwrap(), source);
-    }
 }
diff --git a/tests/fixture_corpus.rs b/tests/fixture_corpus.rs
deleted file mode 100644
index 2c51f6f..0000000
--- a/tests/fixture_corpus.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use std::collections::HashMap;
-use std::fs::File;
-use std::sync::OnceLock;
-
-use zip::ZipArchive;
-
-const CORPUS_ZIP: &str = "tests/fixtures/corpus/opaque-fixtures.zip";
-
-static FIXTURES: OnceLock<HashMap<String, Vec<u8>>> = OnceLock::new();
-
-fn load() -> HashMap<String, Vec<u8>> {
-    let file = File::open(CORPUS_ZIP).expect("failed to open fixture corpus zip");
-    let mut archive = ZipArchive::new(file).expect("failed to parse fixture corpus zip");
-    let mut fixtures = HashMap::with_capacity(archive.len());
-    for index in 0..archive.len() {
-        let mut member = archive.by_index(index).expect("failed to read fixture corpus entry");
-        let mut bytes = Vec::new();
-        std::io::copy(&mut member, &mut bytes).expect("failed to decode fixture corpus entry");
-        fixtures.insert(member.name().to_string(), bytes);
-    }
-    fixtures
-}
-
-pub fn read(path: &str) -> Vec<u8> {
-    FIXTURES
-        .get_or_init(load)
-        .get(path)
-        .unwrap_or_else(|| panic!("missing fixture in corpus zip: {path}"))
-        .clone()
-}
diff --git a/tests/fixtures/corpus/MANIFEST.txt b/tests/fixtures/corpus/MANIFEST.txt
deleted file mode 100644
index caca90a..0000000
--- a/tests/fixtures/corpus/MANIFEST.txt
+++ /dev/null
@@ -1,46 +0,0 @@
-75ca5f457bae225fcb8191f4ef8746743019c1eb4e330d1321f56b956441009a       16384  fec/fec-300-block.bin
-ee94e02ccf9b3e11fad2939dcf1e38cd1439b86436c457bf3dc42256811f1681        8192  fec/fec-one-block.bin
-6ea395fcef53c8e4de2fc708f4c8e1db7de05b53e48a891c77cbebee4e914e65         768  lz4/lz4-no-postfix.lz4
-d0f1ef7cd255d13146f34b70060f21a545428534feeb90837aace772c80331dc        1024  lz4/lz4-no-postfix.raw
-12a28b1f3d4cc5f8b0bfa534f062abae2b9bdbcd886fa2d657cf81e10b2e273e        1152  lz4/lz4hc9-no-postfix.lz4
-ae91406138d4876551426d6e267b62e15a297e4f4d06a807a1adfce08440af88        1536  lz4/lz4hc9-no-postfix.raw
-1e5b41d7f2e7c5d541a65b683be0c357da12241a036509853962e8888e900c87         608  lz4/zero-padding-layout.lz4
-9ec1afaf310fcf60f084bae0daca993d6ff54966a5bae97f4c0bce71db996920         800  lz4/zero-padding-layout.raw
-4cd1380f674ea78e86276bc9ce39ab88b45bbbccb96c611e18bdd7108c738cfa         181  lz4diff/lz4-bsdiff/patch.lz4diff
-43efe58bdcd3552ffcda9608aa72a9f8189984af9cecd3143d468021e3b54c2d         185  lz4diff/lz4hc9-bsdiff/patch.lz4diff
-08fe5ecea8e3f48ec17665d50807516d63b17dcb729baa540566679a261228d4         366  lz4diff/postfix-bsdiff/patch.lz4diff
-4b9ce7db27ac550c6d7fd1e7f18a535c3a4616c8702fe9655a1d10839c681846         304  lz4diff/raw-puffdiff/patch.lz4diff
-de0527c0d2d27f378cb79aec447172e0efcfff9cc45d0be05c313a87a2069280          17  lz4diff/raw-puffdiff/source.bin
-649b17ae72a6d503a1176604d876923270cd467ae1d458a54e58575eda98766e          22  lz4diff/raw-puffdiff/target.bin
-3c5f3a2fa1bbf4dd938eb05dfb76cf53d4a95b70cb06e35faed6c560a7077260         202  lz4diff/zero-padding-bsdiff/patch.lz4diff
-de0527c0d2d27f378cb79aec447172e0efcfff9cc45d0be05c313a87a2069280          17  puffin/deflates-sample1.bin
-649b17ae72a6d503a1176604d876923270cd467ae1d458a54e58575eda98766e          22  puffin/deflates-sample2.bin
-826cd5b1a815cda2d13c2ca5733a9f9e99e0030d27178f2e9d44e47d73d4a9a8         176  puffin/patch-1-to-2-zucchini.puf
-cb44443bb6312b8faac434d3bd7cf67419c78733b863a8c7ecf4815a071cb9bb         266  puffin/patch-1-to-2.puf
-20eef1e91c331d93f8d42f20b2875836aac05b2b2c96fb7d19e9a3a41043341f         185  puffin/patch-1-to-raw.puf
-bdbdce312f5762571faa17f3f4780235ed2c54f966c0f60dace1cddd2634f4f3           4  puffin/raw-11-22-33-44.bin
-193b1caac682a40ad87657e87e387e1b030013c700e79733bf56a8115324972f       29516  zucchini/annotation-jvm-new.dex
-2e49e0ab01d4a3f253d16bd305848b38aeec102ea7982dc4f641dcfa85bc7c25       28568  zucchini/annotation-jvm-old.dex
-764358162ba84969bd6ba9c6bdd7f67df8b6ee6a555e2529d9084cfe057b79e8        8286  zucchini/annotation-jvm.zuc
-bdf755e070b6cba4f0ea478130c261906c12c0f1fcd0a665effb24dda6db18b5      786788  zucchini/dex-large-new.dex
-c837542fb547d892cbc597a39951bc6b3b0398ec89ff76a472a5c0d720e05ae3      786788  zucchini/dex-large-old.dex
-ebad167e527b375967bef5932e7af4dd7317c4d905b4227f1ab5da6fdb2d4515       65758  zucchini/dex-large-unsafe16.zuc
-fef404d99db5d6e9570f6673a78a5a4d4dcf23616648812debd66d65947b5afc       65758  zucchini/dex-large.zuc
-63e76d95aaaa6bdcedf79b2a8f3b55736fb5e9899e021a6be5190fba2d820080         400  zucchini/dex-new.dex
-3b06060663ae19133d71d72a1f3b40d9bf4716fb4d6fc83d7ae039d01e80e945         400  zucchini/dex-old.dex
-88f7512d4fb07ef897804d370ab1db699104c8b72be3be36e29adb5970fed8d5         223  zucchini/dex.zuc
-2664d1c48bf0a2a2e7b3f8b1a9bd38e08055580adf42f2d53ef6abd7dcc65f30         280  zucchini/elf-arm32-new
-a5a51e66fb5f923113eeb1f5df5c020c715df6a16d691c5a6030e36d920c625c         280  zucchini/elf-arm32-old
-852f01e48651fbcd093f6eb2f075fc59feb470413e79e6f9ddc16b9f2cdcec4c         103  zucchini/elf-arm32.zuc
-5125780242c5b230291ba47102734e422e09255e66e6b711a0657aca8098b8b6         384  zucchini/elf-arm64-new
-d101a04d15a4b975f01d179fbf8b98771acdb31edb71dca4d8de40fa88189ecb         384  zucchini/elf-arm64-old
-0b6c484b0b8cfc2c22ff0257a1e3677e36948bb2f8062a099e88fa4cc4ddf9d7         104  zucchini/elf-arm64.zuc
-1e2080509d361c7e87f3434a3ed2f7a9be1b6972fcfb48fb531f0311e5820d7c        4680  zucchini/elf-new
-32ae88b0151c4afff7b9a88524a554ce517055257ebdd17329fb23fefde75c55        4680  zucchini/elf-old
-9d5187d155ff0acbb22118ade13032b20d6efc1ebfaf95c970e83d8d2f33b9cd         280  zucchini/elf-x86-new
-7eb3c69419c3221a489fa0ba12bfeb94d258f14212a8e108ee130a31c83dda3b         280  zucchini/elf-x86-old
-3bd7d0fc9454f38707d6af56ba9d1382d8a700e7dbda0f4955dcffc748b93915         103  zucchini/elf-x86.zuc
-7015ce4ab2589a48815f734366f01fa9c7553f06480274fd43e9ed85311afeaa         112  zucchini/elf.zuc
-ff55ebfb1b1889f3d0544b00dfabed96de8e4e4234e857043dba47a7a210d019           5  zucchini/noop-new.bin
-88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589           4  zucchini/noop-old.bin
-dec6c4f3e44a1ae18c48efb1c25e59288ecaad04997b8668ce2de0abcf3342d9          88  zucchini/noop.zuc
diff --git a/tests/fixtures/corpus/README.md b/tests/fixtures/corpus/README.md
deleted file mode 100644
index ce6684f..0000000
--- a/tests/fixtures/corpus/README.md
+++ /dev/null
@@ -1,8 +0,0 @@
-# Fixture Corpus
-
-Opaque binary fixtures used by integration tests are consolidated into
-`opaque-fixtures.zip` to reduce repository fanout while preserving provenance.
-
-- `MANIFEST.txt` records SHA256, size, and archive path for each packed file.
-- `SHA256SUMS` pins the deterministic ZIP blob itself.
-- Text provenance files under `tests/fixtures/*` are intentionally retained.
diff --git a/tests/fixtures/corpus/SHA256SUMS b/tests/fixtures/corpus/SHA256SUMS
deleted file mode 100644
index f62f861..0000000
--- a/tests/fixtures/corpus/SHA256SUMS
+++ /dev/null
@@ -1 +0,0 @@
-6652b1b2d2e1ab4719172a9405f7605f3c08dfec0958215f0f783e05196d4ba3  opaque-fixtures.zip
diff --git a/tests/fixtures/corpus/opaque-fixtures.zip b/tests/fixtures/corpus/opaque-fixtures.zip
deleted file mode 100644
index ef1a0bfbf59b6f7d626c860d02057435b8909662..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1822459
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

diff --git a/tests/fixtures/fec/LICENSE b/tests/fixtures/fec/LICENSE
deleted file mode 100644
index d645695..0000000
--- a/tests/fixtures/fec/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/tests/fixtures/fec/README.md b/tests/fixtures/fec/README.md
deleted file mode 100644
index 6eb73a2..0000000
--- a/tests/fixtures/fec/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# dm-verity FEC fixtures
-
-These parity extents verify Android 17 dm-verity FEC generation.
-They use the Apache-2.0 license in `LICENSE`.
-
-`fec-one-block.bin` is the `FECTest` vector from AOSP `system/update_engine` commit `4591637f51644f5429f9e2fe589ab22b92f61842`.
-Its input is one 4,096-byte block filled with `0x01`, with two FEC roots.
-The output alternates `0x8e, 0x8f` for 8,192 bytes.
-
-`fec-300-block.bin` is a multi-round reference vector generated with AOSP `external/fec` commit `90857deb7973c0ca24c79b9c1809fc9667f32c4f`.
-Input byte `i` in block `b` is `(i * 37 + b * 53 + 13) mod 256`, so each block and interleaved round differ.
-The reference generator calls `init_rs_char(8, 0x11d, 0, 1, 2, 0)` and `encode_rs_char` with the interleaving from Android 17 `VerityWriterAndroid::EncodeFEC`.
-Only the generated parity bytes are included; no LGPL source is distributed.
-
-Run `sha256sum -c SHA256SUMS` from this directory.
diff --git a/tests/fixtures/fec/SHA256SUMS b/tests/fixtures/fec/SHA256SUMS
deleted file mode 100644
index 06ccfde..0000000
--- a/tests/fixtures/fec/SHA256SUMS
+++ /dev/null
@@ -1,2 +0,0 @@
-ee94e02ccf9b3e11fad2939dcf1e38cd1439b86436c457bf3dc42256811f1681  fec-one-block.bin
-75ca5f457bae225fcb8191f4ef8746743019c1eb4e330d1321f56b956441009a  fec-300-block.bin
diff --git a/tests/fixtures/lz4/LICENSE b/tests/fixtures/lz4/LICENSE
deleted file mode 100644
index a1221be..0000000
--- a/tests/fixtures/lz4/LICENSE
+++ /dev/null
@@ -1,25 +0,0 @@
-BSD 2-Clause License
-
-Copyright (c) 2026, Milestone 6a proof contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/tests/fixtures/lz4/README.md b/tests/fixtures/lz4/README.md
deleted file mode 100644
index 5e8ba8b..0000000
--- a/tests/fixtures/lz4/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# Frozen Milestone 6a fixtures
-
-These files contain only the raw and expected block bytes needed by the Milestone 6b1 Rust boundary tests.
-They were extracted without transformation from the frozen Milestone 6a fixtures produced under the BSD-2-Clause license in `LICENSE`.
-
-The source proof pins AOSP `platform/external/lz4` commit `734e07032602e9a72fcc9701028b0aee45147fcd` and AOSP `platform/system/update_engine` commit `dc84c2552b2d4cf00d2a843cb1c091d99d0499f1`.
-
-| Case | Raw bytes | Stored bytes | Algorithm | Level | Layout |
-| --- | ---: | ---: | --- | ---: | --- |
-| `lz4-no-postfix` | 1024 | 768 | LZ4 | implicit acceleration 1 | trailing zero padding |
-| `lz4hc9-no-postfix` | 1536 | 1152 | LZ4HC | 9 | trailing zero padding |
-| `zero-padding-layout` | 800 | 608 | LZ4 | implicit acceleration 1 | 32 raw bytes, then 576 stored bytes with leading zero padding |
-
-Run `sha256sum -c SHA256SUMS` from this directory to verify every fixture file.
diff --git a/tests/fixtures/lz4/SHA256SUMS b/tests/fixtures/lz4/SHA256SUMS
deleted file mode 100644
index e432239..0000000
--- a/tests/fixtures/lz4/SHA256SUMS
+++ /dev/null
@@ -1,7 +0,0 @@
-4054755099cdd5b41a7957816ba51a24e989dab110f702783743bc080dbf7fbd  LICENSE
-d0f1ef7cd255d13146f34b70060f21a545428534feeb90837aace772c80331dc  lz4-no-postfix.raw
-6ea395fcef53c8e4de2fc708f4c8e1db7de05b53e48a891c77cbebee4e914e65  lz4-no-postfix.lz4
-ae91406138d4876551426d6e267b62e15a297e4f4d06a807a1adfce08440af88  lz4hc9-no-postfix.raw
-12a28b1f3d4cc5f8b0bfa534f062abae2b9bdbcd886fa2d657cf81e10b2e273e  lz4hc9-no-postfix.lz4
-9ec1afaf310fcf60f084bae0daca993d6ff54966a5bae97f4c0bce71db996920  zero-padding-layout.raw
-1e5b41d7f2e7c5d541a65b683be0c357da12241a036509853962e8888e900c87  zero-padding-layout.lz4
diff --git a/tests/fixtures/lz4diff/LICENSE.lz4 b/tests/fixtures/lz4diff/LICENSE.lz4
deleted file mode 100644
index a1221be..0000000
--- a/tests/fixtures/lz4diff/LICENSE.lz4
+++ /dev/null
@@ -1,25 +0,0 @@
-BSD 2-Clause License
-
-Copyright (c) 2026, Milestone 6a proof contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/tests/fixtures/lz4diff/LICENSE.puffin b/tests/fixtures/lz4diff/LICENSE.puffin
deleted file mode 100644
index f6d41c6..0000000
--- a/tests/fixtures/lz4diff/LICENSE.puffin
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2017 The ChromiumOS Authors
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/tests/fixtures/lz4diff/README.md b/tests/fixtures/lz4diff/README.md
deleted file mode 100644
index d6dbb09..0000000
--- a/tests/fixtures/lz4diff/README.md
+++ /dev/null
@@ -1,29 +0,0 @@
-# Frozen LZ4DIFF operation fixtures
-
-These static fixtures exercise complete version-1 `LZ4DIFF` operation data.
-Each case keeps its complete container patch. Tests deterministically build the
-small physical source/target blocks from canonical fixtures when those bytes are
-derivable from pinned upstream references.
-
-The LZ4, LZ4HC9, and zero-padding source and target bytes come unchanged from the Milestone 6a reference proof.
-That proof pins AOSP `platform/external/lz4` commit `734e07032602e9a72fcc9701028b0aee45147fcd` and `platform/system/update_engine` commit `dc84c2552b2d4cf00d2a843cb1c091d99d0499f1`.
-The postfix target starts from the frozen LZ4 reference block and changes byte 23 with XOR `0x5a` before patch generation.
-The PUFFDIFF source, patch, and expected target come unchanged from ChromiumOS Puffin commit `343e23db1b4d81045e91a10244244893f5acd73b`.
-
-The LZ4DIFF protobuf and framing follow the pinned Android update_engine `lz4diff.proto`, `lz4diff_format.h`, and `lz4diff.cc` sources.
-The inner identity patches and the real postfix patch are frozen BSDIFF40 output from the reference BSDIFF algorithm in `bsdiff-android` 0.0.2.
-Fixture generation is separate from the extractor implementation.
-The extractor does not generate expected target bytes.
-
-| Case | Inner type | Destination layout | Postfix |
-| --- | --- | --- | --- |
-| `lz4-bsdiff` | BSDIFF | LZ4, 1024 raw bytes in 768 physical bytes | None |
-| `lz4hc9-bsdiff` | BSDIFF | LZ4HC level 9, 1536 raw bytes in 1152 physical bytes | None |
-| `zero-padding-bsdiff` | BSDIFF | 32-byte raw block and leading-zero-padded LZ4 block | None |
-| `postfix-bsdiff` | BSDIFF | LZ4 reference recompression | BSDIFF40 with SHA-256 guard |
-| `raw-puffdiff` | PUFFDIFF | Uncompressed blocks | None |
-
-The LZ4-derived bytes retain the BSD-2-Clause license in `LICENSE.lz4`.
-The Puffin-derived bytes retain the BSD-3-Clause license in `LICENSE.puffin`.
-Run `sha256sum -c SHA256SUMS` from this directory to verify every retained
-frozen file.
diff --git a/tests/fixtures/lz4diff/SHA256SUMS b/tests/fixtures/lz4diff/SHA256SUMS
deleted file mode 100644
index 86bda4f..0000000
--- a/tests/fixtures/lz4diff/SHA256SUMS
+++ /dev/null
@@ -1,7 +0,0 @@
-4cd1380f674ea78e86276bc9ce39ab88b45bbbccb96c611e18bdd7108c738cfa  lz4-bsdiff/patch.lz4diff
-43efe58bdcd3552ffcda9608aa72a9f8189984af9cecd3143d468021e3b54c2d  lz4hc9-bsdiff/patch.lz4diff
-08fe5ecea8e3f48ec17665d50807516d63b17dcb729baa540566679a261228d4  postfix-bsdiff/patch.lz4diff
-4b9ce7db27ac550c6d7fd1e7f18a535c3a4616c8702fe9655a1d10839c681846  raw-puffdiff/patch.lz4diff
-de0527c0d2d27f378cb79aec447172e0efcfff9cc45d0be05c313a87a2069280  raw-puffdiff/source.bin
-649b17ae72a6d503a1176604d876923270cd467ae1d458a54e58575eda98766e  raw-puffdiff/target.bin
-3c5f3a2fa1bbf4dd938eb05dfb76cf53d4a95b70cb06e35faed6c560a7077260  zero-padding-bsdiff/patch.lz4diff
diff --git a/tests/fixtures/puffin/README.md b/tests/fixtures/puffin/README.md
index ce950fc..1bb1be5 100644
--- a/tests/fixtures/puffin/README.md
+++ b/tests/fixtures/puffin/README.md
@@ -5,10 +5,10 @@ The source files are `src/unittest_common.cc` and `src/patching_unittest.cc`.
 
 - `deflates-sample1.bin` is `kDeflatesSample1`.
 - `deflates-sample2.bin` is `kDeflatesSample2`.
-- `patch-1-to-2.puf` is `kPatch1To2`.
 - `patch-1-to-2-zucchini.puf` reconstructs `deflates-sample2.bin` from `deflates-sample1.bin` through three actual deflate streams on each side.
-- `patch-1-to-raw.puf` is `kPatch1ToNoDeflate`.
-- `raw-11-22-33-44.bin` is the expected output declared by `Patching1ToNoDeflateTest`.
+
+Only these three fixture payloads are retained because they are the minimal set
+needed by the product-contract PUFFDIFF/ZUCCHINI extraction test.
 
 The files retain Puffin's BSD-3-Clause license in `LICENSE` and Zucchini's BSD-3-Clause license in `LICENSE.zucchini`.
 Verify them with `sha256sum -c SHA256SUMS` from this directory.
diff --git a/tests/fixtures/puffin/SHA256SUMS b/tests/fixtures/puffin/SHA256SUMS
index fe00d01..ee4413e 100644
--- a/tests/fixtures/puffin/SHA256SUMS
+++ b/tests/fixtures/puffin/SHA256SUMS
@@ -1,6 +1,3 @@
 de0527c0d2d27f378cb79aec447172e0efcfff9cc45d0be05c313a87a2069280  deflates-sample1.bin
 649b17ae72a6d503a1176604d876923270cd467ae1d458a54e58575eda98766e  deflates-sample2.bin
-cb44443bb6312b8faac434d3bd7cf67419c78733b863a8c7ecf4815a071cb9bb  patch-1-to-2.puf
 826cd5b1a815cda2d13c2ca5733a9f9e99e0030d27178f2e9d44e47d73d4a9a8  patch-1-to-2-zucchini.puf
-20eef1e91c331d93f8d42f20b2875836aac05b2b2c96fb7d19e9a3a41043341f  patch-1-to-raw.puf
-bdbdce312f5762571faa17f3f4780235ed2c54f966c0f60dace1cddd2634f4f3  raw-11-22-33-44.bin
diff --git a/tests/fixtures/puffin/deflates-sample1.bin b/tests/fixtures/puffin/deflates-sample1.bin
new file mode 100644
index 0000000000000000000000000000000000000000..3bfad73a72fd1e3307444a8d7a66d2a7c0222dc9
GIT binary patch
literal 17
YcmWesN=`{iOJrp*W@bocVQ>ir03kmEUjP6A

literal 0
HcmV?d00001

diff --git a/tests/fixtures/puffin/deflates-sample2.bin b/tests/fixtures/puffin/deflates-sample2.bin
new file mode 100644
index 0000000000000000000000000000000000000000..a5ae9f565d494da1912b5ed3119fc6b8690e6083
GIT binary patch
literal 22
dcmYdJNlHs(WiU=-WM%mEpOJ}~g*BOl0RTip1q1*9

literal 0
HcmV?d00001

diff --git a/tests/fixtures/puffin/patch-1-to-2-zucchini.puf b/tests/fixtures/puffin/patch-1-to-2-zucchini.puf
new file mode 100644
index 0000000000000000000000000000000000000000..948ff9dfb6b44e0cb7ef03408962e128d6c2a860
GIT binary patch
literal 176
zcmWFtbu(mOU<l@56jJA6;Sdlo0+Im&TtG5GKu8EA5&<MD1T=(LIaV+VSV+iAsc<oY
zm3asRaItdCU<9gT0;?(jlB^sjK&liK7{xOf7>=CUyw^seJKag(g2;XU-__n>lZ#qk
ze|6I1t4I)@`#O8N$Fz*T%AQooz80Tv+f*6S=AXJ7_POomb#pVG8~q1aykj_me#tjD
O3p{rEr(V!lAqfEaA2FW*

literal 0
HcmV?d00001

diff --git a/tests/fixtures/zucchini/LICENSE b/tests/fixtures/zucchini/LICENSE
deleted file mode 100644
index 2ae33ee..0000000
--- a/tests/fixtures/zucchini/LICENSE
+++ /dev/null
@@ -1,29 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2026, dumpbot contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice,
-   this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/tests/fixtures/zucchini/README.md b/tests/fixtures/zucchini/README.md
deleted file mode 100644
index 642976c..0000000
--- a/tests/fixtures/zucchini/README.md
+++ /dev/null
@@ -1,37 +0,0 @@
-# Zucchini fixture provenance
-
-These fixtures use the BSD-3-Clause terms in `LICENSE`.
-`SHA256SUMS` records every binary fixture digest.
-
-The compact `annotation-jvm` DEX pair is retained as a native parity
-regression for annotation-heavy JVM metadata.
-
-The NoOp patch is the complete serialized fixture from the pinned upstream `patch_read_write_unittest.cc` field layout used by the Milestone 5a proof.
-
-The DEX and ELF fixtures were generated by the audited proof tooling from:
-
-- AOSP `external/zucchini` at `e256025d9d9c906caba814fd7b99a311ac8b8ec1`
-- AOSP `external/libchrome` at `0aba0dccfcd93d8303678a4beb61594f7582c73c`
-- Clang 22 for the x86-64 ELF pair
-
-The small DEX files are deterministic DEX 035 files.
-The ELF files cover x86, x86-64, AArch32, and AArch64 reference correction.
-
-The large DEX pair contains 65,537 strings, one `const-string` 16-bit reference to index 2, and one `const-string/jumbo` 32-bit reference to index 65,536.
-The pair was generated bytewise as DEX 035 and patched with the pinned proof's `GenerateBuffer` fixture tool.
-The target changes one same-length string while preserving both code references.
-`dex-large-unsafe16.zuc` changes reference-delta entry 5 from encoded zero to encoded `+2`.
-This resolves the 16-bit writer to the existing jumbo target at index 65,536 and must fail in preflight.
-The expected bytes are stored independently and are not constructed by the adapter tests.
-
-Integration tests wrap canonical `*.zuc` patches with Brotli at runtime.
-They use quality 9 and lgwin 20 to match the original fixture-generation settings:
-
-```sh
-brotli --quality=9 --lgwin=20 --stdout input.zuc > input.zuc.br
-```
-
-Malformed wrapper cases are synthesized in test code from two deterministic inputs:
-
-- raw bytes `not a Brotli stream\n` (intentionally not Brotli), and
-- Brotli-compressed bytes of `not a zucchini patch` (valid Brotli, invalid inner patch).
diff --git a/tests/fixtures/zucchini/SHA256SUMS b/tests/fixtures/zucchini/SHA256SUMS
deleted file mode 100644
index 451cc98..0000000
--- a/tests/fixtures/zucchini/SHA256SUMS
+++ /dev/null
@@ -1,25 +0,0 @@
-bdf755e070b6cba4f0ea478130c261906c12c0f1fcd0a665effb24dda6db18b5  dex-large-new.dex
-193b1caac682a40ad87657e87e387e1b030013c700e79733bf56a8115324972f  annotation-jvm-new.dex
-2e49e0ab01d4a3f253d16bd305848b38aeec102ea7982dc4f641dcfa85bc7c25  annotation-jvm-old.dex
-764358162ba84969bd6ba9c6bdd7f67df8b6ee6a555e2529d9084cfe057b79e8  annotation-jvm.zuc
-c837542fb547d892cbc597a39951bc6b3b0398ec89ff76a472a5c0d720e05ae3  dex-large-old.dex
-ebad167e527b375967bef5932e7af4dd7317c4d905b4227f1ab5da6fdb2d4515  dex-large-unsafe16.zuc
-fef404d99db5d6e9570f6673a78a5a4d4dcf23616648812debd66d65947b5afc  dex-large.zuc
-63e76d95aaaa6bdcedf79b2a8f3b55736fb5e9899e021a6be5190fba2d820080  dex-new.dex
-3b06060663ae19133d71d72a1f3b40d9bf4716fb4d6fc83d7ae039d01e80e945  dex-old.dex
-88f7512d4fb07ef897804d370ab1db699104c8b72be3be36e29adb5970fed8d5  dex.zuc
-2664d1c48bf0a2a2e7b3f8b1a9bd38e08055580adf42f2d53ef6abd7dcc65f30  elf-arm32-new
-a5a51e66fb5f923113eeb1f5df5c020c715df6a16d691c5a6030e36d920c625c  elf-arm32-old
-852f01e48651fbcd093f6eb2f075fc59feb470413e79e6f9ddc16b9f2cdcec4c  elf-arm32.zuc
-5125780242c5b230291ba47102734e422e09255e66e6b711a0657aca8098b8b6  elf-arm64-new
-d101a04d15a4b975f01d179fbf8b98771acdb31edb71dca4d8de40fa88189ecb  elf-arm64-old
-0b6c484b0b8cfc2c22ff0257a1e3677e36948bb2f8062a099e88fa4cc4ddf9d7  elf-arm64.zuc
-1e2080509d361c7e87f3434a3ed2f7a9be1b6972fcfb48fb531f0311e5820d7c  elf-new
-32ae88b0151c4afff7b9a88524a554ce517055257ebdd17329fb23fefde75c55  elf-old
-9d5187d155ff0acbb22118ade13032b20d6efc1ebfaf95c970e83d8d2f33b9cd  elf-x86-new
-7eb3c69419c3221a489fa0ba12bfeb94d258f14212a8e108ee130a31c83dda3b  elf-x86-old
-3bd7d0fc9454f38707d6af56ba9d1382d8a700e7dbda0f4955dcffc748b93915  elf-x86.zuc
-7015ce4ab2589a48815f734366f01fa9c7553f06480274fd43e9ed85311afeaa  elf.zuc
-ff55ebfb1b1889f3d0544b00dfabed96de8e4e4234e857043dba47a7a210d019  noop-new.bin
-88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589  noop-old.bin
-dec6c4f3e44a1ae18c48efb1c25e59288ecaad04997b8668ce2de0abcf3342d9  noop.zuc
diff --git a/tests/native_artifact_fetch_test.py b/tests/native_artifact_fetch_test.py
index 21a1e80..dae9f14 100644
--- a/tests/native_artifact_fetch_test.py
+++ b/tests/native_artifact_fetch_test.py
@@ -1,4 +1,3 @@
-import concurrent.futures
 import hashlib
 import json
 import os
@@ -7,7 +6,6 @@
 import tarfile
 import tempfile
 import unittest
-from typing import Optional
 
 
 REPO_ROOT = pathlib.Path(__file__).resolve().parents[1]
@@ -33,13 +31,10 @@ def write_bundle(
     root: pathlib.Path,
     entries: dict[str, bytes],
     *,
-    include_extra_file: bool = False,
     include_traversal_entry: bool = False,
 ) -> pathlib.Path:
     extract_root = root / "linux-x86_64-gnu"
     write_tree(extract_root, entries)
-    if include_extra_file:
-        (extract_root / "rogue.txt").write_text("rogue", encoding="utf-8")
     archive = root / "bundle.tar.gz"
     with tarfile.open(archive, "w:gz") as tar:
         tar.add(extract_root, arcname="linux-x86_64-gnu")
@@ -50,13 +45,7 @@ def write_bundle(
     return archive
 
 
-def write_locks(
-    root: pathlib.Path,
-    archive: pathlib.Path,
-    *,
-    url: str,
-    sha_override: Optional[str] = None,
-) -> tuple[pathlib.Path, pathlib.Path]:
+def write_locks(root: pathlib.Path, archive: pathlib.Path, url: str) -> tuple[pathlib.Path, pathlib.Path]:
     checksums = {
         "lib/libotadump_zucchini.a": b"archive-bytes\n",
         "SHA256SUMS": b"sha-entry\n",
@@ -65,17 +54,16 @@ def write_locks(
         "provenance.txt": b"provenance\n",
     }
     lock_path = root / "ARTIFACT_LOCK.sha256"
-    lines = []
-    for relpath, content in checksums.items():
-        lines.append(f"{hashlib.sha256(content).hexdigest()}  {relpath}")
-    lock_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
-
-    digest = sha_override or sha256_file(archive)
+    lock_path.write_text(
+        "\n".join(f"{hashlib.sha256(content).hexdigest()}  {relpath}" for relpath, content in checksums.items())
+        + "\n",
+        encoding="utf-8",
+    )
     bundle = {
         "schema": 1,
         "commit": "9534f6e24296b1682d53cdac19da0b81fc97fcbc",
         "url": url,
-        "sha256": digest,
+        "sha256": sha256_file(archive),
         "extract_root": "linux-x86_64-gnu",
     }
     bundle_path = root / "ARTIFACT_BUNDLE_LOCK.json"
@@ -109,14 +97,12 @@ def run_fetch(
         checksum_lock: pathlib.Path,
         out_dir: pathlib.Path,
         cache_dir: pathlib.Path,
-        extra_env: Optional[dict[str, str]] = None,
+        preseed: pathlib.Path,
     ) -> subprocess.CompletedProcess[str]:
         env = os.environ.copy()
-        env.pop("OTADUMP_NATIVE_PRESEED", None)
+        env["OTADUMP_NATIVE_PRESEED"] = str(preseed)
         env.pop("OTADUMP_NATIVE_OFFLINE", None)
         env.pop("OTADUMP_NATIVE_CACHE", None)
-        if extra_env:
-            env.update(extra_env)
         return subprocess.run(
             [
                 "python3",
@@ -136,104 +122,28 @@ def run_fetch(
             check=False,
         )
 
-    def test_parallel_fetches_share_cache_and_atomic_winner(self) -> None:
+    def test_preseed_archive_fetch_populates_verified_output(self) -> None:
         archive = write_bundle(self.root, self.entries)
-        bundle_lock, checksum_lock = write_locks(self.root, archive, url=self.valid_url)
+        bundle_lock, checksum_lock = write_locks(self.root, archive, self.valid_url)
         out_dir = self.root / "out" / "linux-x86_64-gnu"
-        cache_dir = self.root / "cache"
-
-        def run_once() -> subprocess.CompletedProcess[str]:
-            return self.run_fetch(
-                bundle_lock,
-                checksum_lock,
-                out_dir,
-                cache_dir,
-                {"OTADUMP_NATIVE_PRESEED": str(archive)},
-            )
-
-        with concurrent.futures.ThreadPoolExecutor(max_workers=8) as pool:
-            results = list(pool.map(lambda _index: run_once(), range(8)))
-
-        for result in results:
-            self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertTrue((out_dir / "lib" / "libotadump_zucchini.a").is_file())
-        leftovers = [entry.name for entry in out_dir.parent.iterdir() if ".tmp-" in entry.name]
-        self.assertEqual(leftovers, [])
-
-    def test_url_policy_rejects_non_https(self) -> None:
-        archive = write_bundle(self.root, self.entries)
-        bundle_lock, checksum_lock = write_locks(self.root, archive, url=self.valid_url.replace("https://", "http://"))
-        result = self.run_fetch(bundle_lock, checksum_lock, self.root / "out" / "dir", self.root / "cache")
-        self.assertNotEqual(result.returncode, 0)
-        self.assertIn("must use HTTPS", result.stderr)
-
-    def test_url_policy_rejects_unpinned_host_path(self) -> None:
-        archive = write_bundle(self.root, self.entries)
-        bad_url = "https://github.com/AndroidDumps/otadump/archive/refs/heads/mainline.tar.gz"
-        bundle_lock, checksum_lock = write_locks(self.root, archive, url=bad_url)
-        result = self.run_fetch(bundle_lock, checksum_lock, self.root / "out" / "dir", self.root / "cache")
-        self.assertNotEqual(result.returncode, 0)
-        self.assertIn("host must be raw.githubusercontent.com", result.stderr)
+        result = self.run_fetch(bundle_lock, checksum_lock, out_dir, self.root / "cache", archive)
 
-    def test_strict_tree_verification_rejects_extra_unpinned_file(self) -> None:
-        preseed_dir = self.root / "preseed"
-        write_tree(preseed_dir, self.entries)
-        (preseed_dir / "extra.bin").write_bytes(b"x")
-        archive = write_bundle(self.root, self.entries)
-        bundle_lock, checksum_lock = write_locks(self.root, archive, url=self.valid_url)
-        result = self.run_fetch(
-            bundle_lock,
-            checksum_lock,
-            self.root / "out" / "dir",
-            self.root / "cache",
-            {"OTADUMP_NATIVE_PRESEED": str(preseed_dir)},
-        )
-        self.assertNotEqual(result.returncode, 0)
-        self.assertIn("unexpected native artifact file", result.stderr)
-
-    def test_tampered_archive_fails_checksum_lock(self) -> None:
-        archive = write_bundle(self.root, self.entries)
-        bundle_lock, checksum_lock = write_locks(
-            self.root,
-            archive,
-            url=self.valid_url,
-            sha_override="0" * 64,
-        )
-        result = self.run_fetch(
-            bundle_lock,
-            checksum_lock,
-            self.root / "out" / "dir",
-            self.root / "cache",
-            {"OTADUMP_NATIVE_PRESEED": str(archive)},
-        )
-        self.assertNotEqual(result.returncode, 0)
-        self.assertIn("archive checksum mismatch", result.stderr)
+        self.assertEqual(result.returncode, 0, result.stderr)
+        self.assertTrue((out_dir / "lib" / "libotadump_zucchini.a").is_file())
 
     def test_traversal_entry_is_rejected(self) -> None:
         archive = write_bundle(self.root, self.entries, include_traversal_entry=True)
-        bundle_lock, checksum_lock = write_locks(self.root, archive, url=self.valid_url)
+        bundle_lock, checksum_lock = write_locks(self.root, archive, self.valid_url)
         result = self.run_fetch(
             bundle_lock,
             checksum_lock,
-            self.root / "out" / "dir",
+            self.root / "out" / "linux-x86_64-gnu",
             self.root / "cache",
-            {"OTADUMP_NATIVE_PRESEED": str(archive)},
+            archive,
         )
-        self.assertNotEqual(result.returncode, 0)
-        self.assertIn("unsafe entry", result.stderr)
 
-    def test_offline_requires_cache_or_preseed(self) -> None:
-        archive = write_bundle(self.root, self.entries)
-        bundle_lock, checksum_lock = write_locks(self.root, archive, url=self.valid_url)
-        result = self.run_fetch(
-            bundle_lock,
-            checksum_lock,
-            self.root / "out" / "dir",
-            self.root / "cache",
-            {"OTADUMP_NATIVE_OFFLINE": "1"},
-        )
         self.assertNotEqual(result.returncode, 0)
-        self.assertIn("offline native artifact mode is enabled but cache is empty", result.stderr)
+        self.assertIn("unsafe entry", result.stderr)
 
 
 if __name__ == "__main__":
diff --git a/tests/python_smoke.py b/tests/python_smoke.py
index 7e23501..6be42a5 100644
--- a/tests/python_smoke.py
+++ b/tests/python_smoke.py
@@ -1,5 +1,4 @@
 from hashlib import sha256
-from inspect import signature
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from typing import Optional
@@ -60,13 +59,9 @@ def _payload(target: bytes, source: Optional[bytes] = None) -> bytes:
 
 
 def main() -> None:
-    assert issubclass(otadump.OtaDumpError, Exception)
-    extract_signature = str(signature(otadump.extract))
-    assert "partitions" in extract_signature
-    assert "source_dir=None" in extract_signature
-
     with TemporaryDirectory() as temporary_directory:
         temporary_path = Path(temporary_directory)
+
         full_target = b"full partition image"
         full_payload = temporary_path / "full.bin"
         full_payload.write_bytes(_payload(full_target))
@@ -86,43 +81,15 @@ def main() -> None:
         assert (delta_output / "system.img").read_bytes() == source
         assert source_image.read_bytes() == source
 
+        invalid_payload = temporary_path / "invalid.bin"
+        invalid_payload.write_bytes(b"invalid")
         try:
-            otadump.extract(
-                delta_payload,
-                temporary_path / "missing-source-output",
-                source_dir=temporary_path / "missing-source",
-            )
-        except otadump.OtaDumpError as error:
-            assert "Unable to open source partition image" in str(error)
-        else:
-            raise AssertionError("missing source image unexpectedly succeeded")
-
-        payload_file = temporary_path / "invalid.bin"
-        payload_file.write_bytes(b"invalid")
-
-        try:
-            otadump.extract(payload_file, temporary_path / "output")
+            otadump.extract(invalid_payload, temporary_path / "invalid-output")
         except otadump.OtaDumpError as error:
             assert str(error) == "Invalid payload file"
         else:
             raise AssertionError("invalid payload unexpectedly succeeded")
 
-        cancellation_token = otadump.CancellationToken()
-        cancellation_token.cancel()
-        cancellation_token.cancel()
-        cancelled_output = temporary_path / "cancelled-output"
-        try:
-            otadump.extract(
-                full_payload,
-                cancelled_output,
-                cancellation_token=cancellation_token,
-            )
-        except KeyboardInterrupt:
-            pass
-        else:
-            raise AssertionError("cancelled extraction unexpectedly succeeded")
-        assert not cancelled_output.exists()
-
 
 if __name__ == "__main__":
     main()

From a1f1badf9048d668a596cc6ea9f12bee61f8e9e7 Mon Sep 17 00:00:00 2001
From: Akhil Narang <me@akhilnarang.dev>
Date: Sun, 13 Sep 2026 00:05:02 +0530
Subject: [PATCH 42/42] Remove unreachable return in fetch script

Signed-off-by: Akhil Narang <me@akhilnarang.dev>
---
 scripts/fetch-native-artifact.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/scripts/fetch-native-artifact.py b/scripts/fetch-native-artifact.py
index daee375..a6aa586 100755
--- a/scripts/fetch-native-artifact.py
+++ b/scripts/fetch-native-artifact.py
@@ -252,9 +252,6 @@ def main() -> int:
 
         return publish_tree(extracted, out_dir, checksums)
 
-    return 0
-
-
 if __name__ == "__main__":
     try:
         raise SystemExit(main())